emdash 0.41.0 → 0.42.0

package/dist/astro/index.mjs

@@ -1,23 +1,23 @@
-import "../runner-B3eyB9Gb.mjs";
+import "../runner-CLpxmhl8.mjs";
 import "../dialect-helpers-7_IqPdh9.mjs";
 import "../config-CvmjJcVw.mjs";
 import "../datetime-normalization-PeiEdcRY.mjs";
-import { t as INTERNAL_MEDIA_PREFIX } from "../normalize-DduyxBjf.mjs";
-import { n as setDevTypegenRefresh } from "../dev-typegen-HRxwLRcT.mjs";
-import { c as resolveRegistryConfigForSandbox, i as normalizeRegistryConfig } from "../config-CCz3xOLc.mjs";
-import { t as defaultSeed } from "../default-DPsys51U.mjs";
-import { n as validateAllowedOrigins, r as validateOriginShape } from "../allowed-origins-U1z4TdEZ.mjs";
-import { r as normalizeMigrationConfig } from "../policy-BcEqut3n.mjs";
-import { c as normalizeAstroI18n, n as MIGRATION_CONFIG_SYMBOL, o as serializeMigrationManifest, r as createMigrationIntegrationMetadata, s as validateMigrationManifest, t as buildMigrationManifest } from "../manifest-builder-BQzCHNgB.mjs";
-import { n as VERSION, t as COMMIT } from "../version-Dq71scUb.mjs";
-import { r as getCoreMigrationIdentity } from "../identity-NVTOOQyq.mjs";
+import { t as INTERNAL_MEDIA_PREFIX } from "../normalize-BuWa0lvd.mjs";
+import { n as DEV_TYPEGEN_REFRESH_GLOBAL, t as DEV_TYPEGEN_REFRESH_EVENT } from "../dev-typegen-8JlYYFno.mjs";
+import { a as parseDurationSeconds, c as resolveRegistryConfigForSandbox, i as normalizeRegistryConfig } from "../config-BnuORwSP.mjs";
+import { n as VERSION, t as COMMIT } from "../version-IneBU54o.mjs";
+import { n as validateAllowedOrigins, r as validateOriginShape } from "../allowed-origins-CFtudhyw.mjs";
+import { r as normalizeMigrationConfig } from "../policy-C1qpNxrr.mjs";
+import { c as normalizeAstroI18n, n as MIGRATION_CONFIG_SYMBOL, o as serializeMigrationManifest, r as createMigrationIntegrationMetadata, s as validateMigrationManifest, t as buildMigrationManifest } from "../manifest-builder-D7Y8iirE.mjs";
+import { r as getCoreMigrationIdentity } from "../identity-u3KgtUC9.mjs";
+import { A as VIRTUAL_SANDBOX_RUNNER_ID, B as generateConfigModule, C as VIRTUAL_CONFIG_ID, D as VIRTUAL_OBJECT_CACHE_ID, E as VIRTUAL_MEDIA_PROVIDERS_ID, F as generateAdminRegistryModule, G as generatePluginsModule, H as generateEnvModule, I as generateAuthModule, J as generateSchedulerModule, K as generateSandboxRunnerModule, L as generateAuthProvidersModule, M as VIRTUAL_SEED_ID, N as VIRTUAL_STORAGE_ID, O as VIRTUAL_PLUGINS_ID, P as VIRTUAL_WAIT_UNTIL_ID, R as generateBlockComponentsModule, S as VIRTUAL_BUILD_ID, T as VIRTUAL_ENV_ID, U as generateMediaProvidersModule, V as generateDialectModule, W as generateObjectCacheModule, X as generateStorageModule, Y as generateSeedModule, Z as generateWaitUntilModule, _ as RESOLVED_VIRTUAL_WAIT_UNTIL_ID, a as RESOLVED_VIRTUAL_BUILD_ID, b as VIRTUAL_AUTH_PROVIDERS_ID, c as RESOLVED_VIRTUAL_ENV_ID, d as RESOLVED_VIRTUAL_PLUGINS_ID, f as RESOLVED_VIRTUAL_SANDBOXED_PLUGINS_ID, g as RESOLVED_VIRTUAL_STORAGE_ID, h as RESOLVED_VIRTUAL_SEED_ID, i as RESOLVED_VIRTUAL_BLOCK_COMPONENTS_ID, j as VIRTUAL_SCHEDULER_ID, k as VIRTUAL_SANDBOXED_PLUGINS_ID, l as RESOLVED_VIRTUAL_MEDIA_PROVIDERS_ID, m as RESOLVED_VIRTUAL_SCHEDULER_ID, n as RESOLVED_VIRTUAL_AUTH_ID, o as RESOLVED_VIRTUAL_CONFIG_ID, p as RESOLVED_VIRTUAL_SANDBOX_RUNNER_ID, q as generateSandboxedPluginsModule, r as RESOLVED_VIRTUAL_AUTH_PROVIDERS_ID, s as RESOLVED_VIRTUAL_DIALECT_ID, t as RESOLVED_VIRTUAL_ADMIN_REGISTRY_ID, u as RESOLVED_VIRTUAL_OBJECT_CACHE_ID, v as VIRTUAL_ADMIN_REGISTRY_ID, w as VIRTUAL_DIALECT_ID, x as VIRTUAL_BLOCK_COMPONENTS_ID, y as VIRTUAL_AUTH_ID, z as generateBuildModule } from "../virtual-modules-Brh6mRVe.mjs";
 import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { randomUUID } from "node:crypto";
 import { mkdir, rename, unlink, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, win32 } from "node:path";
 import { fontProviders } from "astro/config";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 
 //#region src/astro/storage/adapters.ts
 /**
@@ -133,12 +133,25 @@ async function writeMigrationManifest(projectRoot, manifest, fileSystem = nodeFi
 //#endregion
 //#region src/astro/integration/dev-typegen.ts
 /**
+* Call `refresh` whenever server-side code in any Vite environment reports a
+* schema change. Schema mutations can run in a separate realm from the
+* integration (workerd under the Cloudflare adapter), so the signal travels
+* over each environment's hot channel. The global covers same-realm SSR when
+* HMR is disabled and modules have no hot channel.
+*/
+function listenForDevTypegenRefresh(server, refresh) {
+	for (const environment of Object.values(server.environments)) {
+		if (environment.config.consumer !== "server") continue;
+		environment.hot.on(DEV_TYPEGEN_REFRESH_EVENT, () => refresh());
+	}
+	Reflect.set(globalThis, DEV_TYPEGEN_REFRESH_GLOBAL, refresh);
+}
+/**
 * Create a debounced refresh function that fetches the generated types from
 * the dev server and writes them to `emdash-env.d.ts` in the project root.
 *
-* This runs in the Astro integration (Node) and is registered for schema
-* mutations to call back into. It never runs in production builds or in
-* workerd SSR isolates, because only the integration registers it.
+* This runs in the Astro integration (Node), never in production builds or
+* in workerd SSR isolates.
 */
 function createDebouncedTypegenRefresh(port, logger) {
 	let timer;
@@ -840,6 +853,10 @@ function injectCoreRoutes(injectRoute, options = {}) {
 		pattern: "/_emdash/api/admin/plugins/updates",
 		entrypoint: resolveRoute("api/admin/plugins/updates.ts")
 	});
+	injectRoute({
+		pattern: "/_emdash/api/admin/core-update",
+		entrypoint: resolveRoute("api/admin/core-update.ts")
+	});
 	injectRoute({
 		pattern: "/_emdash/api/admin/hooks/exclusive",
 		entrypoint: resolveRoute("api/admin/hooks/exclusive/index.ts")
@@ -1254,514 +1271,6 @@ function injectBuiltinAuthRoutes(injectRoute) {
 	});
 }
 
-//#endregion
-//#region src/astro/integration/virtual-modules.ts
-/**
-* Virtual Module Generators
-*
-* Functions that generate virtual module content for Vite.
-* These modules statically import configured dependencies
-* so Vite can properly resolve and bundle them.
-*/
-const TS_SOURCE_EXT_RE = /^\.(ts|tsx|mts|cts|jsx)$/;
-/** Pattern to remove scoped package prefix from plugin ID */
-const SCOPED_PREFIX_PATTERN = /^@[^/]+\/plugin-/;
-/** Pattern to remove emdash-plugin- prefix from plugin ID */
-const EMDASH_PREFIX_PATTERN = /^emdash-plugin-/;
-const VIRTUAL_CONFIG_ID = "virtual:emdash/config";
-const RESOLVED_VIRTUAL_CONFIG_ID = "\0" + VIRTUAL_CONFIG_ID;
-const VIRTUAL_DIALECT_ID = "virtual:emdash/dialect";
-const RESOLVED_VIRTUAL_DIALECT_ID = "\0" + VIRTUAL_DIALECT_ID;
-const VIRTUAL_STORAGE_ID = "virtual:emdash/storage";
-const RESOLVED_VIRTUAL_STORAGE_ID = "\0" + VIRTUAL_STORAGE_ID;
-const VIRTUAL_OBJECT_CACHE_ID = "virtual:emdash/object-cache";
-const RESOLVED_VIRTUAL_OBJECT_CACHE_ID = "\0" + VIRTUAL_OBJECT_CACHE_ID;
-const VIRTUAL_ADMIN_REGISTRY_ID = "virtual:emdash/admin-registry";
-const RESOLVED_VIRTUAL_ADMIN_REGISTRY_ID = "\0" + VIRTUAL_ADMIN_REGISTRY_ID;
-const VIRTUAL_PLUGINS_ID = "virtual:emdash/plugins";
-const RESOLVED_VIRTUAL_PLUGINS_ID = "\0" + VIRTUAL_PLUGINS_ID;
-const VIRTUAL_SANDBOX_RUNNER_ID = "virtual:emdash/sandbox-runner";
-const RESOLVED_VIRTUAL_SANDBOX_RUNNER_ID = "\0" + VIRTUAL_SANDBOX_RUNNER_ID;
-const VIRTUAL_SANDBOXED_PLUGINS_ID = "virtual:emdash/sandboxed-plugins";
-const RESOLVED_VIRTUAL_SANDBOXED_PLUGINS_ID = "\0" + VIRTUAL_SANDBOXED_PLUGINS_ID;
-const VIRTUAL_AUTH_ID = "virtual:emdash/auth";
-const RESOLVED_VIRTUAL_AUTH_ID = "\0" + VIRTUAL_AUTH_ID;
-const VIRTUAL_AUTH_PROVIDERS_ID = "virtual:emdash/auth-providers";
-const RESOLVED_VIRTUAL_AUTH_PROVIDERS_ID = "\0" + VIRTUAL_AUTH_PROVIDERS_ID;
-const VIRTUAL_MEDIA_PROVIDERS_ID = "virtual:emdash/media-providers";
-const RESOLVED_VIRTUAL_MEDIA_PROVIDERS_ID = "\0" + VIRTUAL_MEDIA_PROVIDERS_ID;
-const VIRTUAL_BLOCK_COMPONENTS_ID = "virtual:emdash/block-components";
-const RESOLVED_VIRTUAL_BLOCK_COMPONENTS_ID = "\0" + VIRTUAL_BLOCK_COMPONENTS_ID;
-const VIRTUAL_SEED_ID = "virtual:emdash/seed";
-const RESOLVED_VIRTUAL_SEED_ID = "\0" + VIRTUAL_SEED_ID;
-const VIRTUAL_WAIT_UNTIL_ID = "virtual:emdash/wait-until";
-const RESOLVED_VIRTUAL_WAIT_UNTIL_ID = "\0" + VIRTUAL_WAIT_UNTIL_ID;
-const VIRTUAL_SCHEDULER_ID = "virtual:emdash/scheduler";
-const RESOLVED_VIRTUAL_SCHEDULER_ID = "\0" + VIRTUAL_SCHEDULER_ID;
-const VIRTUAL_ENV_ID = "virtual:emdash/env";
-const RESOLVED_VIRTUAL_ENV_ID = "\0" + VIRTUAL_ENV_ID;
-const VIRTUAL_BUILD_ID = "virtual:emdash/build";
-const RESOLVED_VIRTUAL_BUILD_ID = "\0" + VIRTUAL_BUILD_ID;
-/**
-* Generates the config virtual module.
-*/
-function generateConfigModule(serializableConfig) {
-	return `export default ${JSON.stringify(serializableConfig)};`;
-}
-/**
-* Generates the dialect virtual module.
-*
-* Adapters that set `supportsRequestScope: true` on their descriptor are
-* expected to export `createRequestScopedDb` from their runtime entrypoint;
-* the generator re-exports it so middleware can ask for a per-request Kysely
-* (used for D1 Sessions API, bookmark cookies, read-replica routing). Other
-* adapters get a stub that returns null.
-*
-* Adapters independently opt into the cold-start coalescing dialect. Keeping
-* this capability explicit prevents bundlers from probing exports that do not
-* exist on SQLite, libSQL, PostgreSQL, or other adapters.
-*/
-function generateDialectModule(opts) {
-	const { entrypoint, supportsRequestScope, supportsCoalescing, supportsCollectionDeletionGuard } = opts;
-	if (!entrypoint) return [
-		`export const createDialect = undefined;`,
-		`export const dialectType = "sqlite";`,
-		`export const createRequestScopedDb = (_opts) => null;`,
-		`export const createCoalescingDialect = undefined;`,
-		`export const executeCollectionDeletionGuard = undefined;`
-	].join("\n");
-	const type = opts.type ?? "sqlite";
-	const coalescingExport = supportsCoalescing ? `import { createCoalescingDialect as _createCoalescingDialect } from "${entrypoint}";
-export const createCoalescingDialect = _createCoalescingDialect;` : `export const createCoalescingDialect = undefined;`;
-	const collectionDeletionExport = supportsCollectionDeletionGuard ? `export { executeCollectionDeletionGuard } from "${entrypoint}";` : `export const executeCollectionDeletionGuard = undefined;`;
-	if (supportsRequestScope) return `
-import { createDialect as _createDialect } from "${entrypoint}";
-export { createRequestScopedDb } from "${entrypoint}";
-${coalescingExport}
-${collectionDeletionExport}
-export const createDialect = _createDialect;
-export const dialectType = ${JSON.stringify(type)};
-`;
-	return `
-import { createDialect as _createDialect } from "${entrypoint}";
-${coalescingExport}
-${collectionDeletionExport}
-export const createDialect = _createDialect;
-export const dialectType = ${JSON.stringify(type)};
-export const createRequestScopedDb = (_opts) => null;
-`;
-}
-/**
-* Generates the storage virtual module.
-* Statically imports the configured storage adapter.
-*/
-function generateStorageModule(storageEntrypoint) {
-	if (!storageEntrypoint) return `export const createStorage = undefined;`;
-	return `
-import { createStorage as _createStorage } from "${storageEntrypoint}";
-export const createStorage = _createStorage;
-`;
-}
-/**
-* Generates the object-cache virtual module.
-*
-* Statically imports the configured object-cache backend's `createObjectCache`
-* factory and embeds its serializable config. When no object cache is
-* configured, exports `undefined` so the runtime read-through layer becomes a
-* transparent passthrough (cache off by default).
-*/
-function generateObjectCacheModule(entrypoint, config) {
-	if (!entrypoint) return [`export const createObjectCache = undefined;`, `export const objectCacheConfig = undefined;`].join("\n");
-	return `
-import { createObjectCache as _createObjectCache } from "${entrypoint}";
-export const createObjectCache = _createObjectCache;
-export const objectCacheConfig = ${JSON.stringify(config ?? {})};
-`;
-}
-/**
-* Generates the auth virtual module.
-* Statically imports the configured auth provider.
-*/
-function generateAuthModule(authEntrypoint) {
-	if (!authEntrypoint) return `export const authenticate = undefined;`;
-	return `
-import { authenticate as _authenticate } from "${authEntrypoint}";
-export const authenticate = _authenticate;
-`;
-}
-/**
-* Generates the auth providers module.
-*
-* Statically imports each auth provider's `adminEntry` module and exports
-* a registry keyed by provider ID. The admin UI uses this to render
-* provider-specific login buttons/forms and setup steps.
-*
-* Follows the same pattern as `generateAdminRegistryModule()` for plugins.
-*/
-function generateAuthProvidersModule(descriptors) {
-	const withAdmin = descriptors.filter((d) => d.adminEntry);
-	if (withAdmin.length === 0) return `export const authProviders = {};`;
-	const imports = [];
-	const entries = [];
-	withAdmin.forEach((descriptor, index) => {
-		const varName = `authProvider${index}`;
-		imports.push(`import * as ${varName} from ${JSON.stringify(descriptor.adminEntry)};`);
-		entries.push(`  ${JSON.stringify(descriptor.id)}: { ...${varName}, id: ${JSON.stringify(descriptor.id)}, label: ${JSON.stringify(descriptor.label)} },`);
-	});
-	return `
-// Auto-generated auth provider registry
-${imports.join("\n")}
-
-export const authProviders = {
-${entries.join("\n")}
-};
-`;
-}
-/**
-* Generates the plugins module.
-* Imports and instantiates all plugins at runtime.
-*
-* Handles two plugin formats:
-* - **Native**: imports `createPlugin` and calls it with options
-* - **Standard**: imports the default export and wraps it with `adaptSandboxEntry`
-*
-* The format is determined by `descriptor.format`:
-* - `"standard"` -- uses adaptSandboxEntry
-* - `"native"` or undefined -- uses createPlugin
-*
-* This is critical for Cloudflare Workers where globals don't persist
-* between build time and runtime.
-*/
-function generatePluginsModule(descriptors) {
-	if (descriptors.length === 0) return `export const plugins = [];`;
-	const imports = [];
-	const instantiations = [];
-	let needsAdapter = false;
-	descriptors.forEach((descriptor, index) => {
-		if (!descriptor.entrypoint) throw new Error(`[emdash] Plugin "${descriptor.id}" has no \`entrypoint\`. The astro integration's \`plugins: []\` requires plugins that resolve to a file/package entrypoint so they can be bundled at build time; an in-process \`definePlugin({...})\` result passed directly is not supported. Move the plugin into its own module and reference it via a factory that returns a descriptor with an \`entrypoint\` (e.g. \`plugins: [myPlugin()]\`).`);
-		if (descriptor.format === "standard") {
-			needsAdapter = true;
-			const varName = `pluginDef${index}`;
-			imports.push(`import ${varName} from "${descriptor.entrypoint}";`);
-			instantiations.push(`adaptSandboxEntry(${varName}, ${JSON.stringify({
-				id: descriptor.id,
-				version: descriptor.version,
-				capabilities: descriptor.capabilities,
-				allowedHosts: descriptor.allowedHosts,
-				storage: descriptor.storage,
-				adminPages: descriptor.adminPages,
-				adminWidgets: descriptor.adminWidgets,
-				editorPanels: descriptor.editorPanels,
-				editorActions: descriptor.editorActions,
-				settingsSchema: descriptor.settingsSchema,
-				portableTextBlocks: descriptor.portableTextBlocks,
-				fieldWidgets: descriptor.fieldWidgets
-			})})`);
-		} else {
-			const varName = `createPlugin${index}`;
-			imports.push(`import { createPlugin as ${varName} } from "${descriptor.entrypoint}";`);
-			instantiations.push(`${varName}(${JSON.stringify(descriptor.options ?? {})})`);
-		}
-	});
-	return `
-// Auto-generated plugins module
-// Imports and instantiates all configured plugins at runtime
-
-${needsAdapter ? `import { adaptSandboxEntry } from "emdash/plugins/adapt-sandbox-entry";\n` : ""}${imports.join("\n")}
-
-/** Resolved plugins array */
-export const plugins = [
-  ${instantiations.join(",\n  ")}
-];
-`;
-}
-/**
-* Generates the admin registry module.
-* Uses adminEntry from plugin descriptors to statically import admin modules.
-*/
-function generateAdminRegistryModule(descriptors) {
-	const adminDescriptors = descriptors.filter((d) => d.adminEntry);
-	if (adminDescriptors.length === 0) return `export const pluginAdmins = {};`;
-	const imports = [];
-	const entries = [];
-	adminDescriptors.forEach((descriptor, index) => {
-		const varName = `admin${index}`;
-		const pluginId = descriptor.id ?? descriptor.entrypoint.replace(SCOPED_PREFIX_PATTERN, "").replace(EMDASH_PREFIX_PATTERN, "");
-		imports.push(`import * as ${varName} from "${descriptor.adminEntry}";`);
-		entries.push(`  "${pluginId}": ${varName},`);
-	});
-	return `
-// Auto-generated plugin admin registry
-${imports.join("\n")}
-
-export const pluginAdmins = {
-${entries.join("\n")}
-};
-`;
-}
-/**
-* Generates the sandbox runner module.
-* Imports the configured sandbox runner factory or provides a noop default.
-*
-* When sandbox is explicitly false (debugging escape hatch), we still mark
-* sandboxEnabled = true so sandboxed plugin entries are loaded, but we use
-* the noop runner which falls through to in-process loading via adaptSandboxEntry.
-*/
-function generateSandboxRunnerModule(sandboxRunner, sandbox) {
-	if (!sandboxRunner) return `
-// No sandbox runner configured - sandboxed plugins disabled
-import { createNoopSandboxRunner } from "emdash";
-
-export const createSandboxRunner = createNoopSandboxRunner;
-export const sandboxEnabled = false;
-`;
-	if (sandbox === false) return `
-// Sandbox explicitly disabled (sandbox: false) - plugins run in-process
-import { createNoopSandboxRunner } from "emdash";
-
-export const createSandboxRunner = createNoopSandboxRunner;
-export const sandboxEnabled = true;
-export const sandboxBypassed = true;
-`;
-	return `
-// Auto-generated sandbox runner module
-import { createSandboxRunner as _createSandboxRunner } from "${sandboxRunner}";
-
-export const createSandboxRunner = _createSandboxRunner;
-export const sandboxEnabled = true;
-`;
-}
-/**
-* Generates the media providers module.
-* Imports and instantiates configured media providers at runtime.
-*/
-function generateMediaProvidersModule(descriptors) {
-	const localDisabled = descriptors.some((d) => d.id === "local" && d.config.enabled === false);
-	const imports = [];
-	const entries = [];
-	if (!localDisabled) {
-		imports.push(`import { createMediaProvider as createLocalProvider } from "emdash/media/local-runtime";`);
-		entries.push(`{
-	id: "local",
-	name: "Library",
-	icon: "folder",
-	capabilities: { browse: true, search: false, upload: true, delete: true },
-	createProvider: (ctx) => createLocalProvider({ ...ctx, enabled: true }),
-}`);
-	}
-	descriptors.filter((d) => d.id !== "local" || d.config.enabled !== false).filter((d) => d.id !== "local").forEach((descriptor, index) => {
-		const varName = `createProvider${index}`;
-		imports.push(`import { createMediaProvider as ${varName} } from "${descriptor.entrypoint}";`);
-		entries.push(`{
-	id: ${JSON.stringify(descriptor.id)},
-	name: ${JSON.stringify(descriptor.name)},
-	icon: ${JSON.stringify(descriptor.icon)},
-	capabilities: ${JSON.stringify(descriptor.capabilities)},
-	createProvider: (ctx) => ${varName}({ ...${JSON.stringify(descriptor.config)}, ...ctx }),
-}`);
-	});
-	return `
-// Auto-generated media providers module
-${imports.join("\n")}
-
-/** Media provider descriptors with factory functions */
-export const mediaProviders = [
-  ${entries.join(",\n  ")}
-];
-`;
-}
-/**
-* Generates the block components module.
-* Collects and merges `blockComponents` exports from plugin component entries.
-*/
-function generateBlockComponentsModule(descriptors) {
-	const withComponents = descriptors.filter((d) => d.componentsEntry);
-	if (withComponents.length === 0) return `export const pluginBlockComponents = {};`;
-	const imports = [];
-	const spreads = [];
-	withComponents.forEach((d, i) => {
-		imports.push(`import { blockComponents as bc${i} } from "${d.componentsEntry}";`);
-		spreads.push(`...bc${i}`);
-	});
-	return `${imports.join("\n")}\nexport const pluginBlockComponents = { ${spreads.join(", ")} };`;
-}
-/**
-* Generates the wait-until virtual module.
-*
-* Under @astrojs/cloudflare, re-exports `waitUntil` from `cloudflare:workers`
-* so `after(fn)` in core can extend the worker's lifetime past the response
-* for deferred bookkeeping. For any other adapter, exports `undefined` —
-* Node's long-lived event loop keeps deferred promises running without a
-* lifetime extender.
-*
-* Keeping the adapter check here — rather than in core — means core itself
-* has no Cloudflare-specific imports or code paths.
-*/
-function generateWaitUntilModule(adapterName) {
-	if (adapterName === "@astrojs/cloudflare") return `export { waitUntil } from "cloudflare:workers";`;
-	return `export const waitUntil = undefined;`;
-}
-/**
-* Generates the env virtual module.
-*
-* Under @astrojs/cloudflare, re-exports `env` from `cloudflare:workers` so
-* routes can read Worker bindings/secrets without touching
-* `Astro.locals.runtime.env`, which Astro 6+ removed (accessing it throws
-* rather than returning undefined, so `locals.runtime?.env` optional-chaining
-* doesn't help -- see #1736). For any other adapter, exports `undefined` so
-* callers fall back to `import.meta.env`. Mirrors generateWaitUntilModule:
-* core stays adapter-agnostic, with no direct `cloudflare:workers` import
-* that would fail to resolve under a Node build.
-*/
-function generateEnvModule(adapterName) {
-	if (adapterName === "@astrojs/cloudflare") return `export { env } from "cloudflare:workers";`;
-	return `export const env = undefined;`;
-}
-/**
-* Generates the build virtual module.
-*
-* Content-hashed `/_astro/*` names make the response depend on the build, not
-* only on the content. Exposing the build timestamp lets the middleware fold
-* that dimension into the cache validator, so a code-only deploy stops
-* answering conditional requests with 304 while the assets the cached HTML
-* references are already gone.
-*/
-function generateBuildModule(buildTime) {
-	return `export const buildTime = ${buildTime};`;
-}
-/**
-* Generates the scheduler virtual module.
-*
-* Decides — at build time, from the Astro adapter — whether the runtime gets a
-* long-lived timer heartbeat. A *production* Cloudflare build has no persistent
-* timers, so the Worker's `scheduled()` handler (a Cron Trigger) drives
-* `runScheduledTasks()` instead and this exports `null`. Every other case — any
-* other adapter (Node, Bun), and crucially local `astro dev` even under the
-* Cloudflare adapter (no Cron Trigger fires in dev) — gets a `NodeCronScheduler`
-* factory so plugin cron, scheduled publishing, and cleanup still run.
-*
-* Keeping the adapter check here — rather than in core's runtime — means the
-* runtime has no Cloudflare-specific code path; it just calls `createScheduler`
-* if one was injected. Mirrors the wait-until module's approach.
-*/
-function generateSchedulerModule(adapterName, command) {
-	if (adapterName === "@astrojs/cloudflare" && command !== "serve") return `// Serverless build: an external Cron Trigger drives scheduled work.
-export const createScheduler = null;
-`;
-	return `// Long-lived runtime (or local dev): drive scheduled work from an in-process timer.
-import { NodeCronScheduler } from "emdash";
-
-export function createScheduler(executor) {
-	return new NodeCronScheduler(executor);
-}
-`;
-}
-/**
-* Generates the seed virtual module.
-* Reads the user's seed file at build time (in Node context) and embeds it,
-* so the runtime doesn't need filesystem access (required for workerd).
-*
-* Search order:
-*   1. `.emdash/seed.json`
-*   2. `package.json` → `emdash.seed` reference
-*   3. `seed/seed.json` (conventional template path)
-*
-* Exports `userSeed` (user's seed or null) and `seed` (user's seed or default).
-*
-* When no user seed is found, falls back to the built-in default seed and
-* (if `warnOnFallback` is true) logs a warning so misconfiguration is visible
-* during `astro dev`. Build/preview/sync stay silent so sites that
-* intentionally use the default seed (e.g. the blank template) don't
-* generate noisy logs.
-*/
-function generateSeedModule(projectRoot, warnOnFallback = false) {
-	let userSeedJson = null;
-	try {
-		const content = readFileSync(resolve(projectRoot, ".emdash", "seed.json"), "utf-8");
-		JSON.parse(content);
-		userSeedJson = content;
-	} catch {}
-	if (!userSeedJson) try {
-		const pkgContent = readFileSync(resolve(projectRoot, "package.json"), "utf-8");
-		const pkg = JSON.parse(pkgContent);
-		if (pkg.emdash?.seed) {
-			const content = readFileSync(resolve(projectRoot, pkg.emdash.seed), "utf-8");
-			JSON.parse(content);
-			userSeedJson = content;
-		}
-	} catch {}
-	if (!userSeedJson) try {
-		const content = readFileSync(resolve(projectRoot, "seed", "seed.json"), "utf-8");
-		JSON.parse(content);
-		userSeedJson = content;
-	} catch {}
-	if (userSeedJson) return [`export const userSeed = ${userSeedJson};`, `export const seed = userSeed;`].join("\n");
-	if (warnOnFallback) console.warn("[emdash] No user seed found at .emdash/seed.json, package.json#emdash.seed, or seed/seed.json. Falling back to the built-in default seed; the setup wizard will not offer demo content for this site.");
-	return [`export const userSeed = null;`, `export const seed = ${JSON.stringify(defaultSeed)};`].join("\n");
-}
-/**
-* Resolve a module specifier from the project's context.
-* Uses Node.js require.resolve with the project root as base.
-*/
-function resolveModulePathFromProject(specifier, projectRoot) {
-	return createRequire(resolve(projectRoot, "package.json")).resolve(specifier);
-}
-/**
-* Generates the sandboxed plugins module.
-* Resolves plugin entrypoints to files, reads them, and embeds the code.
-* Notifies the caller about each resolved entry so build tools can watch it.
-*
-* At runtime, middleware uses SandboxRunner to load these into isolates.
-*/
-function generateSandboxedPluginsModule(sandboxed, projectRoot, onEntryResolved) {
-	if (sandboxed.length === 0) return `
-// No sandboxed plugins configured
-export const sandboxedPlugins = [];
-`;
-	const pluginEntries = [];
-	for (const descriptor of sandboxed) {
-		const bundleSpecifier = descriptor.entrypoint;
-		const filePath = resolveModulePathFromProject(bundleSpecifier, projectRoot);
-		const ext = filePath.slice(filePath.lastIndexOf("."));
-		if (TS_SOURCE_EXT_RE.test(ext)) throw new Error(`Sandboxed plugin "${descriptor.id}" entrypoint "${bundleSpecifier}" resolves to unbuilt source (${filePath}). Sandbox entries must be pre-built JavaScript. Ensure the plugin's package.json exports point to built files (e.g. dist/*.mjs) and run the plugin's build step before building the site.`);
-		onEntryResolved?.(filePath);
-		const code = readFileSync(filePath, "utf-8");
-		pluginEntries.push(`{
-    id: ${JSON.stringify(descriptor.id)},
-    version: ${JSON.stringify(descriptor.version)},
-    options: ${JSON.stringify(descriptor.options ?? {})},
-    capabilities: ${JSON.stringify(descriptor.capabilities ?? [])},
-    allowedHosts: ${JSON.stringify(descriptor.allowedHosts ?? [])},
-    storage: ${JSON.stringify(descriptor.storage ?? {})},
-    mcp: ${JSON.stringify(descriptor.mcp)},
-    routes: ${JSON.stringify(descriptor.routes ?? [])},
-    hooks: ${JSON.stringify(descriptor.hooks ?? [])},
-    adminPages: ${JSON.stringify(descriptor.adminPages ?? [])},
-    adminWidgets: ${JSON.stringify(descriptor.adminWidgets ?? [])},
-    editorPanels: ${JSON.stringify(descriptor.editorPanels ?? [])},
-    editorActions: ${JSON.stringify(descriptor.editorActions ?? [])},
-    settingsSchema: ${JSON.stringify(descriptor.settingsSchema)},
-    portableTextBlocks: ${JSON.stringify(descriptor.portableTextBlocks ?? [])},
-    fieldWidgets: ${JSON.stringify(descriptor.fieldWidgets ?? [])},
-    adminEntry: ${JSON.stringify(descriptor.adminEntry)},
-    // Code read from: ${filePath}
-    code: ${JSON.stringify(code)},
-  }`);
-	}
-	return `
-// Auto-generated sandboxed plugins module
-// Plugin code is embedded at build time
-
-/**
- * Sandboxed plugin entries with embedded code.
- * Loaded at runtime via SandboxRunner.
- */
-export const sandboxedPlugins = [
-  ${pluginEntries.join(",\n  ")}
-];
-`;
-}
-
 //#endregion
 //#region src/astro/integration/vite-config.ts
 /**
@@ -1771,6 +1280,9 @@ export const sandboxedPlugins = [
 * Vite-specific configuration for EmDash.
 */
 const LOCALE_MESSAGES_RE = /[/\\]([a-z]{2}(?:-[A-Z]{2})?)[/\\]messages\.mjs$/;
+function pathToImportUrl(path) {
+	return pathToFileURL(path, { windows: win32.isAbsolute(path) }).href;
+}
 /**
 * Vite plugin that compiles Lingui macros in admin source files.
 * Only active in dev mode when the admin package is aliased to source for HMR.
@@ -1778,21 +1290,24 @@ const LOCALE_MESSAGES_RE = /[/\\]([a-z]{2}(?:-[A-Z]{2})?)[/\\]messages\.mjs$/;
 * not declared by core, never ships to end users.
 */
 function linguiMacroPlugin(adminSourcePath, adminDistPath) {
-	const babelCorePath = createRequire(resolve(adminDistPath, "index.js")).resolve("@babel/core");
+	const adminRequire = createRequire(resolve(adminDistPath, "index.js"));
+	const babelCorePath = adminRequire.resolve("@babel/core");
+	const linguiMacroPluginPath = adminRequire.resolve("@lingui/babel-plugin-lingui-macro");
+	const adminSourceVitePath = adminSourcePath.replaceAll("\\", "/");
 	return {
 		name: "emdash-lingui-macro",
 		enforce: "pre",
 		resolveId(id, importer) {
-			if (!importer?.startsWith(adminSourcePath)) return;
+			if (!importer?.startsWith(adminSourceVitePath)) return;
 			const match = id.match(LOCALE_MESSAGES_RE);
 			if (match?.[1]) return resolve(adminDistPath, "locales", match[1], "messages.mjs");
 		},
 		async transform(code, id) {
-			if (!id.startsWith(adminSourcePath) || !code.includes("@lingui")) return;
-			const { transformAsync } = await import(babelCorePath);
+			if (!id.startsWith(adminSourceVitePath) || !code.includes("@lingui")) return;
+			const { transformAsync } = await import(pathToImportUrl(babelCorePath));
 			const result = await transformAsync(code, {
 				filename: id,
-				plugins: ["@lingui/babel-plugin-lingui-macro"],
+				plugins: [linguiMacroPluginPath],
 				parserOpts: { plugins: ["jsx", "typescript"] }
 			});
 			if (!result?.code) return;
@@ -2203,6 +1718,33 @@ function buildImageRemotePatterns(storage, siteUrl, command) {
 	return patterns;
 }
 /**
+* Build the config subset baked into `virtual:emdash/config` and exposed
+* at runtime as `locals.emdash.config`. A config option that runtime code
+* reads (routes, middleware) MUST be listed here — an option only on
+* `EmDashConfig` is invisible at runtime and silently ignored.
+*
+* @internal Exported for unit testing.
+*/
+function buildSerializableConfig(resolvedConfig) {
+	return {
+		database: resolvedConfig.database,
+		migrations: resolvedConfig.migrations,
+		storage: resolvedConfig.storage,
+		auth: resolvedConfig.auth,
+		authProviders: resolvedConfig.authProviders,
+		marketplace: resolvedConfig.marketplace,
+		registry: resolvedConfig.registry,
+		experimental: resolvedConfig.experimental,
+		siteUrl: resolvedConfig.siteUrl,
+		trustedProxyHeaders: resolvedConfig.trustedProxyHeaders,
+		maxUploadSize: resolvedConfig.maxUploadSize,
+		admin: resolvedConfig.admin,
+		toolbar: resolvedConfig.toolbar,
+		updateCheck: resolvedConfig.updateCheck,
+		objectCacheEnabled: resolvedConfig.objectCache !== void 0
+	};
+}
+/**
 * Stock image endpoints EmDash may safely replace with its storage-backed
 * wrapper. Our wrapper delegates non-EmDash images to the platform's transform
 * endpoint, so we only override endpoints whose transform we can delegate to.
@@ -2252,6 +1794,16 @@ function missingReactIntegrationWarning(integrations) {
 	if (integrations.some((integration) => integration.name === "@astrojs/react")) return;
 	return "@astrojs/react is not registered in your Astro config. The EmDash admin UI will not hydrate without it (the page stays on \"Loading EmDash...\"). Add it to your integrations:\n\n  import react from \"@astrojs/react\";\n  export default defineConfig({\n    integrations: [react(), emdash({ ... })],\n  });";
 }
+/**
+* Warn when Astro has no session driver. Sign-in stores the user in the Astro
+* session, so without a driver every sign-in route fails. The Node, Cloudflare,
+* and Netlify adapters configure a driver in `astro:config:setup`; others,
+* such as Vercel, do not.
+*/
+function missingSessionDriverWarning(session) {
+	if (session && session.driver) return void 0;
+	return `${session === false ? `Astro sessions are disabled (\`session: false\`), but EmDash stores signed-in users in the Astro session.` : `No Astro session driver is configured, but EmDash stores signed-in users in the Astro session.`} Without one, signing in to the admin fails. Use an adapter that provides a driver (Node, Cloudflare, Netlify) or configure one yourself, for example:\n\n  import { defineConfig, sessionDrivers } from "astro/config";\n  export default defineConfig({\n    session: { driver: sessionDrivers.redis({ url: process.env.REDIS_URL }) },\n  });\n\nSee https://docs.astro.build/en/guides/sessions/`;
+}
 const dim = (s) => `\x1b[2m${s}\x1b[22m`;
 const bold = (s) => `\x1b[1m${s}\x1b[22m`;
 const cyan = (s) => `\x1b[36m${s}\x1b[39m`;
@@ -2334,6 +1886,12 @@ function emdash(config = {}) {
 		allowLocalhost: true,
 		fieldPrefix: registry.fieldPrefix
 	});
+	const updateCheckAge = typeof resolvedConfig.updateCheck === "object" ? resolvedConfig.updateCheck?.minimumReleaseAge : void 0;
+	if (updateCheckAge !== void 0) try {
+		parseDurationSeconds(updateCheckAge);
+	} catch (e) {
+		throw new Error(`Invalid updateCheck.minimumReleaseAge: ${String(updateCheckAge)}`, { cause: e });
+	}
 	if (resolvedConfig.marketplace) {
 		const url = resolvedConfig.marketplace;
 		try {
@@ -2370,21 +1928,7 @@ function emdash(config = {}) {
 		if (descriptor.componentsEntry) throw new Error(`Plugin "${descriptor.id}" is standard format but declares componentsEntry. Portable Text block components require native format. Remove componentsEntry or change format to "native".`);
 	}
 	for (const descriptor of sandboxedDescriptors) if (descriptor.format !== "standard") throw new Error(`Plugin "${descriptor.id}" uses the native format and cannot be placed in \`sandboxed: []\`. Native plugins can only run in \`plugins: []\`. To sandbox this plugin, convert it to the standard format.`);
-	const serializableConfig = {
-		database: resolvedConfig.database,
-		migrations: resolvedConfig.migrations,
-		storage: resolvedConfig.storage,
-		auth: resolvedConfig.auth,
-		authProviders: resolvedConfig.authProviders,
-		marketplace: resolvedConfig.marketplace,
-		registry: resolvedConfig.registry,
-		experimental: resolvedConfig.experimental,
-		siteUrl: resolvedConfig.siteUrl,
-		trustedProxyHeaders: resolvedConfig.trustedProxyHeaders,
-		maxUploadSize: resolvedConfig.maxUploadSize,
-		admin: resolvedConfig.admin,
-		toolbar: resolvedConfig.toolbar
-	};
+	const serializableConfig = buildSerializableConfig(resolvedConfig);
 	const useExternalAuth = !!(resolvedConfig.auth && "entrypoint" in resolvedConfig.auth);
 	let astroCommand;
 	let normalizedI18n = null;
@@ -2392,7 +1936,7 @@ function emdash(config = {}) {
 	const integration = {
 		name: "emdash",
 		hooks: {
-			"astro:config:setup": ({ injectRoute, addMiddleware, logger, updateConfig, config: astroConfig, command }) => {
+			"astro:config:setup": ({ injectRoute: astroInjectRoute, addMiddleware, logger, updateConfig, config: astroConfig, command }) => {
 				astroCommand = command;
 				normalizeRegistryConfig(registry.input, {
 					allowLocalhost: command === "dev" || command === "sync",
@@ -2453,6 +1997,10 @@ function emdash(config = {}) {
 						astroConfig
 					}, command)
 				});
+				const injectRoute = (route) => astroInjectRoute({
+					...route,
+					prerender: false
+				});
 				injectCoreRoutes(injectRoute, { srcDir: astroConfig.srcDir });
 				if (resolvedConfig.authProviders?.length) injectAuthProviderRoutes(injectRoute, resolvedConfig.authProviders);
 				if (!useExternalAuth) injectBuiltinAuthRoutes(injectRoute);
@@ -2462,6 +2010,8 @@ function emdash(config = {}) {
 			"astro:config:done": async ({ config: finalConfig, logger }) => {
 				const warning = missingReactIntegrationWarning(finalConfig.integrations);
 				if (warning) logger.warn(warning);
+				const sessionWarning = useExternalAuth ? void 0 : missingSessionDriverWarning(finalConfig.session);
+				if (sessionWarning) logger.warn(sessionWarning);
 				if (astroCommand !== "build" && astroCommand !== "sync") return;
 				if (!migrationMetadata.database) {
 					logger.warn("EmDash migration manifest was not written because no database adapter is configured.");
@@ -2492,7 +2042,7 @@ function emdash(config = {}) {
 					if (!address || typeof address === "string") return;
 					const port = address.port;
 					const refreshDevTypes = createDebouncedTypegenRefresh(port, logger);
-					setDevTypegenRefresh(refreshDevTypes);
+					listenForDevTypegenRefresh(server, refreshDevTypes);
 					refreshDevTypes();
 				});
 			},