emdash 0.37.0 → 0.38.0

package/src/api/handlers/content.ts

@@ -15,6 +15,7 @@ import {
 	isSystemOrderField,
 	type ContentRevisionPrecondition,
 } from "../../database/repositories/content.js";
+import { EntryLockRepository } from "../../database/repositories/entry-locks.js";
 import { RedirectRepository } from "../../database/repositories/redirect.js";
 import { RevisionRepository } from "../../database/repositories/revision.js";
 import { SeoRepository } from "../../database/repositories/seo.js";
@@ -425,6 +426,8 @@ async function createSlugChangeRedirect(
 	oldSlug: string,
 	newSlug: string,
 	contentId: string,
+	oldPublishedAt: string | null,
+	newPublishedAt: string | null,
 ): Promise<void> {
 	// A URL pattern has no locale token, so every locale variant of an entry
 	// generates the same URL, and slugs are unique per (slug, locale) — a
@@ -448,6 +451,8 @@ async function createSlugChangeRedirect(
 		newSlug,
 		contentId,
 		collectionRow?.url_pattern ?? null,
+		oldPublishedAt,
+		newPublishedAt,
 	);
 	invalidateRedirectCache();
 }
@@ -1095,17 +1100,27 @@ export async function handleContentUpdate(
 				updated.primaryBylineId = credits[0]?.byline.translationGroup ?? null;
 			}
 
-			// Create auto-redirect when slug changes
+			// Create auto-redirect when slug changes. Date tokens in the URL
+			// pattern resolve from the publish date, so the old URL uses the
+			// pre-update date (the URL that was actually live) and the new URL
+			// the post-update one.
 			if (oldSlug && body.slug) {
-				await createSlugChangeRedirect(trx, collection, oldSlug, body.slug, resolvedId);
+				await createSlugChangeRedirect(
+					trx,
+					collection,
+					oldSlug,
+					body.slug,
+					resolvedId,
+					existing?.publishedAt ?? null,
+					updated.publishedAt ?? null,
+				);
 			}
 
 			// Sync non-translatable fields to sibling locales in the same
 			// translation group. Only runs when i18n is enabled, data was updated,
 			// and the item belongs to a translation group with siblings.
 			if (isI18nEnabled() && body.data && updated.translationGroup) {
-				await syncNonTranslatableFields(
-					trx,
+				await trxRepo.syncNonTranslatableFields(
 					collection,
 					updated.id,
 					updated.translationGroup,
@@ -1283,10 +1298,11 @@ export async function handleContentDelete(
 		const result = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const resolvedId = (await resolveId(repo, collection, id)) ?? id;
-			return {
-				id: resolvedId,
-				deleted: await repo.delete(collection, resolvedId),
-			};
+			const deleted = await repo.delete(collection, resolvedId);
+			if (deleted) {
+				await new EntryLockRepository(trx).releaseEntry(collection, resolvedId);
+			}
+			return { id: resolvedId, deleted };
 		});
 
 		if (!result.deleted) {
@@ -1372,6 +1388,7 @@ export async function handleContentPermanentDelete(
 		// Wrap content delete + SEO/comment cleanup in a transaction
 		const deleted = await withTransaction(db, async (trx) => {
 			const trxRepo = new ContentRepository(trx);
+			const item = await trxRepo.findByIdIncludingTrashed(collection, resolvedId);
 			const wasDeleted = await trxRepo.permanentDelete(collection, resolvedId);
 
 			if (wasDeleted) {
@@ -1384,6 +1401,22 @@ export async function handleContentPermanentDelete(
 				// Clean up revisions for permanently deleted content
 				const revisionRepo = new RevisionRepository(trx);
 				await revisionRepo.deleteByEntry(collection, resolvedId);
+				await new EntryLockRepository(trx).releaseEntry(collection, resolvedId);
+				// Term assignments are keyed by translation_group, so they belong to the
+				// group rather than to this row. They go only once no row of the group is
+				// left, trashed ones included, since a trashed row can still be restored.
+				if (item?.translationGroup) {
+					const groupSurvives = await trxRepo.hasTranslationsIncludingTrashed(
+						collection,
+						item.translationGroup,
+					);
+					if (!groupSurvives) {
+						await new TaxonomyRepository(trx).clearEntryGroupTerms(
+							collection,
+							item.translationGroup,
+						);
+					}
+				}
 			}
 
 			return wasDeleted;
@@ -1593,7 +1626,7 @@ export async function handleContentUnschedule(
  * Publish content immediately.
  *
  * Publication is one atomic content-row statement. On databases that support
- * transactions, the existing slug-redirect side write remains grouped with it.
+ * transactions, the slug redirect and the locale sync stay grouped with it.
  */
 export async function handleContentPublish(
 	db: Kysely<Database>,
@@ -1631,6 +1664,21 @@ export async function handleContentPublish(
 				expectedRevision,
 			);
 
+			if (
+				existing &&
+				isI18nEnabled() &&
+				publishConfig.supportsRevisions &&
+				published.translationGroup
+			) {
+				await repo.syncNonTranslatableFields(
+					collection,
+					published.id,
+					published.translationGroup,
+					published.data,
+					{ previous: existing.data },
+				);
+			}
+
 			// Leave a 301 behind when publishing changed the slug of an entry that
 			// was already published — its old URL was live and may be indexed or
 			// linked. A first publish is excluded: a draft's URL was never public.
@@ -1640,7 +1688,15 @@ export async function handleContentPublish(
 				published.slug &&
 				existing.slug !== published.slug
 			) {
-				await createSlugChangeRedirect(trx, collection, existing.slug, published.slug, resolvedId);
+				await createSlugChangeRedirect(
+					trx,
+					collection,
+					existing.slug,
+					published.slug,
+					resolvedId,
+					existing.publishedAt ?? null,
+					published.publishedAt ?? null,
+				);
 			}
 
 			return published;
@@ -1986,75 +2042,6 @@ export async function handleContentTranslations(
 	}
 }
 
-// ---------------------------------------------------------------------------
-// Non-translatable field sync
-// ---------------------------------------------------------------------------
-
-/**
- * Sync non-translatable fields to sibling locales.
- *
- * When a content item is updated and it belongs to a translation group,
- * any non-translatable fields in the update data are written to all other
- * rows in the same translation group within the same transaction.
- *
- * Non-translatable fields are **copied, not linked** — each row owns its
- * own data. This keeps queries simple and avoids cross-row joins.
- */
-async function syncNonTranslatableFields(
-	trx: Kysely<Database>,
-	collectionSlug: string,
-	updatedItemId: string,
-	translationGroup: string,
-	data: Record<string, unknown>,
-): Promise<void> {
-	// Get the collection to find its fields
-	const collection = await trx
-		.selectFrom("_emdash_collections")
-		.select("id")
-		.where("slug", "=", collectionSlug)
-		.executeTakeFirst();
-
-	if (!collection) return;
-
-	// Find non-translatable fields that are present in the update data
-	const fields = await trx
-		.selectFrom("_emdash_fields")
-		.select("slug")
-		.where("collection_id", "=", collection.id)
-		.where("translatable", "=", 0)
-		.execute();
-
-	const nonTranslatableSlugs = fields.map((f) => f.slug);
-	if (nonTranslatableSlugs.length === 0) return;
-
-	// Filter to only the non-translatable fields present in this update
-	const syncData: Record<string, unknown> = {};
-	for (const slug of nonTranslatableSlugs) {
-		if (slug in data) {
-			syncData[slug] = data[slug];
-		}
-	}
-	if (Object.keys(syncData).length === 0) return;
-
-	// Build the SET clause for sibling rows
-	validateIdentifier(collectionSlug, "collection slug");
-	const tableName = `ec_${collectionSlug}`;
-
-	// Update all sibling rows (same translation_group, different id)
-	const setClauses = Object.entries(syncData).map(([key, value]) => {
-		validateIdentifier(key, "field slug");
-		const serialized = typeof value === "object" && value !== null ? JSON.stringify(value) : value;
-		return sql`${sql.ref(key)} = ${serialized}`;
-	});
-
-	await sql`
-		UPDATE ${sql.ref(tableName)}
-		SET ${sql.join(setClauses, sql`, `)}
-		WHERE translation_group = ${translationGroup}
-		AND id != ${updatedItemId}
-	`.execute(trx);
-}
-
 /**
  * Resolve a `{ taxonomyName: [slug, ...] }` map to term IDs and replace the
  * entry's assignments for each named taxonomy.

package/src/api/handlers/entry-lock.ts

@@ -0,0 +1,206 @@
+import type { Kysely } from "kysely";
+import { ulid } from "ulidx";
+
+import { EntryLockRepository, type EntryLock } from "../../database/repositories/entry-locks.js";
+import type { Database } from "../../database/types.js";
+import { ErrorCode } from "../errors.js";
+import type { ApiResult } from "../types.js";
+
+/**
+ * How long an entry stays locked without a heartbeat or save. Long enough to
+ * survive a pause in typing, short enough that a closed tab frees the entry
+ * within a coffee break.
+ */
+export const ENTRY_LOCK_LEASE_MS = 7 * 60 * 1000;
+
+const ENTRY_LOCK_LEASE_SECONDS = ENTRY_LOCK_LEASE_MS / 1000;
+
+export interface EntryLockHolder {
+	userId: string;
+	userName: string | null;
+	acquiredAt: string;
+	expiresAt: string;
+}
+
+export interface EntryLockStatus {
+	/** Whether the collection takes edit locks at all. */
+	enabled: boolean;
+	/** The live lease, whoever holds it. */
+	holder: EntryLockHolder | null;
+	/** Whether `holder` is the caller. */
+	heldByCaller: boolean;
+}
+
+export interface EntryLockRefusal {
+	code: typeof ErrorCode.ENTRY_LOCKED;
+	message: string;
+	details: EntryLockHolder;
+}
+
+function toHolder(lock: EntryLock): EntryLockHolder {
+	return {
+		userId: lock.userId,
+		userName: lock.userName,
+		acquiredAt: lock.acquiredAt,
+		expiresAt: lock.expiresAt,
+	};
+}
+
+function holderLabel(holder: EntryLockHolder): string {
+	return holder.userName?.trim() ? holder.userName : "Another editor";
+}
+
+async function isLockingEnabled(db: Kysely<Database>, collection: string): Promise<boolean | null> {
+	const row = await db
+		.selectFrom("_emdash_collections")
+		.select("edit_locking")
+		.where("slug", "=", collection)
+		.executeTakeFirst();
+	if (!row) return null;
+	return row.edit_locking !== 0;
+}
+
+function collectionNotFound(collection: string): ApiResult<never> {
+	return {
+		success: false,
+		error: {
+			code: ErrorCode.COLLECTION_NOT_FOUND,
+			message: `Collection '${collection}' not found`,
+		},
+	};
+}
+
+/**
+ * Takes the entry's lock for `userId`, or reports who is holding it. A
+ * take-over is only granted when the caller asks for one.
+ */
+export async function handleEntryLockAcquire(
+	db: Kysely<Database>,
+	collection: string,
+	entryId: string,
+	userId: string,
+	options: { takeover?: boolean; token?: string } = {},
+): Promise<ApiResult<EntryLockStatus>> {
+	try {
+		const enabled = await isLockingEnabled(db, collection);
+		if (enabled === null) return collectionNotFound(collection);
+		if (!enabled) {
+			return { success: true, data: { enabled: false, holder: null, heldByCaller: false } };
+		}
+
+		const claim = await new EntryLockRepository(db).acquire({
+			collection,
+			entryId,
+			userId,
+			token: options.token ?? ulid(),
+			leaseSeconds: ENTRY_LOCK_LEASE_SECONDS,
+			takeover: options.takeover,
+		});
+
+		return {
+			success: true,
+			data: {
+				enabled: true,
+				holder: toHolder(claim.lock),
+				heldByCaller: claim.outcome === "acquired",
+			},
+		};
+	} catch (error) {
+		console.error("[entry-lock] acquire failed:", error);
+		return {
+			success: false,
+			error: { code: ErrorCode.ENTRY_LOCK_ERROR, message: "Failed to acquire the entry lock" },
+		};
+	}
+}
+
+export async function handleEntryLockRead(
+	db: Kysely<Database>,
+	collection: string,
+	entryId: string,
+	userId: string,
+): Promise<ApiResult<EntryLockStatus>> {
+	try {
+		const enabled = await isLockingEnabled(db, collection);
+		if (enabled === null) return collectionNotFound(collection);
+		if (!enabled) {
+			return { success: true, data: { enabled: false, holder: null, heldByCaller: false } };
+		}
+
+		const lock = await new EntryLockRepository(db).findLive(collection, entryId);
+		return {
+			success: true,
+			data: {
+				enabled: true,
+				holder: lock ? toHolder(lock) : null,
+				heldByCaller: lock?.userId === userId,
+			},
+		};
+	} catch (error) {
+		console.error("[entry-lock] read failed:", error);
+		return {
+			success: false,
+			error: { code: ErrorCode.ENTRY_LOCK_ERROR, message: "Failed to read the entry lock" },
+		};
+	}
+}
+
+export async function handleEntryLockRelease(
+	db: Kysely<Database>,
+	collection: string,
+	entryId: string,
+	userId: string,
+	options: { token?: string } = {},
+): Promise<ApiResult<{ released: boolean }>> {
+	try {
+		const released = await new EntryLockRepository(db).release({
+			collection,
+			entryId,
+			userId,
+			token: options.token,
+		});
+		return { success: true, data: { released } };
+	} catch (error) {
+		console.error("[entry-lock] release failed:", error);
+		return {
+			success: false,
+			error: { code: ErrorCode.ENTRY_LOCK_ERROR, message: "Failed to release the entry lock" },
+		};
+	}
+}
+
+/**
+ * Decides whether a write may proceed, and keeps the caller's own lease alive
+ * while it does. Resolves to `null` when the write is allowed.
+ *
+ * A write never takes a lock it was not given, so a CLI or API caller writing
+ * an unlocked entry leaves it unlocked.
+ */
+export async function claimEntryLockForWrite(
+	db: Kysely<Database>,
+	collection: string,
+	entryId: string,
+	userId: string,
+	options: { override?: boolean } = {},
+): Promise<EntryLockRefusal | null> {
+	if (options.override === true) return null;
+
+	const repo = new EntryLockRepository(db);
+	const heldByCaller = await repo.refreshHeld({
+		collection,
+		entryId,
+		userId,
+		leaseSeconds: ENTRY_LOCK_LEASE_SECONDS,
+	});
+	if (heldByCaller) return null;
+
+	const holder = await repo.findEnforceable(collection, entryId);
+	if (!holder) return null;
+
+	const details = toHolder(holder);
+	return {
+		code: ErrorCode.ENTRY_LOCKED,
+		message: `${holderLabel(details)} is holding this entry`,
+		details,
+	};
+}

package/src/api/handlers/manifest.ts

@@ -170,6 +170,7 @@ export async function buildManifestCollections(
 				titleField: collection.titleField,
 				dateField: collection.dateField,
 				...(collection.hidden ? { hidden: true } : {}),
+				...(collection.group ? { group: collection.group } : {}),
 				listColumns: listColumns.length > 0 ? listColumns : undefined,
 				fields,
 			};

package/src/api/handlers/marketplace.ts

@@ -22,6 +22,7 @@ import {
 	type MarketplaceVersionSummary,
 	type PluginBundle,
 } from "../../plugins/marketplace.js";
+import { withUnavailableReason } from "../../plugins/sandbox/types.js";
 import type { SandboxRunner } from "../../plugins/sandbox/types.js";
 import { PluginStateRepository } from "../../plugins/state.js";
 import {
@@ -363,7 +364,10 @@ export async function handleMarketplaceInstall(
 			success: false,
 			error: {
 				code: "SANDBOX_NOT_AVAILABLE",
-				message: "Sandbox runner is required for marketplace plugins",
+				message: withUnavailableReason(
+					"Sandbox runner is required for marketplace plugins",
+					sandboxRunner,
+				),
 			},
 		};
 	}
@@ -584,7 +588,10 @@ export async function handleMarketplaceUpdate(
 	if (!opts?.sandboxBypassed && (!sandboxRunner || !sandboxRunner.isAvailable())) {
 		return {
 			success: false,
-			error: { code: "SANDBOX_NOT_AVAILABLE", message: "Sandbox runner is required" },
+			error: {
+				code: "SANDBOX_NOT_AVAILABLE",
+				message: withUnavailableReason("Sandbox runner is required", sandboxRunner),
+			},
 		};
 	}
 
@@ -658,6 +665,21 @@ export async function handleMarketplaceUpdate(
 		const oldCaps = oldBundle?.manifest.capabilities ?? [];
 		const capabilityChanges = diffCapabilities(oldCaps, bundle.manifest.capabilities);
 		const hasEscalation = capabilityChanges.added.length > 0;
+		const routeVisibilityChanges = diffRouteVisibility(oldBundle?.manifest, bundle.manifest);
+		const hasNewPublicRoutes = routeVisibilityChanges.newlyPublic.length > 0;
+		const oldMcpTools = [...(oldBundle?.manifest.mcp?.tools ?? [])].toSorted((a, b) =>
+			a.name.localeCompare(b.name),
+		);
+		const newMcpTools = [...(bundle.manifest.mcp?.tools ?? [])].toSorted((a, b) =>
+			a.name.localeCompare(b.name),
+		);
+		const hasMcpChanges = JSON.stringify(oldMcpTools) !== JSON.stringify(newMcpTools);
+		const mcpTools = newMcpTools.map(({ inputSchema: _, outputSchema: __, ...tool }) => tool);
+		const consentDetails = {
+			capabilityChanges,
+			routeVisibilityChanges: hasNewPublicRoutes ? routeVisibilityChanges : undefined,
+			mcpTools: hasMcpChanges ? mcpTools : undefined,
+		};
 
 		// If capabilities escalated, require explicit confirmation
 		if (hasEscalation && !opts?.confirmCapabilityChanges) {
@@ -666,42 +688,31 @@ export async function handleMarketplaceUpdate(
 				error: {
 					code: "CAPABILITY_ESCALATION",
 					message: "Plugin update requires new capabilities",
-					details: { capabilityChanges },
+					details: consentDetails,
 				},
 			};
 		}
 
 		// Diff route visibility — routes going from private to public are a
 		// security-sensitive change that exposes unauthenticated endpoints.
-		const routeVisibilityChanges = diffRouteVisibility(oldBundle?.manifest, bundle.manifest);
-		const hasNewPublicRoutes = routeVisibilityChanges.newlyPublic.length > 0;
-
 		if (hasNewPublicRoutes && !opts?.confirmRouteVisibilityChanges) {
 			return {
 				success: false,
 				error: {
 					code: "ROUTE_VISIBILITY_ESCALATION",
 					message: "Plugin update exposes new public (unauthenticated) routes",
-					details: { routeVisibilityChanges, capabilityChanges },
+					details: consentDetails,
 				},
 			};
 		}
 
-		const oldMcpTools = [...(oldBundle?.manifest.mcp?.tools ?? [])].toSorted((a, b) =>
-			a.name.localeCompare(b.name),
-		);
-		const newMcpTools = [...(bundle.manifest.mcp?.tools ?? [])].toSorted((a, b) =>
-			a.name.localeCompare(b.name),
-		);
-		if (JSON.stringify(oldMcpTools) !== JSON.stringify(newMcpTools) && !opts?.confirmMcpTools) {
+		if (hasMcpChanges && !opts?.confirmMcpTools) {
 			return {
 				success: false,
 				error: {
 					code: "MCP_TOOL_CONSENT_REQUIRED",
 					message: "Plugin update changes its MCP tools",
-					details: {
-						mcpTools: newMcpTools.map(({ inputSchema: _, outputSchema: __, ...tool }) => tool),
-					},
+					details: consentDetails,
 				},
 			};
 		}
@@ -721,9 +732,6 @@ export async function handleMarketplaceUpdate(
 
 		await syncDeclaredStorageIndexes(db, [bundle.manifest]);
 
-		// Clean up old bundle from R2 (best-effort)
-		deleteBundleFromR2(storage, pluginId, oldVersion).catch(() => {});
-
 		return {
 			success: true,
 			data: {

package/src/api/handlers/menus.ts

@@ -173,6 +173,15 @@ export async function handleMenuCreate(
 					error: { code: "NOT_FOUND", message: "Source menu for translation not found" },
 				};
 			}
+			if (source.name !== input.name) {
+				return {
+					success: false,
+					error: {
+						code: "VALIDATION_ERROR",
+						message: `A translation of menu "${source.name}" must use the same name`,
+					},
+				};
+			}
 		}
 
 		// Duplicate guard: same (name, locale). Falls back to the configured

package/src/api/handlers/registry.ts

@@ -13,6 +13,7 @@ import { canonicalizeDeclaredAccess } from "@emdash-cms/plugin-types";
 import type { CanonicalDeclaredAccess } from "@emdash-cms/plugin-types";
 import { checkEnvCompatibility, findSkippedEnvConstraints } from "@emdash-cms/registry-client/env";
 import type { HostEnv } from "@emdash-cms/registry-client/env";
+import { isProvenFirstRelease } from "@emdash-cms/registry-client/listing-policy";
 import { evaluateRegistryReleaseWithdrawal } from "@emdash-cms/registry-client/withdrawal";
 import { NSID } from "@emdash-cms/registry-lexicons";
 import {
@@ -22,6 +23,7 @@ import {
 import type { Kysely } from "kysely";
 
 import type { Database } from "../../database/types.js";
+import { withUnavailableReason } from "../../plugins/sandbox/types.js";
 import type { SandboxRunner } from "../../plugins/sandbox/types.js";
 import { PluginStateRepository } from "../../plugins/state.js";
 import {
@@ -468,7 +470,10 @@ export async function handleRegistryInstall(
 			success: false,
 			error: {
 				code: "SANDBOX_NOT_AVAILABLE",
-				message: "Sandbox runner is required for registry plugins",
+				message: withUnavailableReason(
+					"Sandbox runner is required for registry plugins",
+					sandboxRunner,
+				),
 			},
 		};
 	}
@@ -728,7 +733,9 @@ export async function handleRegistryInstall(
 			const exclude = registryConfig.policy?.minimumReleaseAgeExclude?.map((e) =>
 				e.trim().toLowerCase(),
 			);
-			const exempt = releaseExemptFromMinimumAge(exclude, publisherDid, slug);
+			const exempt =
+				releaseExemptFromMinimumAge(exclude, publisherDid, slug) ||
+				isProvenFirstRelease(packageView);
 			if (!exempt) {
 				const indexedAt = Date.parse(releaseView.indexedAt);
 				if (!Number.isFinite(indexedAt)) {
@@ -1229,7 +1236,10 @@ export async function handleRegistryUpdate(
 	if (!sandboxRunner || !sandboxRunner.isAvailable()) {
 		return {
 			success: false,
-			error: { code: "SANDBOX_NOT_AVAILABLE", message: "Sandbox runner is required" },
+			error: {
+				code: "SANDBOX_NOT_AVAILABLE",
+				message: withUnavailableReason("Sandbox runner is required", sandboxRunner),
+			},
 		};
 	}
 	try {
@@ -1567,11 +1577,6 @@ export async function handleRegistryUpdate(
 
 		await syncDeclaredStorageIndexes(db, [bundle.manifest]);
 
-		// Best-effort cleanup of the old bundle. Failures here don't roll
-		// back the upgrade (the new bundle is already stored and committed
-		// in the state row); the orphan is just storage we'll pay for.
-		deleteBundleFromR2(storage, pluginId, oldVersion, "registry").catch(() => {});
-
 		return {
 			success: true,
 			data: {

package/src/api/handlers/revision.ts

@@ -9,6 +9,7 @@ import { ContentRepository } from "../../database/repositories/content.js";
 import { RevisionRepository, type Revision } from "../../database/repositories/revision.js";
 import { withTransaction } from "../../database/transaction.js";
 import type { Database } from "../../database/types.js";
+import { encodeRev } from "../rev.js";
 import type { ApiResult, ContentResponse } from "../types.js";
 
 export interface RevisionListResponse {
@@ -154,7 +155,7 @@ export async function handleRevisionRestore(
 
 		return {
 			success: true,
-			data: { item },
+			data: { item, _rev: encodeRev(item) },
 		};
 	} catch {
 		return {

package/src/api/handlers/seo.ts

@@ -18,6 +18,13 @@ export interface SitemapContentEntry {
 	slug: string | null;
 	/** ISO date of last modification */
 	updatedAt: string;
+	/**
+	 * ISO publish date, or null when never published. Used to resolve
+	 * date tokens (`{year}`/`{month}`/`{day}`) in the collection's
+	 * `url_pattern` — the published date keeps permalinks stable across
+	 * later edits (unlike `updatedAt`).
+	 */
+	publishedAt: string | null;
 	/**
 	 * Locale of this row (e.g. `"en"`, `"fr"`). Always present — rows in
 	 * pre-i18n databases are backfilled to the configured `defaultLocale`.
@@ -139,11 +146,12 @@ export async function handleSitemapData(
 					slug: string | null;
 					id: string;
 					updated_at: string;
+					published_at: string | null;
 					locale: string;
 					translation_group: string | null;
 					seo_image: string | null;
 				}>`
-					SELECT c.slug, c.id, c.updated_at, c.locale, c.translation_group, s.seo_image
+					SELECT c.slug, c.id, c.updated_at, c.published_at, c.locale, c.translation_group, s.seo_image
 					FROM ${sql.ref(tableName)} c
 					LEFT JOIN _emdash_seo s
 						ON s.collection = ${col.slug}
@@ -165,6 +173,7 @@ export async function handleSitemapData(
 						id: row.id,
 						slug: row.slug,
 						updatedAt: toW3CDate(row.updated_at),
+						publishedAt: row.published_at ?? null,
 						locale: row.locale,
 						translationGroup: row.translation_group,
 						image: row.seo_image ?? null,