emdash 0.13.0 → 0.15.0

package/src/emdash-runtime.ts

@@ -247,11 +247,21 @@ export interface RuntimeDependencies {
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	createStorage: ((config: any) => Storage) | null;
 	sandboxEnabled: boolean;
+	/** sandbox: false escape hatch - load sandboxed plugins in-process */
+	sandboxBypassed?: boolean;
 	/** Media provider entries from virtual module */
 	mediaProviderEntries?: MediaProviderEntry[];
 	sandboxedPluginEntries: SandboxedPluginEntry[];
 	/** Factory function matching SandboxRunnerFactory signature */
-	createSandboxRunner: ((opts: { db: Kysely<Database> }) => SandboxRunner) | null;
+	createSandboxRunner:
+		| ((opts: {
+				db: Kysely<Database>;
+				mediaStorage?: {
+					upload(options: { key: string; body: Uint8Array; contentType: string }): Promise<unknown>;
+					delete(key: string): Promise<unknown>;
+				};
+		  }) => SandboxRunner)
+		| null;
 }
 
 /**
@@ -393,7 +403,7 @@ export class EmDashRuntime {
 	get db(): Kysely<Database> {
 		const ctx = getRequestContext();
 		if (ctx?.db) {
-			// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- db in context is set by middleware with correct type
+			// eslint-disable-next-line typescript/no-unsafe-type-assertion -- db in context is set by middleware with correct type
 			return ctx.db as Kysely<Database>;
 		}
 		return this._db;
@@ -428,6 +438,16 @@ export class EmDashRuntime {
 		return sandboxRunner;
 	}
 
+	/**
+	 * Whether the sandbox bypass mode (sandbox: false) is active.
+	 * Marketplace install/update handlers use this to skip the
+	 * SANDBOX_NOT_AVAILABLE gate, since the bypass path loads
+	 * marketplace plugins in-process via syncMarketplacePlugins().
+	 */
+	isSandboxBypassed(): boolean {
+		return this.runtimeDeps.sandboxBypassed === true;
+	}
+
 	/**
 	 * Tick the cron system from request context (piggyback mode).
 	 * Call this from middleware on each request to ensure cron tasks
@@ -519,6 +539,17 @@ export class EmDashRuntime {
 	 */
 	async syncMarketplacePlugins(): Promise<void> {
 		if (!this.config.marketplace) return;
+
+		// In sandbox bypass mode (sandbox: false), the noop runner reports
+		// unavailable but we still want admin metadata for newly installed
+		// marketplace plugins to refresh in-process. Hooks/routes still won't
+		// execute (matches the cold-start bypass behavior), but Configure
+		// links and admin pages appear immediately.
+		if (this.runtimeDeps.sandboxBypassed) {
+			await this.syncMarketplacePluginsBypassed();
+			return;
+		}
+
 		await this.syncSandboxedSourcePlugins("marketplace");
 	}
 
@@ -537,8 +568,8 @@ export class EmDashRuntime {
 	/**
 	 * Internal: reconcile in-memory sandboxed-plugin state with the
 	 * `_plugin_state` table for the given source tier. Shared
-	 * implementation behind `syncMarketplacePlugins` and
-	 * `syncRegistryPlugins`.
+	 * implementation behind {@link syncMarketplacePlugins} and
+	 * {@link syncRegistryPlugins}.
 	 *
 	 * Each source tier has its own key set in `${source}PluginKeys` so a
 	 * sync for one tier doesn't invalidate the other.
@@ -652,6 +683,173 @@ export class EmDashRuntime {
 		}
 	}
 
+	/**
+	 * Remove a plugin from the in-memory pipeline lists by ID.
+	 * Mutates allPipelinePlugins and configuredPlugins in place.
+	 */
+	private removePluginFromLists(pluginId: string): void {
+		const allIdx = this.allPipelinePlugins.findIndex((p) => p.id === pluginId);
+		if (allIdx !== -1) this.allPipelinePlugins.splice(allIdx, 1);
+		const configIdx = this.configuredPlugins.findIndex((p) => p.id === pluginId);
+		if (configIdx !== -1) this.configuredPlugins.splice(configIdx, 1);
+	}
+
+	/**
+	 * Sync marketplace plugin metadata in sandbox: false bypass mode.
+	 *
+	 * In bypass mode the noop runner can't load plugins, but admin pages,
+	 * widgets, and route metadata still need to refresh in-process when an
+	 * admin installs/updates/uninstalls a marketplace plugin. Otherwise the
+	 * admin UI shows stale data until the server restarts.
+	 *
+	 * Hooks and routes still won't execute under bypass (matches the
+	 * cold-start bypass behavior in loadMarketplacePluginsBypassed).
+	 *
+	 * Known limitation: bypass plugins are loaded via `import(dataUrl)`,
+	 * which Node's ESM cache keys on the full URL. Updates create fresh
+	 * module objects, but old ones remain cached for the worker's lifetime.
+	 * In practice this is a few KB per update — only matters for sites with
+	 * very frequent marketplace updates running long-lived processes. The
+	 * fix would be vm.SourceTextModule for explicit lifecycle management.
+	 */
+	private async syncMarketplacePluginsBypassed(): Promise<void> {
+		if (!this.storage) return;
+		try {
+			const stateRepo = new PluginStateRepository(this.db);
+			const marketplaceStates = await stateRepo.getMarketplacePlugins();
+
+			const desired = new Map<string, string>();
+			for (const state of marketplaceStates) {
+				this.pluginStates.set(state.pluginId, state.status);
+				if (state.status === "active") {
+					this.enabledPlugins.add(state.pluginId);
+				} else {
+					this.enabledPlugins.delete(state.pluginId);
+				}
+				if (state.status !== "active") continue;
+				desired.set(state.pluginId, state.marketplaceVersion ?? state.version);
+			}
+
+			// Drop metadata for plugins no longer active.
+			const toRemove: string[] = [];
+			for (const pluginId of marketplaceManifestCache.keys()) {
+				if (!desired.has(pluginId)) toRemove.push(pluginId);
+			}
+			for (const pluginId of toRemove) {
+				// Fire plugin:deactivate hook before removal
+				const resolved = this.allPipelinePlugins.find((p) => p.id === pluginId);
+				if (resolved) {
+					try {
+						const deactivateHook = resolved.hooks?.["plugin:deactivate"];
+						if (deactivateHook) {
+							const handler =
+								typeof deactivateHook === "function" ? deactivateHook : deactivateHook.handler;
+							if (typeof handler === "function") {
+								// Sandbox-bypass cleanup: the plugin context isn't constructable
+								// here (no DB binding, no media, etc.), but well-behaved
+								// deactivate hooks should be no-op safe. If a hook does require
+								// ctx, it throws and the surrounding catch logs it.
+								// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- best-effort cleanup; see comment above
+								await handler({ pluginId }, {} as never);
+							}
+						}
+					} catch (err) {
+						console.warn(`[emdash] plugin:deactivate hook failed for ${pluginId}:`, err);
+					}
+				}
+				marketplaceManifestCache.delete(pluginId);
+				sandboxedRouteMetaCache.delete(pluginId);
+				// Remove from pipeline lists too (mutate in place since the
+				// arrays are readonly references but mutable contents)
+				this.removePluginFromLists(pluginId);
+				this.enabledPlugins.delete(pluginId);
+			}
+
+			// Load plugin code, adapt as trusted plugins, and add to pipeline lists
+			const { adaptSandboxEntry } = await import("./plugins/adapt-sandbox-entry.js");
+			const newPlugins: ResolvedPlugin[] = [];
+			for (const [pluginId, version] of desired) {
+				const bundle = await loadBundleFromR2(this.storage, pluginId, version);
+				if (!bundle) {
+					console.warn(`EmDash: Marketplace plugin ${pluginId}@${version} not found in R2`);
+					continue;
+				}
+				marketplaceManifestCache.set(pluginId, {
+					id: bundle.manifest.id,
+					version: bundle.manifest.version,
+					admin: bundle.manifest.admin,
+				});
+				if (bundle.manifest.routes.length > 0) {
+					const routeMetaMap = new Map<string, RouteMeta>();
+					for (const entry of bundle.manifest.routes) {
+						const normalized = normalizeManifestRoute(entry);
+						routeMetaMap.set(normalized.name, { public: normalized.public === true });
+					}
+					sandboxedRouteMetaCache.set(pluginId, routeMetaMap);
+				} else {
+					sandboxedRouteMetaCache.delete(pluginId);
+				}
+
+				// Skip if already in the pipeline at this version
+				const existing = this.allPipelinePlugins.find((p) => p.id === pluginId);
+				if (existing && existing.version === bundle.manifest.version) continue;
+
+				// Remove any older version
+				if (existing) {
+					this.removePluginFromLists(pluginId);
+				}
+
+				try {
+					const dataUrl = `data:text/javascript;base64,${Buffer.from(bundle.backendCode).toString("base64")}`;
+					// Dynamic data: import returns `any` from a base64-encoded module.
+					// We trust the bundle to be shaped like a plugin (built by plugin-cli);
+					// adaptSandboxEntry then validates fields it cares about.
+					// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- dynamic module from trusted bundle
+					const pluginModule = (await import(/* @vite-ignore */ dataUrl)) as Record<
+						string,
+						unknown
+					>;
+					const pluginDef = (pluginModule.default ?? pluginModule) as Parameters<
+						typeof adaptSandboxEntry
+					>[0];
+					const adapted = adaptSandboxEntry(pluginDef, {
+						id: bundle.manifest.id,
+						version: bundle.manifest.version,
+						entrypoint: "",
+						capabilities: bundle.manifest.capabilities ?? [],
+						allowedHosts: bundle.manifest.allowedHosts ?? [],
+						// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- adaptSandboxEntry copies storage through
+						storage: (bundle.manifest.storage ?? {}) as never,
+						adminPages: bundle.manifest.admin?.pages,
+						adminWidgets: bundle.manifest.admin?.widgets?.map((w) => ({
+							id: w.id,
+							title: w.title,
+							size:
+								w.size === "full" || w.size === "half" || w.size === "third" ? w.size : undefined,
+						})),
+					});
+					newPlugins.push(adapted);
+					this.allPipelinePlugins.push(adapted);
+					this.configuredPlugins.push(adapted);
+					this.enabledPlugins.add(adapted.id);
+				} catch (error) {
+					console.error(
+						`EmDash: Failed to load marketplace plugin ${pluginId}@${version} in-process:`,
+						error,
+					);
+				}
+			}
+
+			// If anything changed, rebuild the hook pipeline so new/removed
+			// plugins take effect immediately without a server restart.
+			if (toRemove.length > 0 || newPlugins.length > 0) {
+				await this.rebuildHookPipeline();
+			}
+		} catch (error) {
+			console.error("EmDash: Failed to sync marketplace plugins (bypass):", error);
+		}
+	}
+
 	/**
 	 * Create and initialize the runtime
 	 */
@@ -737,6 +935,11 @@ export class EmDashRuntime {
 		// rebuildHookPipeline() filters this to only enabled plugins.
 		const allPipelinePlugins: ResolvedPlugin[] = [...deps.plugins];
 
+		// Collected bypassed plugins (sandbox: false escape hatch).
+		// These need to be added to BOTH the pipeline (for hooks) AND the
+		// configuredPlugins list (for route dispatch).
+		const bypassedPluginsList: ResolvedPlugin[] = [];
+
 		// In dev mode, register a built-in console email provider.
 		// It participates in exclusive hook resolution like any other plugin —
 		// auto-selected when it's the sole provider, overridden when a real one is configured.
@@ -784,6 +987,53 @@ export class EmDashRuntime {
 			console.warn("[comments] Failed to register default moderator:", error);
 		}
 
+		// sandbox: false escape hatch - load sandboxed plugin entries in-process
+		// as trusted plugins (no isolation) so they participate in the hook pipeline.
+		// Block this on Cloudflare Workers where dynamic import(dataUrl) is not
+		// available and running untrusted code in-process is a security risk.
+		if (deps.sandboxBypassed && deps.sandboxedPluginEntries.length > 0) {
+			const isCfWorkers =
+				typeof navigator !== "undefined" &&
+				typeof navigator.userAgent === "string" &&
+				navigator.userAgent.includes("Cloudflare-Workers");
+			if (isCfWorkers) {
+				throw new Error(
+					"sandbox: false is not supported in Cloudflare Workers. " +
+						"Remove the sandbox: false option or use the Cloudflare sandbox runner.",
+				);
+			}
+			console.info(
+				"EmDash: Sandbox disabled (sandbox: false). " +
+					"Sandboxed plugins will run in-process without isolation.",
+			);
+			const bypassedPlugins = await EmDashRuntime.loadBypassedPlugins(deps.sandboxedPluginEntries);
+			for (const plugin of bypassedPlugins) {
+				allPipelinePlugins.push(plugin);
+				bypassedPluginsList.push(plugin);
+				// Respect plugin state: only enable if active or no record exists.
+				// Plugins an admin previously disabled should stay disabled.
+				const status = pluginStates.get(plugin.id);
+				if (status === undefined || status === "active") {
+					enabledPlugins.add(plugin.id);
+				}
+			}
+		}
+
+		// In bypass mode, also load marketplace plugins from R2 as trusted
+		// in-process plugins BEFORE pipeline creation. They need to be in the
+		// pipeline to participate in hook dispatch.
+		if (deps.sandboxBypassed && deps.config.marketplace && storage) {
+			const marketplaceBypassed = await EmDashRuntime.loadMarketplacePluginsBypassed(db, storage);
+			for (const plugin of marketplaceBypassed) {
+				allPipelinePlugins.push(plugin);
+				bypassedPluginsList.push(plugin);
+				const status = pluginStates.get(plugin.id);
+				if (status === undefined || status === "active") {
+					enabledPlugins.add(plugin.id);
+				}
+			}
+		}
+
 		// Filter to currently enabled plugins for the initial pipeline
 		const enabledPluginList = allPipelinePlugins.filter((p) => enabledPlugins.has(p.id));
 
@@ -795,13 +1045,14 @@ export class EmDashRuntime {
 		};
 		const pipeline = createHookPipeline(enabledPluginList, pipelineFactoryOptions);
 
-		// Load sandboxed plugins (build-time)
+		// Load sandboxed plugins (build-time, sandbox runner path)
 		const sandboxedPlugins = await phase("rt.sandbox", "Sandboxed plugins", () =>
-			EmDashRuntime.loadSandboxedPlugins(deps, db),
+			EmDashRuntime.loadSandboxedPlugins(deps, db, storage),
 		);
 
-		// Cold-start: load marketplace-installed plugins from site R2
-		if (deps.config.marketplace && storage) {
+		// Cold-start: load marketplace-installed plugins from site R2 via
+		// the sandbox runner. In bypass mode this was already handled above.
+		if (deps.config.marketplace && storage && !deps.sandboxBypassed) {
 			await phase("rt.market", "Marketplace plugins", () =>
 				EmDashRuntime.loadInstalledSandboxedPlugins(
 					"marketplace",
@@ -942,7 +1193,10 @@ export class EmDashRuntime {
 		return new EmDashRuntime({
 			db,
 			storage,
-			configuredPlugins: deps.plugins,
+			// Include bypassed sandboxed plugins in configuredPlugins so route
+			// dispatch can find them under sandbox: false (they're treated as
+			// trusted plugins for the duration of the bypass).
+			configuredPlugins: [...deps.plugins, ...bypassedPluginsList],
 			sandboxedPlugins,
 			sandboxedPluginEntries: deps.sandboxedPluginEntries,
 			hooks: pipeline,
@@ -997,7 +1251,7 @@ export class EmDashRuntime {
 		// path gives us a fresh singleton instead.
 		const ctx = getRequestContext();
 		if (ctx?.dbIsIsolated && ctx.db) {
-			// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- db in context is typed as unknown to avoid circular deps
+			// eslint-disable-next-line typescript/no-unsafe-type-assertion -- db in context is typed as unknown to avoid circular deps
 			return ctx.db as Kysely<Database>;
 		}
 
@@ -1115,12 +1369,84 @@ export class EmDashRuntime {
 		return storage;
 	}
 
+	/**
+	 * Load sandboxed plugin entries as trusted in-process plugins.
+	 * Used by the sandbox: false debugging escape hatch.
+	 *
+	 * Imports each plugin's bundled ESM code via a data URL, adapts it
+	 * with adaptSandboxEntry, and returns ResolvedPlugin objects ready
+	 * to be merged into the pipeline plugin list.
+	 */
+	private static async loadBypassedPlugins(
+		entries: SandboxedPluginEntry[],
+	): Promise<ResolvedPlugin[]> {
+		const { adaptSandboxEntry } = await import("./plugins/adapt-sandbox-entry.js");
+		const plugins: ResolvedPlugin[] = [];
+		for (const entry of entries) {
+			try {
+				const dataUrl = `data:text/javascript;base64,${Buffer.from(entry.code).toString("base64")}`;
+				// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- dynamic module from trusted bundle (built by plugin-cli); adaptSandboxEntry validates required fields.
+				const pluginModule = (await import(/* @vite-ignore */ dataUrl)) as Record<string, unknown>;
+				const pluginDef = (pluginModule.default ?? pluginModule) as Parameters<
+					typeof adaptSandboxEntry
+				>[0];
+				// PluginDescriptor.storage's TypeScript type is narrower than what
+				// adaptSandboxEntry actually accepts at runtime — it copies indexes
+				// through to PluginStorageConfig which supports composite indexes
+				// (string[][]). Pass the raw entry.storage with a structural cast
+				// to preserve composite index declarations.
+				// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- adaptSandboxEntry copies storage through to PluginStorageConfig which supports composite indexes
+				// Preserve admin metadata so plugin-management APIs can derive
+				// hasAdminPages / hasDashboardWidgets correctly. Without this,
+				// the admin UI hides Configure links and dashboard widgets for
+				// bypassed plugins even though they declared them.
+				// SandboxedPluginEntry uses looser types than PluginDescriptor
+				// (label?, size: string), so coerce to the descriptor shape.
+				const adminPages = entry.adminPages?.map((p) => ({
+					path: p.path,
+					label: p.label ?? p.path,
+					icon: p.icon,
+				}));
+				const adminWidgets:
+					| Array<{
+							id: string;
+							title?: string;
+							size?: "full" | "half" | "third";
+					  }>
+					| undefined = entry.adminWidgets?.map((w) => {
+					const size: "full" | "half" | "third" | undefined =
+						w.size === "full" || w.size === "half" || w.size === "third" ? w.size : undefined;
+					return { id: w.id, title: w.title, size };
+				});
+				const resolved = adaptSandboxEntry(pluginDef, {
+					id: entry.id,
+					version: entry.version,
+					entrypoint: "",
+					capabilities: entry.capabilities,
+					allowedHosts: entry.allowedHosts,
+					// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- adaptSandboxEntry copies storage through
+					storage: entry.storage as never,
+					adminPages,
+					adminWidgets,
+				});
+				plugins.push(resolved);
+				console.log(
+					`EmDash: Loaded plugin ${entry.id}:${entry.version} in-process (sandbox bypassed)`,
+				);
+			} catch (error) {
+				console.error(`EmDash: Failed to load sandboxed plugin ${entry.id} in-process:`, error);
+			}
+		}
+		return plugins;
+	}
+
 	/**
 	 * Load sandboxed plugins using SandboxRunner
 	 */
 	private static async loadSandboxedPlugins(
 		deps: RuntimeDependencies,
 		db: Kysely<Database>,
+		mediaStorage?: Storage | null,
 	): Promise<Map<string, SandboxedPluginInstance>> {
 		// Return cached plugins if already loaded
 		if (sandboxedPluginCache.size > 0) {
@@ -1128,26 +1454,56 @@ export class EmDashRuntime {
 		}
 
 		// Check if sandboxing is enabled
-		if (!deps.sandboxEnabled || deps.sandboxedPluginEntries.length === 0) {
+		if (!deps.sandboxEnabled) {
 			return sandboxedPluginCache;
 		}
 
 		// Create sandbox runner if not exists
 		if (!sandboxRunner && deps.createSandboxRunner) {
-			sandboxRunner = deps.createSandboxRunner({ db });
+			sandboxRunner = deps.createSandboxRunner({
+				db,
+				mediaStorage: mediaStorage
+					? {
+							upload: (opts) =>
+								mediaStorage.upload({
+									key: opts.key,
+									body: opts.body,
+									contentType: opts.contentType,
+								}),
+							delete: (key) => mediaStorage.delete(key),
+						}
+					: undefined,
+			});
 		}
 
 		if (!sandboxRunner) {
 			return sandboxedPluginCache;
 		}
 
-		// Check if the runner is actually available (has required bindings)
+		// Check if the runner is actually available (has required bindings).
+		// Warn regardless of whether there are plugins to load, so operators
+		// see the issue even if no marketplace plugins are installed yet.
 		if (!sandboxRunner.isAvailable()) {
-			console.debug("EmDash: Sandbox runner not available (missing bindings), skipping sandbox");
+			console.warn(
+				"EmDash: Plugin sandbox is configured but not available on this platform. " +
+					"Sandboxed plugins will not be loaded. " +
+					"If using @emdash-cms/sandbox-workerd/sandbox, ensure workerd is installed.",
+			);
+			return sandboxedPluginCache;
+		}
+
+		if (deps.sandboxedPluginEntries.length === 0) {
+			return sandboxedPluginCache;
+		}
+
+		// sandbox: false escape hatch is handled separately (before pipeline
+		// creation) via loadBypassedPlugins. If we somehow reach here with the
+		// flag set, just return — the plugins are already in the trusted pipeline.
+		if (deps.sandboxBypassed) {
 			return sandboxedPluginCache;
 		}
 
-		// Load each sandboxed plugin
+		// Load each sandboxed plugin via sandbox runner
 		for (const entry of deps.sandboxedPluginEntries) {
 			const pluginKey = `${entry.id}:${entry.version}`;
 			if (sandboxedPluginCache.has(pluginKey)) {
@@ -1201,10 +1557,26 @@ export class EmDashRuntime {
 		deps: RuntimeDependencies,
 		cache: Map<string, SandboxedPluginInstance>,
 	): Promise<void> {
-		// Ensure sandbox runner exists
+		// Ensure sandbox runner exists with media storage wired up.
+		// (storage here is the media Storage adapter from the runtime.)
 		if (!sandboxRunner && deps.createSandboxRunner) {
-			sandboxRunner = deps.createSandboxRunner({ db });
+			sandboxRunner = deps.createSandboxRunner({
+				db,
+				mediaStorage: {
+					upload: (opts) =>
+						storage.upload({
+							key: opts.key,
+							body: opts.body,
+							contentType: opts.contentType,
+						}),
+					delete: (key) => storage.delete(key),
+				},
+			});
 		}
+		// In sandbox bypass mode, marketplace plugins are loaded in-process
+		// BEFORE pipeline creation by EmDashRuntime.create(). Skip here.
+		if (deps.sandboxBypassed) return;
+
 		if (!sandboxRunner || !sandboxRunner.isAvailable()) {
 			return;
 		}
@@ -1270,6 +1642,106 @@ export class EmDashRuntime {
 		}
 	}
 
+	/**
+	 * Cold-start: load marketplace plugins in bypass mode (sandbox: false).
+	 *
+	 * Each active marketplace bundle is read, evaluated via data URL, adapted
+	 * with adaptSandboxEntry, and returned as a ResolvedPlugin. The caller is
+	 * responsible for merging these into allPipelinePlugins / configuredPlugins
+	 * BEFORE the hook pipeline is created, so hooks and routes register in
+	 * the trusted pipeline.
+	 *
+	 * Also caches manifest and route metadata so admin UI / getManifest() work.
+	 *
+	 * Returns ResolvedPlugins to be merged into the pipeline.
+	 */
+	private static async loadMarketplacePluginsBypassed(
+		db: Kysely<Database>,
+		storage: Storage,
+	): Promise<ResolvedPlugin[]> {
+		const resolved: ResolvedPlugin[] = [];
+		try {
+			const stateRepo = new PluginStateRepository(db);
+			const marketplacePlugins = await stateRepo.getMarketplacePlugins();
+			if (marketplacePlugins.length === 0) return resolved;
+
+			console.info(
+				"EmDash: Sandbox disabled (sandbox: false). " +
+					"Marketplace plugins will run in-process without isolation.",
+			);
+
+			const { adaptSandboxEntry } = await import("./plugins/adapt-sandbox-entry.js");
+
+			for (const plugin of marketplacePlugins) {
+				if (plugin.status !== "active") continue;
+				const version = plugin.marketplaceVersion ?? plugin.version;
+				try {
+					const bundle = await loadBundleFromR2(storage, plugin.pluginId, version);
+					if (!bundle) {
+						console.warn(
+							`EmDash: Marketplace plugin ${plugin.pluginId}@${version} not found in R2`,
+						);
+						continue;
+					}
+
+					// Cache manifest and route metadata for admin UI and route auth
+					marketplaceManifestCache.set(plugin.pluginId, {
+						id: bundle.manifest.id,
+						version: bundle.manifest.version,
+						admin: bundle.manifest.admin,
+					});
+					if (bundle.manifest.routes.length > 0) {
+						const routeMeta = new Map<string, RouteMeta>();
+						for (const entry of bundle.manifest.routes) {
+							const normalized = normalizeManifestRoute(entry);
+							routeMeta.set(normalized.name, { public: normalized.public === true });
+						}
+						sandboxedRouteMetaCache.set(plugin.pluginId, routeMeta);
+					}
+
+					// Evaluate the bundled ESM and adapt it as a trusted plugin
+					const dataUrl = `data:text/javascript;base64,${Buffer.from(bundle.backendCode).toString("base64")}`;
+					// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- dynamic module from trusted bundle (built by plugin-cli); adaptSandboxEntry validates required fields.
+					const pluginModule = (await import(/* @vite-ignore */ dataUrl)) as Record<
+						string,
+						unknown
+					>;
+					const pluginDef = (pluginModule.default ?? pluginModule) as Parameters<
+						typeof adaptSandboxEntry
+					>[0];
+					const adapted = adaptSandboxEntry(pluginDef, {
+						id: bundle.manifest.id,
+						version: bundle.manifest.version,
+						entrypoint: "",
+						capabilities: bundle.manifest.capabilities ?? [],
+						allowedHosts: bundle.manifest.allowedHosts ?? [],
+						// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- adaptSandboxEntry copies storage through
+						storage: (bundle.manifest.storage ?? {}) as never,
+						adminPages: bundle.manifest.admin?.pages,
+						adminWidgets: bundle.manifest.admin?.widgets?.map((w) => ({
+							id: w.id,
+							title: w.title,
+							size:
+								w.size === "full" || w.size === "half" || w.size === "third" ? w.size : undefined,
+						})),
+					});
+					resolved.push(adapted);
+					console.log(
+						`EmDash: Loaded marketplace plugin ${plugin.pluginId}@${version} in-process (sandbox bypassed)`,
+					);
+				} catch (error) {
+					console.error(
+						`EmDash: Failed to load marketplace plugin ${plugin.pluginId} in-process:`,
+						error,
+					);
+				}
+			}
+		} catch {
+			// _plugin_state table may not exist yet
+		}
+		return resolved;
+	}
+
 	/**
 	 * Resolve exclusive hook selections on startup.
 	 *
@@ -1676,7 +2148,7 @@ export class EmDashRuntime {
 	 */
 	private async hydrateDraftData<T>(result: T): Promise<T> {
 		if (!result || typeof result !== "object") return result;
-		// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- shape probed below
+		// eslint-disable-next-line typescript/no-unsafe-type-assertion -- shape probed below
 		const r = result as {
 			success?: boolean;
 			data?: { item?: Record<string, unknown> };
@@ -1690,7 +2162,7 @@ export class EmDashRuntime {
 			if (!revision) return result;
 			const liveData =
 				item.data && typeof item.data === "object"
-					? // eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- narrowed to object above
+					? // eslint-disable-next-line typescript/no-unsafe-type-assertion -- narrowed to object above
 						(item.data as Record<string, unknown>)
 					: {};
 			// Strip leading-underscore keys (`_slug`, `_rev`, etc.) from the
@@ -1711,7 +2183,7 @@ export class EmDashRuntime {
 			// hydrated item without going back through `unknown`.
 			return {
 				...result,
-				// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- shape preserved; result has been narrowed to the {success,data:{item}} envelope
+				// eslint-disable-next-line typescript/no-unsafe-type-assertion -- shape preserved; result has been narrowed to the {success,data:{item}} envelope
 				data: {
 					...r.data,
 					item: { ...item, data: mergedData, liveData },

package/src/i18n/config.ts

@@ -51,7 +51,7 @@ export function getFallbackChain(locale: string): string[] {
 	const visited = new Set<string>([locale]);
 
 	while (_config.fallback?.[current]) {
-		// eslint-disable-next-line typescript-eslint(no-unnecessary-type-assertion) -- noUncheckedIndexedAccess
+		// eslint-disable-next-line typescript/no-unnecessary-type-assertion -- noUncheckedIndexedAccess
 		const next = _config.fallback[current]!;
 		if (visited.has(next)) break; // prevent cycles
 		chain.push(next);

package/src/index.ts

@@ -12,6 +12,9 @@ export type {
 export {
 	ContentRepository,
 	MediaRepository,
+	PluginStorageRepository,
+	UserRepository,
+	OptionsRepository,
 	EmDashValidationError,
 	InvalidCursorError,
 } from "./database/repositories/index.js";
@@ -198,7 +201,11 @@ export {
 	// Sandbox
 	NoopSandboxRunner,
 	SandboxNotAvailableError,
+	SandboxUnavailableError,
 	createNoopSandboxRunner,
+	// HTTP access for plugins (shared between in-process, Cloudflare, and workerd runners)
+	createHttpAccess,
+	createUnrestrictedHttpAccess,
 } from "./plugins/index.js";
 export type {
 	PluginDefinition,