emdash 0.18.0 → 0.20.0

package/src/astro/integration/virtual-modules.ts

@@ -63,6 +63,9 @@ export const RESOLVED_VIRTUAL_SEED_ID = "\0" + VIRTUAL_SEED_ID;
 export const VIRTUAL_WAIT_UNTIL_ID = "virtual:emdash/wait-until";
 export const RESOLVED_VIRTUAL_WAIT_UNTIL_ID = "\0" + VIRTUAL_WAIT_UNTIL_ID;
 
+export const VIRTUAL_SCHEDULER_ID = "virtual:emdash/scheduler";
+export const RESOLVED_VIRTUAL_SCHEDULER_ID = "\0" + VIRTUAL_SCHEDULER_ID;
+
 /**
  * Generates the config virtual module.
  */
@@ -413,6 +416,42 @@ export function generateWaitUntilModule(adapterName: string | undefined): string
 	return `export const waitUntil = undefined;`;
 }
 
+/**
+ * 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.
+ */
+export function generateSchedulerModule(
+	adapterName: string | undefined,
+	command: "build" | "serve" | undefined,
+): string {
+	// Only suppress the timer for an actual Cloudflare *build* — that artifact
+	// runs in workerd where a Cron Trigger drives scheduled work. In `serve`
+	// (local dev) nothing fires the Cron Trigger, so fall through to the timer.
+	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,

package/src/astro/integration/vite-config.ts

@@ -42,8 +42,11 @@ import {
 	RESOLVED_VIRTUAL_SEED_ID,
 	VIRTUAL_WAIT_UNTIL_ID,
 	RESOLVED_VIRTUAL_WAIT_UNTIL_ID,
+	VIRTUAL_SCHEDULER_ID,
+	RESOLVED_VIRTUAL_SCHEDULER_ID,
 	generateSeedModule,
 	generateWaitUntilModule,
+	generateSchedulerModule,
 	generateConfigModule,
 	generateDialectModule,
 	generateStorageModule,
@@ -203,6 +206,9 @@ export function createVirtualModulesPlugin(options: VitePluginOptions): Plugin {
 			if (id === VIRTUAL_WAIT_UNTIL_ID) {
 				return RESOLVED_VIRTUAL_WAIT_UNTIL_ID;
 			}
+			if (id === VIRTUAL_SCHEDULER_ID) {
+				return RESOLVED_VIRTUAL_SCHEDULER_ID;
+			}
 		},
 		load(id: string) {
 			if (id === RESOLVED_VIRTUAL_CONFIG_ID) {
@@ -271,6 +277,12 @@ export function createVirtualModulesPlugin(options: VitePluginOptions): Plugin {
 			if (id === RESOLVED_VIRTUAL_WAIT_UNTIL_ID) {
 				return generateWaitUntilModule(astroConfig.adapter?.name);
 			}
+			// Generate scheduler module — a NodeCronScheduler factory on
+			// long-lived runtimes, or null under the Cloudflare adapter where
+			// a Cron Trigger drives scheduled work instead.
+			if (id === RESOLVED_VIRTUAL_SCHEDULER_ID) {
+				return generateSchedulerModule(astroConfig.adapter?.name, viteCommand);
+			}
 		},
 	};
 }

package/src/astro/middleware.ts

@@ -25,6 +25,8 @@ import * as virtualSandboxRunnerModule from "virtual:emdash/sandbox-runner";
 // @ts-ignore - virtual module
 import { sandboxedPlugins as virtualSandboxedPlugins } from "virtual:emdash/sandboxed-plugins";
 // @ts-ignore - virtual module
+import { createScheduler as virtualCreateScheduler } from "virtual:emdash/scheduler";
+// @ts-ignore - virtual module
 import { createStorage as virtualCreateStorage } from "virtual:emdash/storage";
 
 import { after } from "../after.js";
@@ -39,6 +41,7 @@ import {
 	type RuntimeDependencies,
 	type SandboxedPluginEntry,
 	type MediaProviderEntry,
+	type CreateSchedulerFn,
 } from "../emdash-runtime.js";
 import { setI18nConfig } from "../i18n/config.js";
 import type { Database, Storage } from "../index.js";
@@ -52,6 +55,7 @@ import {
 	type RequestMetrics,
 	runWithContext,
 } from "../request-context.js";
+import type { PublishedRef } from "../scheduled-publish.js";
 import { isMissingTableError } from "../utils/db-errors.js";
 import { createInitLock, type InitLock, initWithLock } from "../utils/init-lock.js";
 import type { EmDashConfig } from "./integration/runtime.js";
@@ -174,6 +178,7 @@ function buildDependencies(config: EmDashConfig): RuntimeDependencies {
 		plugins: getPlugins(),
 		createDialect: virtualCreateDialect as (config: Record<string, unknown>) => unknown,
 		createStorage: virtualCreateStorage as ((config: Record<string, unknown>) => Storage) | null,
+		createScheduler: virtualCreateScheduler as CreateSchedulerFn | null,
 		sandboxEnabled: sandboxModule.sandboxEnabled as boolean,
 		sandboxBypassed: (sandboxModule.sandboxBypassed as boolean) ?? false,
 		sandboxedPluginEntries: (virtualSandboxedPlugins as SandboxedPluginEntry[]) || [],
@@ -243,6 +248,29 @@ async function getRuntime(
 	);
 }
 
+/**
+ * Run scheduled maintenance (cron tasks, scheduled publishing, system cleanup)
+ * outside any request. Resolves the runtime from the build-time virtual config
+ * and the cached singleton — the same instance request handlers use.
+ *
+ * Wired into a platform heartbeat that is not a request: the Cloudflare Worker's
+ * `scheduled()` handler (Cron Trigger) calls this. On Node the runtime's own
+ * timer-based scheduler already drives the same work, so this isn't needed there.
+ *
+ * Returns the content promoted by the publishing sweep so the caller can purge
+ * edge-cache tags for it. `onPublished` (optional) is awaited after each
+ * collection's batch so the caller can invalidate edge-cache tags incrementally
+ * rather than only after the whole sweep.
+ */
+export async function runScheduledTasks(
+	options: { onPublished?: (refs: PublishedRef[]) => Promise<void> } = {},
+): Promise<{ published: PublishedRef[] }> {
+	const config = getConfig();
+	if (!config) return { published: [] };
+	const runtime = await getRuntime(config);
+	return runtime.runScheduledTasks(options);
+}
+
 /**
  * Astro attaches AstroCookies to outgoing responses via a well-known global
  * symbol. Cloning a Response (`new Response(body, init)`) drops non-header
@@ -305,6 +333,9 @@ function pushMetricsTimings(
 			timings.push({ name: "db.last", dur: metrics.dbLastOffset, desc: "Last query at" });
 		}
 	}
+	if (metrics.rpcCount > 0) {
+		timings.push({ name: "rpc.count", dur: metrics.rpcCount, desc: "DB round trips" });
+	}
 	if (metrics.cacheHits + metrics.cacheMisses > 0) {
 		timings.push({ name: "cache.hit", dur: metrics.cacheHits, desc: "Cache hits" });
 		timings.push({ name: "cache.miss", dur: metrics.cacheMisses, desc: "Cache misses" });
@@ -482,9 +513,15 @@ export const onRequest = defineMiddleware(async (context, next) => {
 						? { ...parent, db: anonScoped.db }
 						: { editMode: false, db: anonScoped.db, metrics };
 					return runWithContext(ctx, async () => {
-						const response = await runAnon();
-						anonScoped.commit();
-						return response;
+						// commit() in finally: the write reached the primary independently
+						// of render, so the bookmark cookie must be persisted even if
+						// render throws -- otherwise a write-then-failed-render leaves the
+						// next request able to read pre-write state off a lagging replica.
+						try {
+							return await runAnon();
+						} finally {
+							anonScoped.commit();
+						}
 					});
 				}
 				return runAnon();
@@ -653,9 +690,14 @@ export const onRequest = defineMiddleware(async (context, next) => {
 					? { ...parent, db: scoped.db }
 					: { editMode: false, db: scoped.db, metrics };
 				return runWithContext(ctx, async () => {
-					const response = await renderAndFinalize();
-					scoped.commit();
-					return response;
+					// commit() in finally: persist the bookmark cookie even if render
+					// throws -- the write already reached the primary, so a failed
+					// render must not strand the next request on a stale replica read.
+					try {
+						return await renderAndFinalize();
+					} finally {
+						scoped.commit();
+					}
 				});
 			}
 

package/src/astro/routes/api/content/[collection]/[id]/discard-draft.ts

@@ -11,7 +11,7 @@ import { apiError, mapErrorStatus, unwrapResult } from "#api/error.js";
 
 export const prerender = false;
 
-export const POST: APIRoute = async ({ params, locals, cache }) => {
+export const POST: APIRoute = async ({ params, locals, url, cache }) => {
 	const { emdash, user } = locals;
 	const collection = params.collection!;
 	const id = params.id!;
@@ -20,8 +20,10 @@ export const POST: APIRoute = async ({ params, locals, cache }) => {
 		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
 	}
 
+	const locale = url.searchParams.get("locale") || undefined;
+
 	// Fetch item to check ownership
-	const existing = await emdash.handleContentGet(collection, id);
+	const existing = await emdash.handleContentGet(collection, id, locale);
 	if (!existing.success) {
 		return apiError(
 			existing.error?.code ?? "UNKNOWN_ERROR",

package/src/astro/routes/api/content/[collection]/[id]/publish.ts

@@ -20,7 +20,7 @@ import { contentPublishBody } from "#api/schemas.js";
 
 export const prerender = false;
 
-export const POST: APIRoute = async ({ params, request, locals, cache }) => {
+export const POST: APIRoute = async ({ params, request, locals, url, cache }) => {
 	const { emdash, user } = locals;
 	const collection = params.collection!;
 	const id = params.id!;
@@ -34,8 +34,10 @@ export const POST: APIRoute = async ({ params, request, locals, cache }) => {
 	const body = await parseOptionalBody(request, contentPublishBody, {});
 	if (isParseError(body)) return body;
 
+	const locale = url.searchParams.get("locale") || undefined;
+
 	// Fetch item to check ownership
-	const existing = await emdash.handleContentGet(collection, id);
+	const existing = await emdash.handleContentGet(collection, id, locale);
 	if (!existing.success) {
 		return apiError(
 			existing.error?.code ?? "UNKNOWN_ERROR",

package/src/astro/routes/api/content/[collection]/[id]/schedule.ts

@@ -34,7 +34,7 @@ function extractOwnership(data: unknown): { authorId: string; resolvedId: string
 	};
 }
 
-export const POST: APIRoute = async ({ params, request, locals, cache }) => {
+export const POST: APIRoute = async ({ params, request, locals, url, cache }) => {
 	const { emdash, user } = locals;
 	const collection = params.collection!;
 	const id = params.id!;
@@ -45,8 +45,10 @@ export const POST: APIRoute = async ({ params, request, locals, cache }) => {
 		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
 	}
 
+	const locale = url.searchParams.get("locale") || undefined;
+
 	// Fetch item to check ownership
-	const existing = await emdash.handleContentGet(collection, id);
+	const existing = await emdash.handleContentGet(collection, id, locale);
 	if (!existing.success) {
 		return apiError(
 			existing.error?.code ?? "UNKNOWN_ERROR",
@@ -68,7 +70,7 @@ export const POST: APIRoute = async ({ params, request, locals, cache }) => {
 	return unwrapResult(result);
 };
 
-export const DELETE: APIRoute = async ({ params, locals, cache }) => {
+export const DELETE: APIRoute = async ({ params, locals, url, cache }) => {
 	const { emdash, user } = locals;
 	const collection = params.collection!;
 	const id = params.id!;
@@ -77,8 +79,10 @@ export const DELETE: APIRoute = async ({ params, locals, cache }) => {
 		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
 	}
 
+	const locale = url.searchParams.get("locale") || undefined;
+
 	// Fetch item to check ownership
-	const existing = await emdash.handleContentGet(collection, id);
+	const existing = await emdash.handleContentGet(collection, id, locale);
 	if (!existing.success) {
 		return apiError(
 			existing.error?.code ?? "UNKNOWN_ERROR",

package/src/astro/routes/api/content/[collection]/[id]/unpublish.ts

@@ -11,7 +11,7 @@ import { apiError, mapErrorStatus, unwrapResult } from "#api/error.js";
 
 export const prerender = false;
 
-export const POST: APIRoute = async ({ params, locals, cache }) => {
+export const POST: APIRoute = async ({ params, locals, url, cache }) => {
 	const { emdash, user } = locals;
 	const collection = params.collection!;
 	const id = params.id!;
@@ -20,8 +20,10 @@ export const POST: APIRoute = async ({ params, locals, cache }) => {
 		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
 	}
 
+	const locale = url.searchParams.get("locale") || undefined;
+
 	// Fetch item to check ownership
-	const existing = await emdash.handleContentGet(collection, id);
+	const existing = await emdash.handleContentGet(collection, id, locale);
 	if (!existing.success) {
 		return apiError(
 			existing.error?.code ?? "UNKNOWN_ERROR",

package/src/astro/routes/api/content/[collection]/[id].ts

@@ -132,7 +132,7 @@ export const PUT: APIRoute = async ({ params, request, locals, cache }) => {
 	return unwrapResult(result);
 };
 
-export const DELETE: APIRoute = async ({ params, locals, cache }) => {
+export const DELETE: APIRoute = async ({ params, locals, url, cache }) => {
 	const { emdash, user } = locals;
 	const collection = params.collection!;
 	const id = params.id!;
@@ -141,8 +141,10 @@ export const DELETE: APIRoute = async ({ params, locals, cache }) => {
 		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
 	}
 
+	const locale = url.searchParams.get("locale") || undefined;
+
 	// Fetch item to check ownership
-	const existing = await emdash.handleContentGet(collection, id);
+	const existing = await emdash.handleContentGet(collection, id, locale);
 	if (!existing.success) {
 		return apiError(
 			existing.error?.code ?? "UNKNOWN_ERROR",

package/src/astro/routes/api/content/[collection]/authors.ts

@@ -0,0 +1,34 @@
+/**
+ * Content authors endpoint - injected by EmDash integration
+ *
+ * GET /_emdash/api/content/{collection}/authors - List the distinct authors
+ * of a collection's live content, for the admin author filter.
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, unwrapResult } from "#api/error.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ params, locals }) => {
+	const { emdash, user } = locals;
+	const collection = params.collection!;
+
+	// Editorial capability, not plain read. This response carries author
+	// emails (PII) and reveals the authors of unpublished entries, so it must
+	// not be reachable by subscribers (content:read). content:read_drafts is
+	// the same tier the list route requires before it stops forcing
+	// status=published, so the visibility surfaces line up.
+	const denied = requirePerm(user, "content:read_drafts");
+	if (denied) return denied;
+
+	if (!emdash?.handleContentAuthors) {
+		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
+	}
+
+	const result = await emdash.handleContentAuthors(collection);
+
+	return unwrapResult(result);
+};

package/src/astro/routes/api/schema/index.ts

@@ -13,7 +13,7 @@ import type { APIRoute } from "astro";
 import { hashString } from "emdash";
 
 import { requirePerm } from "#api/authorize.js";
-import { handleError, requireDb } from "#api/error.js";
+import { apiSuccess, handleError, requireDb } from "#api/error.js";
 import { SchemaRegistry } from "#schema/registry.js";
 import { generateTypeScript } from "#schema/zod-generator.js";
 
@@ -89,20 +89,12 @@ import type { PortableTextBlock } from "emdash";
 
 		const version = await hashString(JSON.stringify(schemaExport));
 
-		return new Response(
-			JSON.stringify({
-				...schemaExport,
-				version,
-			}),
-			{
-				status: 200,
-				headers: {
-					"Content-Type": "application/json",
-					"Cache-Control": "private, no-store",
-					"X-Schema-Version": version,
-				},
-			},
-		);
+		const response = apiSuccess({
+			...schemaExport,
+			version,
+		});
+		response.headers.set("X-Schema-Version", version);
+		return response;
 	} catch (error) {
 		return handleError(error, "Schema export failed", "SCHEMA_EXPORT_ERROR");
 	}

package/src/astro/routes/sitemap-[collection].xml.ts

@@ -23,6 +23,7 @@ import { getSiteSettingsWithDb } from "#settings/index.js";
 
 import { getI18nConfig, isI18nEnabled } from "../../i18n/config.js";
 import { interpolateUrlPattern, localizePath } from "../../i18n/resolve.js";
+import { buildSeoImageUrl } from "../../seo/media-url.js";
 
 export const prerender = false;
 
@@ -112,8 +113,8 @@ export const GET: APIRoute = async ({ params, locals, url }) => {
 		const lines: string[] = ['<?xml version="1.0" encoding="UTF-8"?>'];
 		lines.push(
 			useXhtml
-				? '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">'
-				: '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+				? '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">'
+				: '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">',
 		);
 
 		const writeUrl = async (entry: Entry, siblings: Entry[] | null) => {
@@ -127,6 +128,16 @@ export const GET: APIRoute = async ({ params, locals, url }) => {
 			lines.push(`    <loc>${escapeXml(loc)}</loc>`);
 			lines.push(`    <lastmod>${escapeXml(entry.updatedAt)}</lastmod>`);
 
+			// Google image sitemap extension: advertise the entry's SEO
+			// image (the same "preferred image" used for og:image) so it
+			// can be discovered and indexed for Google Images.
+			if (entry.image) {
+				const imageLoc = buildSeoImageUrl(entry.image, siteUrl);
+				lines.push("    <image:image>");
+				lines.push(`      <image:loc>${escapeXml(imageLoc)}</image:loc>`);
+				lines.push("    </image:image>");
+			}
+
 			if (useXhtml && siblings && siblings.length > 1) {
 				// Emit one xhtml:link per sibling (including self -- Google
 				// recommends including the page's own hreflang annotation).

package/src/astro/types.ts

@@ -233,9 +233,16 @@ export interface EmDashHandlers {
 			orderBy?: string;
 			order?: "asc" | "desc";
 			locale?: string;
+			q?: string;
+			authorId?: string;
+			dateField?: "createdAt" | "updatedAt" | "publishedAt";
+			dateFrom?: string;
+			dateTo?: string;
 		},
 	) => Promise<HandlerResponse>;
 
+	handleContentAuthors: (collection: string) => Promise<HandlerResponse>;
+
 	handleContentGet: (
 		collection: string,
 		id: string,
@@ -313,7 +320,7 @@ export interface EmDashHandlers {
 	handleContentPublish: (
 		collection: string,
 		id: string,
-		options?: { publishedAt?: string },
+		options?: { publishedAt?: string; requireScheduledDue?: boolean },
 	) => Promise<HandlerResponse>;
 
 	handleContentUnpublish: (collection: string, id: string) => Promise<HandlerResponse>;

package/src/bylines/index.ts

@@ -320,6 +320,63 @@ export async function getBylinesForEntries(
 	return result;
 }
 
+/**
+ * Get content entries credited to a byline, in any credit position.
+ *
+ * Unlike filtering on the content table's `primary_byline_id` column (which
+ * only finds entries where the byline is the first/primary credit), this
+ * matches every explicit credit recorded in `_emdash_content_bylines`, so
+ * co-authored entries where the byline is a secondary credit are included.
+ *
+ * `byline` is matched against the byline's `translation_group` (the value
+ * stored on credits since migration 040), so a single credit spans every
+ * locale variant of the byline. Pass `byline.translationGroup ?? byline.id`
+ * from `getByline` / `getBylineBySlug`. An array matches any of the given
+ * bylines (OR).
+ *
+ * The result respects the active locale, status, ordering, and eager
+ * hydration of `getEmDashCollection`.
+ *
+ * @example
+ * ```ts
+ * import { getBylineBySlug, getEntriesByByline } from "emdash";
+ *
+ * const byline = await getBylineBySlug("jane-doe");
+ * if (byline) {
+ *   const posts = await getEntriesByByline("posts", byline.translationGroup ?? byline.id, {
+ *     orderBy: { published_at: "desc" },
+ *   });
+ * }
+ * ```
+ *
+ * @param collection - The collection slug (e.g. "posts")
+ * @param byline - A byline translation group, or an array of them (OR)
+ * @param options - Optional locale, ordering, status, and limit
+ */
+export async function getEntriesByByline(
+	collection: string,
+	byline: string | string[],
+	options: {
+		locale?: string;
+		orderBy?: Record<string, "asc" | "desc">;
+		status?: "draft" | "published" | "archived";
+		limit?: number;
+	} = {},
+): Promise<Array<{ id: string; data: Record<string, unknown> }>> {
+	const { getEmDashCollection } = await import("../query.js");
+
+	const queryOptions: Record<string, unknown> = {
+		where: { byline },
+	};
+	if (options.locale !== undefined) queryOptions.locale = options.locale;
+	if (options.orderBy !== undefined) queryOptions.orderBy = options.orderBy;
+	if (options.status !== undefined) queryOptions.status = options.status;
+	if (options.limit !== undefined) queryOptions.limit = options.limit;
+
+	const { entries } = await getEmDashCollection(collection, queryOptions);
+	return entries;
+}
+
 /** Reads `author_id` + `primary_byline_id` for one entry in a single query. */
 async function getEntryContext(
 	db: Awaited<ReturnType<typeof getDb>>,

package/src/cli/commands/bundle-utils.ts

@@ -13,6 +13,7 @@ import { pipeline } from "node:stream/promises";
 import { imageSize } from "image-size";
 import { packTar } from "modern-tar/fs";
 
+import { capabilitiesToDeclaredAccess } from "../../plugins/types.js";
 import type {
 	PluginManifest,
 	ResolvedPlugin,
@@ -151,6 +152,7 @@ export function extractManifest(plugin: ResolvedPlugin): PluginManifest {
 	return {
 		id: plugin.id,
 		version: plugin.version,
+		declaredAccess: capabilitiesToDeclaredAccess(plugin.capabilities, plugin.allowedHosts),
 		capabilities: plugin.capabilities,
 		allowedHosts: plugin.allowedHosts,
 		storage: plugin.storage,

package/src/cli/commands/export-seed.ts

@@ -20,7 +20,7 @@ import { OptionsRepository } from "../../database/repositories/options.js";
 import { TaxonomyRepository } from "../../database/repositories/taxonomy.js";
 import type { Database } from "../../database/types.js";
 import { validateIdentifier } from "../../database/validate.js";
-import { isI18nEnabled } from "../../i18n/config.js";
+import { getI18nConfig, isI18nEnabled } from "../../i18n/config.js";
 import { SchemaRegistry } from "../../schema/registry.js";
 import type { FieldType } from "../../schema/types.js";
 import type {
@@ -128,7 +128,12 @@ export async function exportSeed(db: Kysely<Database>, withContent?: string): Pr
 	// middleware, but the CLI never does, so `isI18nEnabled()` is always false
 	// under `emdash export-seed` (#1330). Detecting multiple locales in the data
 	// keeps the export locale-aware without the runtime flag.
-	const i18nEnabled = await detectI18nEnabled(db, seed.collections);
+	const { i18nEnabled, defaultLocale } = await detectLocaleInfo(db, seed.collections);
+
+	// Self-describe the default locale so a non-`en` single-locale project
+	// survives the round-trip: `emdash seed` runs outside the runtime and would
+	// otherwise backfill omitted locales as `en` (#1421).
+	if (defaultLocale) seed.defaultLocale = defaultLocale;
 
 	// 3. Export taxonomy definitions and terms
 	seed.taxonomies = await exportTaxonomies(db, i18nEnabled);
@@ -216,7 +221,7 @@ async function exportBylines(
 }
 
 /**
- * Determine whether the export should emit locale-suffixed seed ids.
+ * Determine locale-awareness and the data's default locale for the export.
  *
  * The runtime initializes the i18n config in middleware, but the CLI never does,
  * so `isI18nEnabled()` is always false under `emdash export-seed` (#1330). When
@@ -227,39 +232,50 @@ async function exportBylines(
  * genuinely single-locale project from a multi-locale one. This keeps
  * single-locale exports on bare ids and gives multi-locale exports the
  * per-locale suffix they need to avoid duplicate seed ids.
+ *
+ * `defaultLocale` self-describes the single-locale case so a non-`en` default
+ * survives the round-trip (#1421). When more than one locale is present every
+ * row already carries its own `locale`, so no fallback is needed and we leave it
+ * undefined rather than guess which locale is the "default" without the runtime
+ * config.
  */
-async function detectI18nEnabled(
+async function detectLocaleInfo(
 	db: Kysely<Database>,
 	collections: SeedCollection[],
-): Promise<boolean> {
-	if (isI18nEnabled()) return true;
+): Promise<{ i18nEnabled: boolean; defaultLocale: string | undefined }> {
+	const config = getI18nConfig();
+	if (isI18nEnabled() && config) {
+		return { i18nEnabled: true, defaultLocale: config.defaultLocale };
+	}
 
 	const locales = new Set<string>();
-	const collectDistinctLocales = async (tableRef: ReturnType<typeof sql.ref>): Promise<boolean> => {
+	const collectDistinctLocales = async (tableRef: ReturnType<typeof sql.ref>): Promise<void> => {
 		const result = await sql<{ locale: string | null }>`
 			SELECT DISTINCT locale FROM ${tableRef}
 		`.execute(db);
 		for (const row of result.rows) {
 			if (row.locale) locales.add(row.locale);
 		}
-		return locales.size > 1;
 	};
 
-	if (await collectDistinctLocales(sql.ref("_emdash_taxonomy_defs"))) return true;
-	if (await collectDistinctLocales(sql.ref("_emdash_menus"))) return true;
+	await collectDistinctLocales(sql.ref("_emdash_taxonomy_defs"));
+	await collectDistinctLocales(sql.ref("_emdash_menus"));
 
 	for (const collection of collections) {
 		validateIdentifier(collection.slug, "collection slug");
 		// On D1, deleteCollection is non-atomic, so a collection row can outlive
 		// its ec_* table. Skip missing tables rather than crashing the export.
 		try {
-			if (await collectDistinctLocales(sql.ref(`ec_${collection.slug}`))) return true;
+			await collectDistinctLocales(sql.ref(`ec_${collection.slug}`));
 		} catch (error) {
 			if (!isMissingTableError(error)) throw error;
 		}
 	}
 
-	return false;
+	return {
+		i18nEnabled: locales.size > 1,
+		defaultLocale: locales.size === 1 ? [...locales][0] : undefined,
+	};
 }
 
 /**

package/src/cli/commands/secrets.ts

@@ -4,7 +4,7 @@
  * Pure (no-DB) commands for working with EmDash secrets:
  *
  * - `emdash secrets generate` — emits a fresh `EMDASH_ENCRYPTION_KEY`.
- *   Optionally writes it to `.dev.vars` (Workers) or `.env` (Node).
+ *   Optionally writes it to a local-secrets file (`.env`).
  * - `emdash secrets fingerprint <key>` — prints the kid for a key,
  *   useful in CI for verifying what's been deployed without exposing
  *   the raw value.
@@ -87,7 +87,7 @@ const generateCommand = defineCommand({
 		write: {
 			type: "string",
 			description:
-				"Optional path to write the key to (e.g. .dev.vars or .env). " +
+				"Optional path to write the key to (e.g. .env). " +
 				"Won't overwrite an existing entry without --force.",
 		},
 		force: {