{"id":98099,"date":"2026-10-13T19:50:00","date_gmt":"2026-10-13T23:50:00","guid":{"rendered":"https:\/\/overcentral.com\/en\/?p=98099"},"modified":"2026-09-29T08:06:45","modified_gmt":"2026-09-29T12:06:45","slug":"emdash-hook-execution-order-98099","status":"publish","type":"post","link":"https:\/\/overcentral.com\/en\/emdash-hook-execution-order-98099\/","title":{"rendered":"EmDash Hook Execution Order: Why Sequential Logic Is a Trap"},"content":{"rendered":"

Every WordPress developer knows the rule. Hook priority determines execution order. add_action( 'init', 'my_func', 10 );<\/code>codecodecodecode runs before add_action( 'init', 'my_func', 11 );<\/code>codecodecodecode. It’s predictable. It’s reliable. It’s the bedrock of countless plugin architectures.<\/p>\n

That advice is dangerous in EmDash<\/a>.<\/p>\n

The conventional wisdom about hook order doesn’t just shift in Cloudflare’s new CMS. It breaks entirely. If you’re migrating plugins or building new ones, assuming sequential execution will produce race conditions, silent failures, and data corruption that are nearly impossible to debug.<\/p>\n

Here’s why\u2014and what to do<\/a> about it.<\/p>\n

The WordPress Assumption \u2014 The Priority Queue Mentality<\/h2>\n

WordPress uses a global hook registry stored in memory. When do_action( 'posts:published' )<\/code>codecodecodecode fires, the system walks through every registered callback sorted by a numeric priority parameter. Within the same priority level, callbacks execute sequentially in the order they were added.<\/p>\n

This creates a deterministic chain. Plugin A finishes. Plugin B starts. Plugin B finishes. Plugin C starts. You can trace the exact path of execution through your entire plugin stack.<\/p>\n

Developers exploit this constantly. A caching plugin hooks into save_post<\/code>codecodecodecode at priority 10. An SEO plugin hooks into the same event at priority 15, knowing the cache was already cleared. The system guarantees that ordering. It’s not a convention\u2014it’s an architectural promise.<\/p>\n

EmDash makes no such promise.<\/p>\n

How EmDash Actually Executes Hooks \u2014 The Isolate Paradigm<\/h2>\n

EmDash is built on Cloudflare Workers<\/a> and V8 isolates. When a hook like posts:published<\/code>codecodecodecode fires, EmDash doesn’t walk through a global PHP array. It dispatches an event to every registered plugin. Each plugin’s callback runs inside its own Dynamic Worker\u2014a completely isolated V8 context.<\/p>\n

These workers spin up in milliseconds, execute the callback, and spin back down. From the perspective of the main application thread, they run in parallel<\/em>.<\/p>\n

There is no global priority queue. There is no shared execution context. Plugin A and Plugin B, both listening to the same hook, execute concurrently. The WordPress advice\u2014”set your priority to 10 or 20 to control order”\u2014is not just wrong in EmDash. It’s a dangerous illusion.<\/p>\n

The priority<\/code>codecodecodecode parameter in EmDash’s definePlugin<\/code>codecodecodecode function is effectively decorative for cross-plugin ordering. It controls the order plugins are registered<\/em> in the system, not the order they execute<\/em>. Two workers cannot wait on each other without explicit orchestration.<\/p>\n

The posts:published<\/code> Hook \u2014 A Concrete Example<\/h2>\n

The source material for EmDash shows a plugin that sends an email when a post is published. It declares two capabilities: read_content<\/code>codecodecodecode and email_sent<\/code>codecodecodecode. The hook is posts:published<\/code>codecodecodecode.<\/p>\n

Imagine a second plugin that logs the publication to an external analytics service. Both plugins hook into the same event. In WordPress, you’d set the logging plugin to priority 5 and the email plugin to priority 10. The log writes first. The email sends second. Ordered. Predictable.<\/p>\n

In EmDash, both plugins receive the event simultaneously. The log worker spins up, reads the post content, and makes an HTTP request to your analytics endpoint. The email worker spins up, reads the post content, and sends an SMTP message.<\/p>\n

Neither worker knows the other exists. The log might complete first. The email might complete first. The HTTP request from the log worker might fail because the email worker’s outbound call consumed a shared resource limit. These are race conditions you cannot reproduce in a local testing environment that uses a single-threaded Node.js process.<\/p>\n

The deeper problem is that many plugins implicitly depend on state set by other plugins. An SEO plugin might write meta fields during posts:published<\/code>codecodecodecode. A social-sharing plugin might read those fields during the same hook. In WordPress, the execution order guarantees the fields exist. In EmDash, the social-sharing plugin might read stale or empty values.<\/p>\n

When Order Actually Matters (And How to Enforce It)<\/h2>\n

The most common scenario where order matters is a cascading operation: update a post meta field, regenerate a sitemap, purge the CDN cache. In WordPress, this is a simple hook chain with increasing priority values. In EmDash, three isolated workers can step on each other.<\/p>\n

The fix is counterintuitive. Don’t try to enforce cross-plugin ordering. Instead, build a single orchestrator plugin that sequences its own internal operations.<\/p>\n

EmDash provides hooks through the definePlugin<\/code>codecodecodecode function, but you can also use standard JavaScript async\/await<\/code>codecodecodecode patterns inside a single plugin. A single Dynamic Worker runs your entire callback sequentially. If you need to update meta, regenerate a sitemap, and purge cache, do it in one plugin with three internal steps.<\/p>\n

“`javascript<\/p>\n

definePlugin({<\/p>\n

id: ‘my-orchestrator’,<\/p>\n

capabilities: [‘read_content’, ‘write_content’, ‘cache_purge’],<\/p>\n

hooks: {<\/p>\n

‘posts:published’: async ({ context, post }) => {<\/p>\n

\/\/ Step 1: Update meta<\/p>\n

await context.updateMeta(post.id, { sitemap_changed: true });<\/p>\n

\/\/ Step 2: Regenerate sitemap<\/p>\n

await context.regenerateSitemap();<\/p>\n

\/\/ Step 3: Purge cache<\/p>\n

await context.purgeCDN();<\/p>\n

}<\/p>\n

}<\/p>\n

});<\/p>\n

“`<\/p>\n

This runs inside a single isolate. No parallel execution. No race conditions. No dependency on other plugins.<\/p>\n

If you must coordinate across multiple plugins, use EmDash’s internal event bus or a shared D1 database table as a coordination layer. One plugin writes a completion marker. The next plugin reads it. This is slower than WordPress’s shared memory model, but it’s safe.<\/p>\n

A hidden variable here is the file system. EmDash loads plugins based on file globs in the src\/plugins\/<\/code>codecodecodecode directory. Unlike WordPress’s database-driven plugin registry, the order your operating system returns file names\u2014which varies by filesystem, OS, and even directory fragmentation\u2014influences the order plugins are registered<\/em>. This makes relying on registration order even more fragile than it already is.<\/p>\n

Testing for Hook Execution Order<\/h2>\n

The EmDash playground is useful for exploring the admin interface. It’s not useful for testing race conditions.<\/p>\n

You need integration tests that account for non-deterministic execution. Use Promise.allSettled()<\/code>codecodecodecode patterns and assert on final system state, not on the sequence of side effects. A test that passes because Plugin A ran first today might fail tomorrow.<\/p>\n

“`javascript<\/p>\n

\/\/ Bad test: assumes execution order<\/p>\n

test(’email sends after log’, async () => {<\/p>\n

await triggerPublish();<\/p>\n

expect(logSpy).toHaveBeenCalled();<\/p>\n

expect(emailSpy).toHaveBeenCalled(); \/\/ May fail if email ran first<\/p>\n

});<\/p>\n

\/\/ Good test: asserts final state<\/p>\n

test(‘both plugins complete’, async () => {<\/p>\n

await triggerPublish();<\/p>\n

await new Promise(r => setTimeout(r, 2000)); \/\/ Let isolates settle<\/p>\n

expect(await getLogCount()).toBe(1);<\/p>\n

expect(await getEmailCount()).toBe(1);<\/p>\n

});<\/p>\n

“`<\/p>\n

The EmDash CLI includes a test<\/code>codecodecodecode command that spins up a local D1 database and isolates. Use it. Run your tests multiple times in rapid succession. If you ever see a flaky failure, you have an ordering dependency you need to collapse into a single plugin.<\/p>\n

The AI Agent Wildcard<\/h2>\n

EmDash ships with a built-in MCP server. This means AI agents<\/a> can trigger hooks programmatically. An agent might call posts:published<\/code>codecodecodecode directly, bypassing the normal UI flow.<\/p>\n

When an agent triggers a hook, it doesn’t respect any implicit ordering you might have built around user workflows. The agent fires the event, and all registered workers spin up in parallel. If your plugins depend on a specific chain of side effects, an agent can silently break that chain.<\/p>\n

The solution is the same: single-plugin orchestration with explicit async\/await<\/code>codecodecodecode sequencing. Design your plugins as if every hook call is the first and only call. Stateless. Idempotent. Independent.<\/p>\n

EmDash’s architecture isn’t a bug. It’s a feature that forces you to write plugins that are truly isolated. That’s a better foundation for a secure, scalable CMS than WordPress’s shared-everything model. But it requires unlearning the priority queue mentality.<\/p>\n

Let go of the sequence. Embrace the isolate.<\/p>\n","protected":false},"excerpt":{"rendered":"

Every WordPress developer knows the rule. Hook priority determines execution order. add_action( ‘init’, ‘my_func’, 10 );codecodecodecode runs before add_action( ‘init’, ‘my_func’, 11 );codecodecodecode. It’s predictable. It’s reliable. It’s the bedrock of countless plugin architectures. That advice is dangerous in EmDash. The conventional wisdom about hook order doesn’t just shift in Cloudflare’s new CMS. It breaks […]<\/p>\n","protected":false},"author":7,"featured_media":100456,"comment_status":"closed","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"fifu_image_url":"https:\/\/cards.overcentral.com\/cards\/en\/98099.png","fifu_image_alt":"EmDash Hook Execution Order: Why Sequential Logic Is a Trap","footnotes":""},"categories":[31],"tags":[],"class_list":["post-98099","post","type-post","status-publish","format-standard","has-post-thumbnail","category-technology"],"fifu_image_url":"https:\/\/cards.overcentral.com\/cards\/en\/98099.png","fifu_image_alt":"EmDash Hook Execution Order: Why Sequential Logic Is a Trap","_links":{"self":[{"href":"https:\/\/overcentral.com\/en\/wp-json\/wp\/v2\/posts\/98099","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/overcentral.com\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/overcentral.com\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/overcentral.com\/en\/wp-json\/wp\/v2\/users\/7"}],"replies":[{"embeddable":true,"href":"https:\/\/overcentral.com\/en\/wp-json\/wp\/v2\/comments?post=98099"}],"version-history":[{"count":1,"href":"https:\/\/overcentral.com\/en\/wp-json\/wp\/v2\/posts\/98099\/revisions"}],"predecessor-version":[{"id":100457,"href":"https:\/\/overcentral.com\/en\/wp-json\/wp\/v2\/posts\/98099\/revisions\/100457"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/overcentral.com\/en\/wp-json\/wp\/v2\/media\/100456"}],"wp:attachment":[{"href":"https:\/\/overcentral.com\/en\/wp-json\/wp\/v2\/media?parent=98099"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/overcentral.com\/en\/wp-json\/wp\/v2\/categories?post=98099"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/overcentral.com\/en\/wp-json\/wp\/v2\/tags?post=98099"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}