@@ -0,0 +1,13 @@
+---
+"emdash": patch
+"@emdash-cms/cloudflare": patch
+"@emdash-cms/plugin-test": patch
+---
+
+Fixes sandboxed plugin `ctx.taxonomies` mutations (`createTerm()`, `addEntryTerms()`, and `removeEntryTerms()`), `ctx.content.create()`, versioned content actions (`getVersioned()`, `publish()`, `unpublish()`, `schedule()`, `unschedule()`, `getTrashedVersioned()`, and `restore()`), and `ctx.comments.setStatus()` on Cloudflare when requests run across multiple Worker isolates. Content creation consistently uses runtime validation and hooks and preserves `translationOf` links instead of falling back to a plain database insert.
+
+Runner-created invocations without a content-create callback now receive `Content creation is not configured` rather than a database insert that bypasses runtime behavior. `createPluginTestHost()` supplies a database-backed callback with content-handler validation so transport-level tests can continue creating content and linked translations without starting the full EmDash runtime. It preserves the transport host's support for `data.slug` and `data.status`.
+
+Await these operation promises before returning from a plugin route or hook. Their RPC connection now lasts only for that invocation; unlike the previous loopback binding, it cannot support work that outlives the invocation.
+
+Publication after-hooks remain deferred. Same-entry actions attempted while an after-hook is running can return `CONTENT_ACTION_REENTRANT`; faster callback routing can expose this overlap in tests that assumed hooks had already finished. In runtime-host tests, call `await host.waitForDeferredTasks()` after an action before inspecting its after-hook effects or starting another action on the same entry. This method waits for queued deferred runtime work, including work those tasks enqueue; it does not run future scheduled tasks or wait for arbitrary unawaited plugin operations.
@@ -165,6 +165,10 @@ The runtime host groups its API by boundary:
 - `http` queues external responses and captures the requests that a plugin sends through `ctx.http.fetch()`.
 - `restart()` replaces the runtime and isolate while retaining D1, plugin storage, media storage, and plugin state.
 
+Call `await host.waitForDeferredTasks()` after an action to finish deferred runtime work, such as `content:afterPublish` hooks, before inspecting its effects or starting another action on the same entry. Same-entry actions can otherwise fail with `CONTENT_ACTION_REENTRANT` while an after-hook is running.
+
+The method also waits for deferred work queued by those tasks. It does not run future scheduled tasks or wait for arbitrary unawaited plugin promises. Continue to await plugin operations before returning from a route or hook.
+
 Call `dispose()` after each test. Disposal terminates the isolate and resets all bindings, so a later test cannot observe the previous host's database or media.
 
 Use the settings action and raw inspector to prove that a generated settings save reaches the production handler and does not persist plaintext:
 
@@ -45,6 +45,7 @@ import {
 	setTaxonomyWriteCallback,
 	setHttpFetchCallback,
 } from "./bridge.js";
+import { PluginRuntimeBridge } from "./runtime-bridge.js";
 import type { WorkerLoader, WorkerStub, PluginBridgeBinding, WorkerLoaderLimits } from "./types.js";
 import { generatePluginWrapper } from "./wrapper.js";
 
@@ -136,6 +137,9 @@ export class CloudflareSandboxRunner implements SandboxRunner {
 	private plugins = new Map<string, CloudflareSandboxedPlugin>();
 	private options: SandboxOptions;
 	private resolvedLimits: ResolvedLimits;
+	private contentCreate: SandboxContentCreateCallback | null = null;
+	private contentActions: ContentActionCallbacks | null;
+	private commentModerate: SandboxCommentModerateCallback | null;
 	private readonly contentCreateRuntimeId = crypto.randomUUID();
 	private readonly contentActionsRuntimeId = crypto.randomUUID();
 	private readonly taxonomyWriteRuntimeId = crypto.randomUUID();
@@ -150,6 +154,8 @@ export class CloudflareSandboxRunner implements SandboxRunner {
 
 	constructor(options: SandboxOptions) {
 		this.options = options;
+		this.contentActions = options.contentActions ?? null;
+		this.commentModerate = options.commentModerate ?? null;
 		this.resolvedLimits = resolveLimits(options.limits);
 		this.siteInfo = options.siteInfo;
 		if (options.httpFetch) {
@@ -179,14 +185,17 @@ export class CloudflareSandboxRunner implements SandboxRunner {
 	}
 
 	setCommentModerate(callback: SandboxCommentModerateCallback | null): void {
+		this.commentModerate = callback;
 		setCommentModerateCallback(callback);
 	}
 
 	setContentCreate(callback: SandboxContentCreateCallback | null): void {
+		this.contentCreate = callback;
 		setContentCreateCallback(this.contentCreateRuntimeId, callback);
 	}
 
 	setContentActions(callback: ContentActionCallbacks | null): void {
+		this.contentActions = callback;
 		setContentActionsCallback(this.contentActionsRuntimeId, callback);
 	}
 
@@ -262,6 +271,21 @@ export class CloudflareSandboxRunner implements SandboxRunner {
 			this.taxonomyWriteRuntimeId,
 			this.httpFetchKey,
 			this.mediaStorageKey,
+			// RPC parameters retain the originating isolate; loopback props only carry data.
+			(invocationId) =>
+				new PluginRuntimeBridge(
+					manifest.id,
+					normalizePluginCapabilities(manifest.capabilities || []),
+					invocationId,
+					{
+						contentCreate: this.contentCreate,
+						beforeContentWrite: this.options.beforeContentWrite,
+						contentActions: this.contentActions,
+						taxonomyWrite: this.options.taxonomyWrite,
+						commentModerate: this.commentModerate,
+						i18nConfig: getI18nConfig(),
+					},
+				),
 		);
 
 		this.plugins.set(pluginId, plugin);
@@ -325,6 +349,7 @@ class CloudflareSandboxedPlugin implements SandboxedPluginInstance {
 		private taxonomyWriteRuntimeId?: string,
 		private readonly httpFetchKey?: string,
 		private readonly mediaStorageKey?: string,
+		private readonly createRuntimeBridge?: (invocationId: string) => PluginRuntimeBridge,
 	) {
 		this.id = `${manifest.id}:${manifest.version}`;
 		this.workerName = isolateKey ? `${this.id}:${isolateKey}` : this.id;
@@ -472,7 +497,12 @@ class CloudflareSandboxedPlugin implements SandboxedPluginInstance {
 		const invocation = Promise.resolve().then(() => {
 			const worker = this.createWorker();
 			const entrypoint = worker.getEntrypoint<PluginEntrypoint>("default");
-			return entrypoint.invokeHook(hookName, event, invocationId);
+			return entrypoint.invokeHook(
+				hookName,
+				event,
+				invocationId,
+				this.createRuntimeBridge?.(invocationId),
+			);
 		});
 		return this.withWallTimeLimit(`hook:${hookName}`, invocationId, invocation);
 	}
@@ -499,7 +529,13 @@ class CloudflareSandboxedPlugin implements SandboxedPluginInstance {
 		const invocation = (async () => {
 			const worker = this.createWorker();
 			const entrypoint = worker.getEntrypoint<PluginEntrypoint>("default");
-			const routeResult = await entrypoint.invokeRoute(routeName, input, request, invocationId);
+			const routeResult = await entrypoint.invokeRoute(
+				routeName,
+				input,
+				request,
+				invocationId,
+				this.createRuntimeBridge?.(invocationId),
+			);
 			const envelope = getSandboxRouteErrorEnvelope(routeResult);
 			if (envelope) throw createSandboxRouteError(envelope.error.code);
 			return routeResult;
@@ -520,12 +556,18 @@ class CloudflareSandboxedPlugin implements SandboxedPluginInstance {
  * The RPC interface exposed by the plugin wrapper.
  */
 interface PluginEntrypoint {
-	invokeHook(hookName: string, event: unknown, invocationId: string): Promise<unknown>;
+	invokeHook(
+		hookName: string,
+		event: unknown,
+		invocationId: string,
+		runtimeBridge?: PluginRuntimeBridge,
+	): Promise<unknown>;
 	invokeRoute(
 		routeName: string,
 		input: unknown,
 		request: SerializedRequest,
 		invocationId: string,
+		runtimeBridge?: PluginRuntimeBridge,
 	): Promise<unknown>;
 }