dineway 0.2.39 → 0.2.41

package/dist/media/index.mjs

@@ -1,5 +1,5 @@
-import { n as normalizeMediaValue } from "../normalize-aTwryvvi.mjs";
-import { n as generatePlaceholder, t as enrichImageMetadata } from "../enrich-B7PIJ8Iy.mjs";
+import { n as normalizeMediaValue } from "../normalize-DrmlLn40.mjs";
+import { n as generatePlaceholder, t as enrichImageMetadata } from "../enrich-CAMsD1aT.mjs";
 
 //#region src/media/types.ts
 /**

package/dist/media/local-runtime.d.mts

@@ -1,16 +1,19 @@
-import "../types-CJynaYg1.mjs";
-import { t as Database } from "../types-B--VyN3n.mjs";
-import { h as MediaProviderItem, o as CreateMediaProviderFn } from "../placeholder-DJLP_HY7.mjs";
-import "../runner-SoP1rphP.mjs";
-import "../index-BVGe04wF.mjs";
-import "../types-B03h5jt_.mjs";
-import "../adapters-C8nRpUuj.mjs";
-import { d as Storage } from "../types-KFzuijKE.mjs";
-import "../scheduled-publish-BxdShRGs.mjs";
-import "../public-url-Ccv0Xmue.mjs";
-import "../validate-kmN2lS8H.mjs";
-import "../byline-fields-CKhPED5o.mjs";
-import "../types-DsJTXStN.mjs";
+import "../types-C3jUu4Bc.mjs";
+import { n as Database } from "../types-Dpv_MvwZ.mjs";
+import { h as MediaProviderItem, o as CreateMediaProviderFn } from "../placeholder-DdZV3I8x.mjs";
+import "../runner-DXQkyPeX.mjs";
+import "../index-CLj17kW9.mjs";
+import "../types-qOEot0UQ.mjs";
+import "../types-DheoByey.mjs";
+import "../adapters-lDnJjNDz.mjs";
+import "../runtime-Bs2JMbb2.mjs";
+import "../hook-events-BQw73jc7.mjs";
+import { d as Storage } from "../types-C0heD9oI.mjs";
+import "../scheduled-publish-eCNGpvNm.mjs";
+import "../public-url-CEC1vj02.mjs";
+import "../validate-DUscf6VG.mjs";
+import "../byline-fields-Bne2v0ti.mjs";
+import "../types-BJztoTbF.mjs";
 import "../index.mjs";
 import { Kysely } from "kysely";
 

package/dist/media/local-runtime.mjs

@@ -1,6 +1,6 @@
-import "../base64-Cz-aU0X1.mjs";
-import "../types-RFzE_V1M.mjs";
-import { t as MediaRepository } from "../media-C5ba8fvI.mjs";
+import "../base64-qvSs0Gxy.mjs";
+import "../types-BI3ULB3A.mjs";
+import { t as MediaRepository } from "../media-BjH5OD-A.mjs";
 
 //#region src/media/local-runtime.ts
 /**

package/dist/{media-C5ba8fvI.mjs → media-BjH5OD-A.mjs}

@@ -1,4 +1,4 @@
-import { i as encodeCursor, r as decodeCursor } from "./types-RFzE_V1M.mjs";
+import { i as encodeCursor, r as decodeCursor } from "./types-BI3ULB3A.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 

package/dist/{media-allowlist-DQvscVkS.mjs → media-allowlist-C8HJ2O61.mjs}

@@ -1,4 +1,4 @@
-import { r as parseAllowedMimeTypes } from "./mime-BnVhH671.mjs";
+import { r as parseAllowedMimeTypes } from "./mime-FkfazULS.mjs";
 
 //#region src/api/handlers/media-allowlist.ts
 /**

package/dist/{menus-CyNpBQrX.mjs → menus-CbBi7Ad7.mjs}

@@ -1,7 +1,7 @@
-import { c as __exportAll } from "./runner-CRU7BXjr.mjs";
+import { c as __exportAll } from "./runner-CuG8o1uW.mjs";
 import { AtomicWriteConflict, atomicBatch, rowUnchanged } from "./database/batch.mjs";
 import { n as getI18nConfig } from "./config-XW5tMrH8.mjs";
-import { c as invalidateMenuObjectCache } from "./object-cache-mxCW-Rpt.mjs";
+import { c as invalidateMenuObjectCache } from "./object-cache-DyI1SOBK.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 

package/dist/{menus-w5xwT-f5.mjs → menus-D0c8CeVg.mjs}

@@ -1,11 +1,11 @@
 import { t as validateIdentifier } from "./validate-Co3j6T_K.mjs";
-import { r as getDb } from "./loader-Dp6zLmQm.mjs";
-import { n as cachedQuery, t as CacheNamespace } from "./object-cache-mxCW-Rpt.mjs";
-import { t as CommentRepository } from "./comment-DAQfUjqt.mjs";
-import { r as requestCached } from "./request-cache-8_ifFzVw.mjs";
-import { n as resolveLocaleChain, t as resolveLocale } from "./resolve-DEKC4qVa.mjs";
-import { n as sanitizeHref } from "./url-DGG3hw_h.mjs";
-import { t as CommentReactionRepository } from "./comment-reaction-Dp3G7UZc.mjs";
+import { r as getDb } from "./loader-CCwWFQSh.mjs";
+import { r as requestCached } from "./request-cache-CizvDoxV.mjs";
+import { n as cachedQuery, t as CacheNamespace } from "./object-cache-DyI1SOBK.mjs";
+import { t as CommentRepository } from "./comment-BWDG1nQm.mjs";
+import { n as resolveLocaleChain, t as resolveLocale } from "./resolve-BxFGSKYu.mjs";
+import { n as sanitizeHref } from "./url-Coamqvs4.mjs";
+import { t as CommentReactionRepository } from "./comment-reaction-B7pLTlQ7.mjs";
 import { sql } from "kysely";
 
 //#region src/comments/ranking.ts

package/dist/migration-DJuj7ZwN.mjs

@@ -0,0 +1,526 @@
+import { atomicBatch, rowUnchanged } from "./database/batch.mjs";
+import { a as validateContentStorage, i as resolveContentPartition, n as contentDigest, o as ContentStorageError, t as canonicalContentJson } from "./config-6R0bchVE.mjs";
+import { h as prepareContentChangeJournal, m as contentChangeSequence, p as readContentPartitionRoute, r as getContentStorage, u as cancelContentMigration } from "./runtime-Ch5G-tnG.mjs";
+import { n as readRevisionDataBatch, r as storedRevisionIndex } from "./revisions-CQ7rMP5d.mjs";
+import { t as ContentRepository } from "./content-BigS8BAv.mjs";
+import { o as invalidateCollectionCache } from "./object-cache-DyI1SOBK.mjs";
+import { A as prepareContentProjection, i as contentWriteConfiguration, j as snapshotPartitionDependencies, k as contentProjectionValues } from "./content-write-DAZCNKWl.mjs";
+import { a as contentVersionSchema } from "./version-store-BXv2D0de.mjs";
+import { a as contentItemSchema } from "./content-Dr22fzA_.mjs";
+import { sql } from "kysely";
+import { z } from "zod";
+
+//#region src/content-storage/config-migration.ts
+/** Explicit deployment step. Mapping changes retain the source until its data migration completes. */
+async function migrateContentStorageConfig(db, previous, next) {
+	validateContentStorage(previous);
+	validateContentStorage(next);
+	if (previous.version === next.version) throw new ContentStorageError("INVALID_CONFIG", "A routing configuration change requires a new version.");
+	const oldDigest = await contentDigest(previous);
+	const digest = await contentDigest(next);
+	const installed = (await sql`SELECT version,digest FROM _dineway_content_storage_config WHERE id='active'`.execute(db)).rows[0];
+	if (installed?.version === next.version && installed.digest === digest) return;
+	const checks = [
+		sql`NOT EXISTS (SELECT 1 FROM _dineway_content_hook_deliveries WHERE delivered_at IS NULL)`,
+		sql`EXISTS (SELECT 1 FROM _dineway_content_storage_config WHERE id='active' AND version=${previous.version} AND digest=${oldDigest})`,
+		sql`NOT EXISTS (SELECT 1 FROM _dineway_content_partitions WHERE state<>'active')`
+	];
+	const statements = [];
+	for (const [name, descriptor] of Object.entries(previous.stores)) {
+		const replacement = next.stores[name];
+		if (replacement && replacement.identity !== descriptor.identity) throw new ContentStorageError("INVALID_CONFIG", "Add the replacement database under a new store name, migrate its partitions, then remove the old store.");
+		if (!replacement) checks.push(sql`NOT EXISTS (SELECT 1 FROM _dineway_content_locations WHERE store=${name})`, sql`NOT EXISTS (SELECT 1 FROM revisions WHERE json_extract(data,'$.__dineway_content_storage__.store')=${name})`, sql`NOT EXISTS (SELECT 1 FROM _dineway_content_partitions WHERE store=${name})`);
+	}
+	for (const collection of new Set([...Object.keys(previous.rules), ...Object.keys(next.rules)])) {
+		const oldRule = previous.rules[collection];
+		const rule = next.rules[collection];
+		const rebuild = !oldRule || !rule || canonicalContentJson(oldRule.partitionBy) !== canonicalContentJson(rule.partitionBy);
+		if (rebuild && oldRule) {
+			checks.push(sql`NOT EXISTS (SELECT 1 FROM _dineway_content_locations WHERE collection=${collection} AND store<>'primary')`, sql`NOT EXISTS (SELECT 1 FROM revisions WHERE collection=${collection} AND json_type(data,'$.__dineway_content_storage__') IS NOT NULL)`);
+			statements.push(sql`DELETE FROM _dineway_content_locations WHERE collection=${collection}`.compile(db), sql`DELETE FROM _dineway_content_partitions WHERE collection=${collection}`.compile(db));
+		}
+		if (!rule) continue;
+		statements.push(...await prepareContentChangeJournal(db, collection));
+		if (!rebuild) for (const partition of Object.keys(oldRule.stores)) {
+			if (Object.hasOwn(rule.stores, partition)) continue;
+			checks.push(sql`NOT EXISTS (SELECT 1 FROM _dineway_content_locations WHERE collection=${collection} AND partition=${partition})`);
+			statements.push(sql`DELETE FROM _dineway_content_partitions WHERE collection=${collection} AND partition=${partition}`.compile(db));
+		}
+		for (const [partition, store] of Object.entries(rule.stores)) if (rebuild || !Object.hasOwn(oldRule.stores, partition)) statements.push(sql`INSERT INTO _dineway_content_partitions (collection,partition,store,target_store,state,epoch,migration_id,updated_at) VALUES (${collection},${partition},'primary',${store},'active',1,NULL,${(/* @__PURE__ */ new Date()).toISOString()})`.compile(db));
+		else statements.push(sql`UPDATE _dineway_content_partitions SET target_store=${store},epoch=epoch+1,updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE collection=${collection} AND partition=${partition}`.compile(db));
+	}
+	statements.push(sql`UPDATE _dineway_content_operations SET state='aborted',updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE state='pending'`.compile(db), sql`UPDATE _dineway_content_storage_config SET version=${next.version},digest=${digest} WHERE id='active'`.compile(db));
+	await atomicBatch(db, {
+		checks,
+		statements
+	});
+}
+
+//#endregion
+//#region src/content-storage/migration-snapshot.ts
+const rowSchema = z.record(z.string(), z.json());
+const revisionSchema = z.object({
+	id: z.string(),
+	collection: z.string(),
+	entry_id: z.string(),
+	data: z.string(),
+	author_id: z.string().nullable(),
+	created_at: z.string()
+});
+const contentMigrationSnapshotSchema = z.object({
+	collection: z.string(),
+	entryId: z.string(),
+	schemaDigest: z.string(),
+	changeSequence: z.number().int().nonnegative(),
+	row: rowSchema,
+	item: contentItemSchema.extend({ data: rowSchema }),
+	location: rowSchema.nullable(),
+	partitionDependencies: rowSchema,
+	revisions: z.array(z.object({
+		row: revisionSchema,
+		data: rowSchema
+	})),
+	owned: z.object({
+		terms: z.array(rowSchema),
+		bylines: z.array(rowSchema),
+		seo: z.array(rowSchema)
+	})
+}).strict();
+function contentMigrationSnapshotChecks(snapshot, options = {}) {
+	const { collection, entryId } = snapshot;
+	return [
+		...options.journal === false ? [] : [sql`${contentChangeSequence(collection, entryId)}=${snapshot.changeSequence}`],
+		rowUnchanged(`ec_${collection}`, snapshot.row),
+		...snapshot.revisions.map((revision) => rowUnchanged("revisions", revision.row)),
+		sql`(SELECT COUNT(*) FROM revisions WHERE collection=${collection} AND entry_id=${entryId})=${snapshot.revisions.length}`,
+		...snapshot.owned.terms.map((row) => rowUnchanged("content_taxonomies", row)),
+		sql`(SELECT COUNT(*) FROM content_taxonomies WHERE collection=${collection} AND entry_id=${entryId})=${snapshot.owned.terms.length}`,
+		...snapshot.owned.bylines.map((row) => rowUnchanged("_dineway_content_bylines", row)),
+		sql`(SELECT COUNT(*) FROM _dineway_content_bylines WHERE collection_slug=${collection} AND content_id=${entryId})=${snapshot.owned.bylines.length}`,
+		...snapshot.owned.seo.map((row) => rowUnchanged("_dineway_seo", row)),
+		sql`(SELECT COUNT(*) FROM _dineway_seo WHERE collection=${collection} AND content_id=${entryId})=${snapshot.owned.seo.length}`,
+		...snapshot.location ? [rowUnchanged("_dineway_content_locations", snapshot.location)] : [sql`NOT EXISTS (SELECT 1 FROM _dineway_content_locations WHERE collection=${collection} AND entry_id=${entryId})`]
+	];
+}
+/** Capture an entry, complete history and owned metadata without changing its visibility. */
+async function captureContentMigrationSnapshot(db, collection, entryId) {
+	const storage = getContentStorage(db, collection);
+	if (!storage) throw new ContentStorageError("INVALID_CONFIG", "The content type has no storage migration configuration.");
+	const configuration = await contentWriteConfiguration(db, collection);
+	const row = (await sql`SELECT * FROM ${sql.table(`ec_${collection}`)} WHERE id=${entryId}`.execute(db)).rows[0];
+	const item = await new ContentRepository(db).findByIdIncludingTrashed(collection, entryId);
+	if (!row || !item || row.version !== item.version) throw new ContentStorageError("CONFLICT", "The source entry changed while taking its snapshot.");
+	const revisions = [];
+	let afterId = "";
+	for (;;) {
+		const page = await db.selectFrom("revisions").selectAll().where("collection", "=", collection).where("entry_id", "=", entryId).where("id", ">", afterId).orderBy("id").limit(32).execute();
+		const data = await readRevisionDataBatch(db, page);
+		revisions.push(...page.map((revision, index) => ({
+			row: revision,
+			data: rowSchema.parse(data[index])
+		})));
+		if (page.length < 32) break;
+		afterId = page.at(-1).id;
+	}
+	const terms = await db.selectFrom("content_taxonomies").selectAll().where("collection", "=", collection).where("entry_id", "=", entryId).orderBy("taxonomy_id").execute();
+	const bylines = await db.selectFrom("_dineway_content_bylines").selectAll().where("collection_slug", "=", collection).where("content_id", "=", entryId).orderBy("id").execute();
+	const seo = await db.selectFrom("_dineway_seo").selectAll().where("collection", "=", collection).where("content_id", "=", entryId).execute();
+	const location = (await sql`SELECT * FROM _dineway_content_locations WHERE collection=${collection} AND entry_id=${entryId}`.execute(db)).rows[0] ?? null;
+	const dependencies = await snapshotPartitionDependencies(db, collection, item, storage.runtime.config.rules[collection]);
+	const changeSequence = (await sql`SELECT ${contentChangeSequence(collection, entryId)} AS sequence`.execute(db)).rows[0].sequence;
+	const snapshot = contentMigrationSnapshotSchema.parse({
+		collection,
+		entryId,
+		schemaDigest: await contentDigest({
+			collection: configuration.row,
+			fields: configuration.fields
+		}),
+		changeSequence,
+		row,
+		item,
+		location,
+		partitionDependencies: dependencies.dependencies,
+		revisions,
+		owned: {
+			terms,
+			bylines,
+			seo
+		}
+	});
+	await atomicBatch(db, {
+		checks: [
+			...configuration.checks,
+			...dependencies.checks,
+			...contentMigrationSnapshotChecks(snapshot)
+		],
+		statements: []
+	});
+	return snapshot;
+}
+/** Index legacy primary rows in resumable pages before taking a partition's write freeze. */
+async function bootstrapContentDirectoryPage(db, collection, options = {}) {
+	const storage = getContentStorage(db, collection);
+	if (!storage) throw new ContentStorageError("INVALID_CONFIG", "The content type has no storage routing configuration.");
+	const limit = Math.min(100, Math.max(1, Math.trunc(options.limit ?? 20)));
+	const ids = (await sql`SELECT c.id FROM ${sql.table(`ec_${collection}`)} c WHERE c.id>${options.afterId ?? ""} AND NOT EXISTS (SELECT 1 FROM _dineway_content_locations l WHERE l.collection=${collection} AND l.entry_id=c.id) ORDER BY c.id LIMIT ${limit}`.execute(db)).rows;
+	for (const { id } of ids) {
+		const raw = (await sql`SELECT * FROM ${sql.table(`ec_${collection}`)} WHERE id=${id}`.execute(db)).rows[0];
+		const item = await new ContentRepository(db).findByIdIncludingTrashed(collection, id);
+		if (!raw || !item) throw new ContentStorageError("CONFLICT", "The source content changed during directory indexing.");
+		const dependencies = await snapshotPartitionDependencies(db, collection, item, storage.runtime.config.rules[collection]);
+		const destination = await resolveContentPartition(storage.runtime.config, {
+			collection,
+			id,
+			data: rowSchema.parse(item.data),
+			dependencies: dependencies.dependencies
+		}, storage.runtime.resolvers);
+		if (!destination) throw new ContentStorageError("INVALID_PARTITION", "The content has no partition.");
+		const partition = await readContentPartitionRoute(db, collection, destination.partition);
+		if (partition.route.store !== "primary" || partition.route.state === "frozen") throw new ContentStorageError("CONFLICT", "Legacy content can only be indexed while its primary partition remains writable.");
+		const digest = await contentDigest(item.data);
+		await atomicBatch(db, {
+			checks: [
+				rowUnchanged(`ec_${collection}`, raw),
+				partition.check,
+				...dependencies.checks,
+				sql`NOT EXISTS (SELECT 1 FROM _dineway_content_locations WHERE collection=${collection} AND entry_id=${id})`
+			],
+			statements: [sql`INSERT INTO _dineway_content_locations (collection, entry_id, store, partition, routing_version, version, digest) VALUES (${collection}, ${id}, 'primary', ${destination.partition}, ${storage.runtime.config.version}, ${`primary-${await contentDigest(raw)}`}, ${digest})`.compile(db)]
+		});
+	}
+	return {
+		indexed: ids.length,
+		nextCursor: ids.length === limit ? ids.at(-1)?.id : void 0
+	};
+}
+
+//#endregion
+//#region src/content-storage/migration.ts
+async function migrationState(db, migration) {
+	const row = (await sql`SELECT state, manifest_digest, verified_count FROM _dineway_content_migrations WHERE id=${migration.id} AND collection=${migration.collection} AND partition=${migration.partition}`.execute(db)).rows[0];
+	if (!row) throw new ContentStorageError("CONFLICT", "The migration record is missing.");
+	return row;
+}
+async function migrationManifest(db, migration) {
+	const rows = (await sql`SELECT * FROM _dineway_content_migration_entries WHERE migration_id=${migration.id} AND state<>'skipped' ORDER BY entry_id`.execute(db)).rows;
+	return {
+		rows,
+		digest: await contentDigest(rows.map((row) => ({
+			entryId: row.entry_id,
+			sourceDigest: row.source_digest,
+			archive: row.archive_key,
+			location: row.target_location
+		})))
+	};
+}
+async function entryCheckpoint(db, migration, entryId) {
+	return (await sql`SELECT * FROM _dineway_content_migration_entries WHERE migration_id=${migration.id} AND entry_id=${entryId}`.execute(db)).rows[0];
+}
+async function targetVersions(snapshot, migration, store, routingVersion) {
+	const sourceDigest = await contentDigest(snapshot);
+	const base = {
+		collection: snapshot.collection,
+		entryId: snapshot.entryId,
+		store,
+		partition: migration.partition,
+		routingVersion,
+		principalId: "content-migration",
+		expectedVersion: null
+	};
+	const revisions = [];
+	for (const revision of snapshot.revisions) {
+		const version = await contentDigest({
+			migration: migration.id,
+			sourceDigest,
+			revision: revision.row.id
+		});
+		revisions.push({
+			id: revision.row.id,
+			value: {
+				command: {
+					...base,
+					kind: "revision",
+					version,
+					operationId: version,
+					digest: await contentDigest(revision.data)
+				},
+				data: revision.data
+			}
+		});
+	}
+	const { data: fields, ...metadata } = snapshot.item;
+	const data = contentVersionSchema.shape.data.parse({
+		...fields,
+		_dineway: {
+			...metadata,
+			deletedAt: snapshot.row.deleted_at ?? null,
+			partitionDependencies: snapshot.partitionDependencies,
+			owned: snapshot.owned,
+			revisions: revisions.map((revision) => ({
+				id: revision.id,
+				version: revision.value.command.version,
+				digest: revision.value.command.digest
+			}))
+		}
+	});
+	const version = await contentDigest({
+		migration: migration.id,
+		entryId: snapshot.entryId,
+		sourceDigest
+	});
+	return {
+		sourceDigest,
+		revisions,
+		root: {
+			command: {
+				...base,
+				version,
+				operationId: version,
+				digest: await contentDigest(data)
+			},
+			data
+		}
+	};
+}
+/** Idempotent pre-copy. Full source data must be durably archived and read back first. */
+async function stageContentMigrationEntry(db, migration, entryId, archive) {
+	return stageMigrationEntry(db, migration, entryId, archive);
+}
+async function stageMigrationEntry(db, migration, entryId, archive, verificationEpoch) {
+	const storage = getContentStorage(db, migration.collection);
+	if (!storage) throw new ContentStorageError("INVALID_CONFIG", "Content storage is not configured.");
+	const partition = await readContentPartitionRoute(db, migration.collection, migration.partition);
+	if (partition.route.migration_id !== migration.id || partition.route.state === "active") throw new ContentStorageError("CONFLICT", "The migration does not own this partition.");
+	const phase = await migrationState(db, migration);
+	if (verificationEpoch === void 0 ? !["copying", "frozen"].includes(phase.state) : phase.state !== "verifying" || partition.route.epoch !== verificationEpoch) throw new ContentStorageError("CONFLICT", "The verified manifest is immutable or another verifier superseded this attempt.");
+	const existing = await entryCheckpoint(db, migration, entryId);
+	if (existing?.state === "activated") return existing;
+	if (existing?.state === "prepared") {
+		const archived = contentMigrationSnapshotSchema.parse(await archive.get(existing.archive_key));
+		if (await contentDigest(archived) !== existing.source_digest) throw new ContentStorageError("UNAVAILABLE", "The source archive failed its read-back checksum.");
+		const sequence = (await sql`SELECT ${contentChangeSequence(migration.collection, entryId)} AS value`.execute(db)).rows[0].value;
+		const schema = await contentWriteConfiguration(db, migration.collection);
+		const dependencies = await snapshotPartitionDependencies(db, migration.collection, archived.item, storage.runtime.config.rules[migration.collection]);
+		if (sequence === archived.changeSequence && await contentDigest(dependencies.dependencies) === await contentDigest(archived.partitionDependencies) && await contentDigest({
+			collection: schema.row,
+			fields: schema.fields
+		}) === archived.schemaDigest) {
+			await atomicBatch(db, {
+				checks: [
+					partition.check,
+					rowUnchanged("_dineway_content_migration_entries", { ...existing }),
+					...schema.checks,
+					...dependencies.checks,
+					...contentMigrationSnapshotChecks(archived)
+				],
+				statements: []
+			});
+			return existing;
+		}
+	}
+	const snapshot = await captureContentMigrationSnapshot(db, migration.collection, entryId);
+	if (snapshot.location?.partition !== migration.partition || snapshot.location.store !== partition.route.store) throw new ContentStorageError("CONFLICT", "The entry is not in the migration's source partition.");
+	const versions = await targetVersions(snapshot, migration, partition.route.target_store, storage.runtime.config.version);
+	const archiveKey = `${migration.id}/${entryId}/${versions.sourceDigest}.json`;
+	await archive.put(archiveKey, snapshot);
+	if (await contentDigest(contentMigrationSnapshotSchema.parse(await archive.get(archiveKey))) !== versions.sourceDigest) throw new ContentStorageError("UNAVAILABLE", "The source archive failed its read-back checksum.");
+	if (partition.route.target_store !== "primary") {
+		const store = storage.stores[partition.route.target_store];
+		for (const revision of versions.revisions) await store.prepare(revision.value);
+		await store.prepare(versions.root);
+		await storage.coordinator.readLocations([...versions.revisions.map((revision) => revision.value.command), versions.root.command]);
+	}
+	const dependencies = await snapshotPartitionDependencies(db, migration.collection, snapshot.item, storage.runtime.config.rules[migration.collection]);
+	if (await contentDigest(dependencies.dependencies) !== await contentDigest(snapshot.partitionDependencies)) throw new ContentStorageError("CONFLICT", "Partition dependencies changed while copying content.");
+	await atomicBatch(db, {
+		checks: [
+			partition.check,
+			sql`EXISTS (SELECT 1 FROM _dineway_content_migrations WHERE id=${migration.id} AND state=${phase.state})`,
+			...dependencies.checks,
+			...contentMigrationSnapshotChecks(snapshot),
+			sql`NOT EXISTS (SELECT 1 FROM _dineway_content_migration_entries WHERE migration_id=${migration.id} AND entry_id=${entryId} AND state='activated')`
+		],
+		statements: [sql`INSERT INTO _dineway_content_migration_entries (migration_id, entry_id, source_digest, archive_key, target_location, state, updated_at) VALUES (${migration.id}, ${entryId}, ${versions.sourceDigest}, ${archiveKey}, ${JSON.stringify(versions.root.command)}, 'prepared', ${(/* @__PURE__ */ new Date()).toISOString()}) ON CONFLICT (migration_id, entry_id) DO UPDATE SET source_digest=excluded.source_digest, archive_key=excluded.archive_key, target_location=excluded.target_location, state='prepared', updated_at=excluded.updated_at`.compile(db)]
+	});
+	return await entryCheckpoint(db, migration, entryId);
+}
+/** Activate one verified entry while the city remains frozen; retries use its persisted receipt. */
+async function activateContentMigrationEntry(db, migration, entryId, archive) {
+	const storage = getContentStorage(db, migration.collection);
+	if (!storage) throw new ContentStorageError("INVALID_CONFIG", "Content storage is not configured.");
+	const partition = await readContentPartitionRoute(db, migration.collection, migration.partition);
+	if (partition.route.migration_id !== migration.id || partition.route.state !== "frozen") throw new ContentStorageError("CONFLICT", "Freeze the partition before activating imported content.");
+	const phase = await migrationState(db, migration);
+	if (!["verified", "activating"].includes(phase.state)) throw new ContentStorageError("CONFLICT", "Verify the complete frozen manifest before activating entries.");
+	const checkpoint = await entryCheckpoint(db, migration, entryId);
+	if (!checkpoint) throw new ContentStorageError("CONFLICT", "The entry has not been copied and verified.");
+	if (checkpoint.state === "activated") return;
+	const snapshot = contentMigrationSnapshotSchema.parse(await archive.get(checkpoint.archive_key));
+	if (snapshot.collection !== migration.collection || snapshot.entryId !== entryId || await contentDigest(snapshot) !== checkpoint.source_digest) throw new ContentStorageError("CONFLICT", "The migration archive does not match its checkpoint.");
+	const saved = contentVersionSchema.shape.command.parse(JSON.parse(checkpoint.target_location));
+	const versions = await targetVersions(snapshot, migration, partition.route.target_store, storage.runtime.config.version);
+	if (JSON.stringify(versions.root.command) !== checkpoint.target_location) throw new ContentStorageError("CONFLICT", "The target content identity changed.");
+	if (saved.store !== "primary") await storage.coordinator.readLocations([...versions.revisions.map((revision) => revision.value.command), versions.root.command], []);
+	const dependencies = await snapshotPartitionDependencies(db, migration.collection, snapshot.item, storage.runtime.config.rules[migration.collection]);
+	if (await contentDigest(dependencies.dependencies) !== await contentDigest(snapshot.partitionDependencies)) throw new ContentStorageError("CONFLICT", "Partition dependencies changed after copying.");
+	const destination = await resolveContentPartition(storage.runtime.config, {
+		collection: migration.collection,
+		id: entryId,
+		data: snapshot.item.data,
+		dependencies: dependencies.dependencies
+	}, storage.runtime.resolvers);
+	if (destination?.partition !== migration.partition || destination.store !== saved.store) throw new ContentStorageError("ROUTE_CHANGED", "The copied content belongs to another partition.");
+	const schema = await contentWriteConfiguration(db, migration.collection);
+	if (await contentDigest({
+		collection: schema.row,
+		fields: schema.fields
+	}) !== snapshot.schemaDigest) throw new ContentStorageError("CONFLICT", "The content schema changed after the migration snapshot.");
+	await atomicBatch(db, {
+		checks: [
+			partition.check,
+			sql`EXISTS (SELECT 1 FROM _dineway_content_migrations WHERE id=${migration.id} AND state IN ('verified','activating') AND manifest_digest=${phase.manifest_digest})`,
+			rowUnchanged("_dineway_content_migration_entries", { ...checkpoint }),
+			...schema.checks,
+			...dependencies.checks,
+			...contentMigrationSnapshotChecks(snapshot)
+		],
+		statements: [
+			prepareContentProjection(db, migration.collection, snapshot.item, schema.fields, false, saved.store === "primary"),
+			...versions.revisions.map((revision) => db.updateTable("revisions").set({ data: saved.store === "primary" ? JSON.stringify(revision.value.data) : storedRevisionIndex(revision.value.command) }).where("id", "=", revision.id).compile()),
+			sql`UPDATE _dineway_content_locations SET store=${saved.store}, partition=${saved.partition}, routing_version=${saved.routingVersion}, version=${saved.version}, digest=${saved.digest} WHERE collection=${migration.collection} AND entry_id=${entryId}`.compile(db),
+			sql`UPDATE _dineway_content_migration_entries SET state='activated', updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE migration_id=${migration.id} AND entry_id=${entryId}`.compile(db),
+			sql`UPDATE _dineway_content_migrations SET state='activating', updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE id=${migration.id}`.compile(db)
+		]
+	});
+	invalidateCollectionCache(migration.collection);
+}
+/** Refresh the frozen delta, verify all current IDs, and seal the activation manifest. */
+async function verifyContentMigration(db, migration, archive) {
+	const partition = await readContentPartitionRoute(db, migration.collection, migration.partition);
+	if (partition.route.migration_id !== migration.id || partition.route.state !== "frozen") throw new ContentStorageError("CONFLICT", "The final verification requires a frozen partition.");
+	const phase = await migrationState(db, migration);
+	if (["verified", "activating"].includes(phase.state)) return {
+		count: phase.verified_count,
+		digest: phase.manifest_digest
+	};
+	if (!["frozen", "verifying"].includes(phase.state)) throw new ContentStorageError("CONFLICT", "The migration cannot be verified in its current state.");
+	await atomicBatch(db, {
+		checks: [partition.check, sql`EXISTS (SELECT 1 FROM _dineway_content_migrations WHERE id=${migration.id} AND state=${phase.state})`],
+		statements: [sql`UPDATE _dineway_content_partitions SET epoch=epoch+1, updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE collection=${migration.collection} AND partition=${migration.partition}`.compile(db), sql`UPDATE _dineway_content_migrations SET state='verifying', updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE id=${migration.id}`.compile(db)]
+	});
+	const verification = await readContentPartitionRoute(db, migration.collection, migration.partition);
+	let cursor = "";
+	for (;;) {
+		const ids = (await sql`SELECT c.id FROM ${sql.table(`ec_${migration.collection}`)} c JOIN _dineway_content_locations l ON l.collection=${migration.collection} AND l.entry_id=c.id WHERE l.partition=${migration.partition} AND c.id>${cursor} ORDER BY c.id LIMIT 20`.execute(db)).rows;
+		for (const { id } of ids) await stageMigrationEntry(db, migration, id, archive, verification.route.epoch);
+		if (ids.length < 20) break;
+		cursor = ids.at(-1).id;
+	}
+	await atomicBatch(db, {
+		checks: [verification.check],
+		statements: [sql`UPDATE _dineway_content_migration_entries SET state='skipped' WHERE migration_id=${migration.id} AND state='prepared' AND NOT EXISTS (SELECT 1 FROM ${sql.table(`ec_${migration.collection}`)} c JOIN _dineway_content_locations l ON l.collection=${migration.collection} AND l.entry_id=c.id WHERE c.id=_dineway_content_migration_entries.entry_id AND l.partition=${migration.partition})`.compile(db), sql`DELETE FROM _dineway_content_locations WHERE collection=${migration.collection} AND partition=${migration.partition} AND NOT EXISTS (SELECT 1 FROM ${sql.table(`ec_${migration.collection}`)} c WHERE c.id=_dineway_content_locations.entry_id)`.compile(db)]
+	});
+	const manifest = await migrationManifest(db, migration);
+	await atomicBatch(db, {
+		checks: [
+			verification.check,
+			sql`EXISTS (SELECT 1 FROM _dineway_content_migrations WHERE id=${migration.id} AND state='verifying')`,
+			sql`(SELECT COUNT(*) FROM _dineway_content_locations WHERE collection=${migration.collection} AND partition=${migration.partition})=${manifest.rows.length}`,
+			sql`NOT EXISTS (SELECT 1 FROM _dineway_content_locations l WHERE l.collection=${migration.collection} AND l.partition=${migration.partition} AND NOT EXISTS (SELECT 1 FROM _dineway_content_migration_entries m WHERE m.migration_id=${migration.id} AND m.entry_id=l.entry_id AND m.state='prepared'))`
+		],
+		statements: [sql`UPDATE _dineway_content_migrations SET state='verified', manifest_digest=${manifest.digest}, verified_count=${manifest.rows.length}, updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE id=${migration.id} AND state='verifying'`.compile(db)]
+	});
+	return {
+		count: manifest.rows.length,
+		digest: manifest.digest
+	};
+}
+/** Reopen writes only after every sealed entry has activated; old archives remain retained. */
+async function completeContentMigration(db, migration) {
+	const phase = await migrationState(db, migration);
+	if (phase.state === "complete") return;
+	const partition = await readContentPartitionRoute(db, migration.collection, migration.partition);
+	if (partition.route.state !== "frozen" || partition.route.migration_id !== migration.id || !["verified", "activating"].includes(phase.state)) throw new ContentStorageError("CONFLICT", "The migration is not ready to reopen writes.");
+	const manifest = await migrationManifest(db, migration);
+	if (manifest.digest !== phase.manifest_digest || manifest.rows.length !== phase.verified_count || manifest.rows.some((row) => row.state !== "activated")) throw new ContentStorageError("CONFLICT", "The sealed manifest has not completely activated.");
+	await atomicBatch(db, {
+		checks: [
+			partition.check,
+			sql`EXISTS (SELECT 1 FROM _dineway_content_migrations WHERE id=${migration.id} AND manifest_digest=${manifest.digest} AND state IN ('verified','activating'))`,
+			sql`NOT EXISTS (SELECT 1 FROM _dineway_content_migration_entries WHERE migration_id=${migration.id} AND state NOT IN ('activated','skipped'))`,
+			sql`NOT EXISTS (SELECT 1 FROM _dineway_content_locations WHERE collection=${migration.collection} AND partition=${migration.partition} AND store<>${partition.route.target_store})`
+		],
+		statements: [sql`UPDATE _dineway_content_partitions SET store=target_store, state='active', migration_id=NULL, epoch=epoch+1, updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE collection=${migration.collection} AND partition=${migration.partition}`.compile(db), sql`UPDATE _dineway_content_migrations SET state='complete', retain_until=${new Date(Date.now() + 7 * 864e5).toISOString()}, updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE id=${migration.id}`.compile(db)]
+	});
+	invalidateCollectionCache(migration.collection);
+}
+/** Restore the archived source only before writes have reopened. Never deletes either copy. */
+async function rollbackContentMigration(db, migration, archive) {
+	const phase = await migrationState(db, migration);
+	if (phase.state === "cancelled") return;
+	if (phase.state === "complete") throw new ContentStorageError("CONFLICT", "Writes have reopened. Returning to the old store requires a reverse data migration.");
+	const current = await readContentPartitionRoute(db, migration.collection, migration.partition);
+	if (current.route.migration_id !== migration.id || current.route.state !== "frozen") throw new ContentStorageError("CONFLICT", "Freeze the partition before restoring its archive.");
+	if (phase.state !== "rolling_back") await atomicBatch(db, {
+		checks: [current.check, sql`EXISTS (SELECT 1 FROM _dineway_content_migrations WHERE id=${migration.id} AND state=${phase.state})`],
+		statements: [sql`UPDATE _dineway_content_partitions SET epoch=epoch+1, updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE collection=${migration.collection} AND partition=${migration.partition}`.compile(db), sql`UPDATE _dineway_content_migrations SET state='rolling_back', updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE id=${migration.id}`.compile(db)]
+	});
+	const partition = await readContentPartitionRoute(db, migration.collection, migration.partition);
+	const schema = await contentWriteConfiguration(db, migration.collection);
+	for (;;) {
+		const entries = (await sql`SELECT * FROM _dineway_content_migration_entries WHERE migration_id=${migration.id} AND state='activated' ORDER BY entry_id LIMIT 20`.execute(db)).rows;
+		if (!entries.length) break;
+		for (const checkpoint of entries) {
+			const snapshot = contentMigrationSnapshotSchema.parse(await archive.get(checkpoint.archive_key));
+			if (snapshot.collection !== migration.collection || snapshot.entryId !== checkpoint.entry_id || await contentDigest(snapshot) !== checkpoint.source_digest) throw new ContentStorageError("CONFLICT", "The migration archive does not match its checkpoint.");
+			if (!snapshot.location || snapshot.location.store !== partition.route.store || await contentDigest({
+				collection: schema.row,
+				fields: schema.fields
+			}) !== snapshot.schemaDigest) throw new ContentStorageError("CONFLICT", "The source location or schema changed. The archive cannot be restored.");
+			const target = contentVersionSchema.shape.command.parse(JSON.parse(checkpoint.target_location));
+			const versions = await targetVersions(snapshot, migration, partition.route.target_store, target.routingVersion);
+			if (JSON.stringify(versions.root.command) !== checkpoint.target_location) throw new ContentStorageError("CONFLICT", "The target content identity changed.");
+			const expected = contentMigrationSnapshotSchema.parse({
+				...snapshot,
+				row: {
+					...snapshot.row,
+					...contentProjectionValues(snapshot.item, schema.fields, target.store === "primary")
+				},
+				location: {
+					...snapshot.location,
+					store: target.store,
+					partition: target.partition,
+					routing_version: target.routingVersion,
+					version: target.version,
+					digest: target.digest
+				},
+				revisions: snapshot.revisions.map((revision, index) => ({
+					...revision,
+					row: {
+						...revision.row,
+						data: target.store === "primary" ? JSON.stringify(revision.data) : storedRevisionIndex(versions.revisions[index].value.command)
+					}
+				}))
+			});
+			await atomicBatch(db, {
+				checks: [
+					partition.check,
+					rowUnchanged("_dineway_content_migration_entries", { ...checkpoint }),
+					...schema.checks,
+					...contentMigrationSnapshotChecks(expected, { journal: false })
+				],
+				statements: [
+					sql`UPDATE ${sql.table(`ec_${migration.collection}`)} SET ${sql.join(Object.entries(snapshot.row).filter(([key]) => key !== "id").map(([key, value]) => sql`${sql.ref(key)}=${value}`))} WHERE id=${checkpoint.entry_id}`.compile(db),
+					...snapshot.revisions.map((revision) => db.updateTable("revisions").set({ data: revision.row.data }).where("id", "=", revision.row.id).compile()),
+					sql`UPDATE _dineway_content_locations SET ${sql.join(Object.entries(snapshot.location).filter(([key]) => !["collection", "entry_id"].includes(key)).map(([key, value]) => sql`${sql.ref(key)}=${value}`))} WHERE collection=${migration.collection} AND entry_id=${checkpoint.entry_id}`.compile(db),
+					sql`UPDATE _dineway_content_migration_entries SET state='restored', updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE migration_id=${migration.id} AND entry_id=${checkpoint.entry_id}`.compile(db)
+				]
+			});
+		}
+	}
+	await cancelContentMigration(db, migration);
+	invalidateCollectionCache(migration.collection);
+}
+
+//#endregion
+export { verifyContentMigration as a, contentMigrationSnapshotSchema as c, stageContentMigrationEntry as i, migrateContentStorageConfig as l, completeContentMigration as n, bootstrapContentDirectoryPage as o, rollbackContentMigration as r, captureContentMigrationSnapshot as s, activateContentMigrationEntry as t };

package/dist/{migrations-CLlX25HO.mjs → migrations-BAjF60cl.mjs}

@@ -1,4 +1,4 @@
-import { o as assertD1Migrations } from "./runner-CRU7BXjr.mjs";
+import { o as assertD1Migrations } from "./runner-CuG8o1uW.mjs";
 import { t as d1Database } from "./d1-binding-DrLMBUxu.mjs";
 import { Migrator } from "kysely";