dineway 0.2.40 → 0.2.41

package/dist/cli/index.mjs

@@ -1,55 +1,68 @@
 #!/usr/bin/env node
-import { a as runMigrations, n as getMigrationFingerprint, r as getMigrationStatus } from "../runner-CRU7BXjr.mjs";
+import { a as runMigrations, n as getMigrationFingerprint, r as getMigrationStatus } from "../runner-CuG8o1uW.mjs";
 import { t as createDatabase } from "../connection-DJ3GzHVH.mjs";
-import "../d1-binding-DrLMBUxu.mjs";
+import { t as d1Database } from "../d1-binding-DrLMBUxu.mjs";
 import { AtomicWriteConflict, atomicBatch, rowUnchanged } from "../database/batch.mjs";
 import { t as validateIdentifier } from "../validate-Co3j6T_K.mjs";
 import { l as listTablesLike } from "../dialect-helpers-C6xtO-Ui.mjs";
 import { n as getI18nConfig, r as isI18nEnabled } from "../config-XW5tMrH8.mjs";
-import { i as encodeBase64url } from "../base64-Cz-aU0X1.mjs";
-import "../types-RFzE_V1M.mjs";
-import { o as isMissingTableError } from "../loader-Dp6zLmQm.mjs";
-import "../actor-DxUAJgQX.mjs";
-import "../atomic-authority-CnBQJ14T.mjs";
-import "../object-cache-mxCW-Rpt.mjs";
-import { n as slugify } from "../slugify-kD31VIv2.mjs";
-import "../revision-W6FDfDqx.mjs";
-import { t as ContentRepository } from "../content-CIKsrvU9.mjs";
-import { t as MediaRepository } from "../media-C5ba8fvI.mjs";
-import { t as TaxonomyRepository } from "../taxonomy-DN6i1upz.mjs";
-import { t as OptionsRepository } from "../options-JiLWB6Bt.mjs";
-import "../redirect-BQFa1THe.mjs";
-import "../request-cache-8_ifFzVw.mjs";
-import "../byline-registry-CJihchD1.mjs";
-import "../field-defs-cache-aXUeXJdC.mjs";
-import { t as BylineRepository } from "../byline-TYk2kad6.mjs";
-import { n as DinewayToolsService, r as integrationResponse, t as DinewayToolsError } from "../service-kQ5ljRzX.mjs";
-import "../runtime-env-CPTzh0mZ.mjs";
-import { i as parseEncryptionKeys, n as fingerprintKey, r as generateEncryptionKey, t as DinewaySecretsError } from "../secrets-D_pergcD.mjs";
-import "../content-refresh-BilzqcLt.mjs";
-import { n as resolveAndValidateExternalUrl, t as SsrfError } from "../ssrf-C9dyjU8O.mjs";
-import "../fts-manager-BrPpYtK0.mjs";
-import "../public-discovery-BGyhuD5U.mjs";
-import { n as SchemaRegistry } from "../registry-Dclv9iHv.mjs";
-import "../settings-DsBzKeUQ.mjs";
-import { n as VERSION } from "../version-CISd4wX_.mjs";
-import { t as IntegrationCredentialStore } from "../store-32e6dfD-.mjs";
-import { a as reconcileManifestAccess, i as pluginManifestSchema } from "../manifest-schema-CCvogfrP.mjs";
-import "../migrations-CLlX25HO.mjs";
-import { t as validateSeed } from "../validate-C05z0m7M.mjs";
-import { t as applySeed } from "../apply-D4rZHDyg.mjs";
-import { n as validateWorkersBindings, t as WORKERS_BUILD_METADATA } from "../workers-build-BkmPhclj.mjs";
-import { n as d1ReleaseRevision } from "../state-jx6Yiwsm.mjs";
-import { a as createForgewayAccountClient, c as normalizeForgewayApiUrl, d as refreshForgewayAccountCredentials, f as removeStoredForgewayAccount, g as writeForgewayCredentials, h as readForgewayCredentials, i as completeForgewayAccountLogin, l as normalizeForgewayEmail, m as listForgewayCredentials, n as DEFAULT_FORGEWAY_API_BASE_URL, o as getForgewayDinewayAccount, p as sendForgewayAccountLoginLink, r as InvalidForgewayAccountCredentialsError, s as normalizeDinewayWebUrl, t as DEFAULT_DINEWAY_WEB_URL, u as readStoredForgewayAccount } from "../forgeway-account-DcTxh3Gw.mjs";
-import { n as output, t as configureOutputMode } from "../output-7HDrYTSQ.mjs";
+import { a as validateContentStorage, n as contentDigest, r as contentStorageConfigSchema, t as canonicalContentJson } from "../config-6R0bchVE.mjs";
+import { c as installContentStorageConfig, f as freezeContentPartition, l as beginContentMigration, o as registerContentStorage, r as getContentStorage, t as assertContentStorageConfiguration, u as cancelContentMigration } from "../runtime-Ch5G-tnG.mjs";
+import "../revisions-CQ7rMP5d.mjs";
+import "../runtime-env-DpYGy4pT.mjs";
+import { i as encodeBase64url } from "../base64-qvSs0Gxy.mjs";
+import "../types-BI3ULB3A.mjs";
+import { o as isMissingTableError } from "../loader-CCwWFQSh.mjs";
+import "../actor-D0AW80ld.mjs";
+import "../atomic-authority-Bf5QZboB.mjs";
+import { t as ContentRepository } from "../content-BigS8BAv.mjs";
+import "../request-cache-CizvDoxV.mjs";
+import "../byline-registry-Caj0_gbU.mjs";
+import "../field-defs-cache-dn5Tw79A.mjs";
+import "../object-cache-DyI1SOBK.mjs";
+import { t as BylineRepository } from "../byline-3qjp1-oa.mjs";
+import "../owned-metadata-BPmUjZqI.mjs";
+import { n as slugify } from "../slugify-DvoaEPtL.mjs";
+import "../revision-B_HYO2AE.mjs";
+import { t as MediaRepository } from "../media-BjH5OD-A.mjs";
+import "../user-Bl2_8rhJ.mjs";
+import "../terms-EskuqbKE.mjs";
+import { t as TaxonomyRepository } from "../taxonomy-BK7JmHlo.mjs";
+import { t as OptionsRepository } from "../options-yFkLUuTw.mjs";
+import "../redirect-CJ-FAbNK.mjs";
+import "../content-write-DAZCNKWl.mjs";
+import "../text-extraction-CdqMGYQK.mjs";
+import { n as assertContentVersionStore, o as installContentVersionStore, r as contentStoreCollectionSchema, t as ContentVersionStore } from "../version-store-BXv2D0de.mjs";
+import "../write-intent-DuHVqks9.mjs";
+import "../seo-Cv7ud_m2.mjs";
+import { n as DinewayToolsService, r as integrationResponse, t as DinewayToolsError } from "../service-DeX1PRNt.mjs";
+import { i as parseEncryptionKeys, n as fingerprintKey, r as generateEncryptionKey, t as DinewaySecretsError } from "../secrets-CIYcw9T9.mjs";
+import "../content-refresh-DJuFIqQ4.mjs";
+import { n as resolveAndValidateExternalUrl, t as SsrfError } from "../ssrf-DcD8vn3E.mjs";
+import "../fts-manager-Zu5ITic0.mjs";
+import "../public-discovery-BnqYofSK.mjs";
+import { n as SchemaRegistry } from "../registry-zXXZezu-.mjs";
+import "../settings-BUONaNnG.mjs";
+import { n as VERSION } from "../version-BlE1LEPb.mjs";
+import { t as IntegrationCredentialStore } from "../store-BzaAtszy.mjs";
+import { a as reconcileManifestAccess, i as pluginManifestSchema } from "../manifest-schema-DaQpgyTB.mjs";
+import "../content-Dr22fzA_.mjs";
+import "../migrations-BAjF60cl.mjs";
+import { t as validateSeed } from "../validate-C-yk7mmX.mjs";
+import { t as applySeed } from "../apply-B5qoX19G.mjs";
+import { n as validateWorkersBindings, t as WORKERS_BUILD_METADATA } from "../workers-build-4926MPc0.mjs";
+import { n as d1ReleaseRevision } from "../state-CKkqoA6i.mjs";
+import { a as createForgewayAccountClient, c as normalizeForgewayApiUrl, d as refreshForgewayAccountCredentials, f as removeStoredForgewayAccount, g as writeForgewayCredentials, h as readForgewayCredentials, i as completeForgewayAccountLogin, l as normalizeForgewayEmail, m as listForgewayCredentials, n as DEFAULT_FORGEWAY_API_BASE_URL, o as getForgewayDinewayAccount, p as sendForgewayAccountLoginLink, r as InvalidForgewayAccountCredentialsError, s as normalizeDinewayWebUrl, t as DEFAULT_DINEWAY_WEB_URL, u as readStoredForgewayAccount } from "../forgeway-account-YzraapbX.mjs";
+import { n as output, t as configureOutputMode } from "../output-ljHaxIHX.mjs";
 import { createHeaderAwareFetch, isRedirectResponse, resolveCustomHeaders } from "../client/external-auth-headers.mjs";
-import { t as convertDataForRead } from "../portable-text-tQhvPLf1.mjs";
-import { _ as saveMarketplaceCredential, a as ensureProjectGitignoreDinewayLocalState, c as resolveDinewayBaseUrl, d as getCredentials, f as getMarketplaceCredential, g as saveCredentials, h as resolveCredentialKey, i as DEFAULT_DINEWAY_URL, l as resolveDinewayToken, m as removeMarketplaceCredential, n as connectionArgs, o as ensureProjectGitignoreEntry, p as removeCredentials, r as createClientFromArgs, s as readProjectEnv, u as upsertProjectEnv } from "../client-factory-C1ZQCMog.mjs";
-import { t as migrateD1Release } from "../release-Da2UFygt.mjs";
+import { t as convertDataForRead } from "../portable-text-CSbRjM-T.mjs";
+import { _ as saveMarketplaceCredential, a as ensureProjectGitignoreDinewayLocalState, c as resolveDinewayBaseUrl, d as getCredentials, f as getMarketplaceCredential, g as saveCredentials, h as resolveCredentialKey, i as DEFAULT_DINEWAY_URL, l as resolveDinewayToken, m as removeMarketplaceCredential, n as connectionArgs, o as ensureProjectGitignoreEntry, p as removeCredentials, r as createClientFromArgs, s as readProjectEnv, u as upsertProjectEnv } from "../client-factory-BLbm250o.mjs";
+import { t as migrateD1Release } from "../release-Cpi0-Bzq.mjs";
+import { a as verifyContentMigration, c as contentMigrationSnapshotSchema, i as stageContentMigrationEntry, l as migrateContentStorageConfig, n as completeContentMigration, o as bootstrapContentDirectoryPage, r as rollbackContentMigration, t as activateContentMigrationEntry } from "../migration-DJuj7ZwN.mjs";
 import { LocalStorage } from "../storage/local.mjs";
-import { r as fileExists$11, t as bundleCommand } from "../bundle-bhiszAui.mjs";
+import { r as fileExists$11, t as bundleCommand } from "../bundle-DWn5eFKz.mjs";
 import { createRequire } from "node:module";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { CompiledQuery, Kysely, sql } from "kysely";
 import { z } from "zod";
 import { createGzipDecoder, unpackTar } from "modern-tar";
@@ -57,7 +70,7 @@ import { createReadStream, existsSync, readFileSync, writeFileSync } from "node:
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import sax from "sax";
 import { pathToFileURL } from "node:url";
-import { access, mkdir, mkdtemp, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
+import { access, link, mkdir, mkdtemp, open, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
 import { defineCommand, runCommand, runMain } from "citty";
 import { createInterface } from "node:readline/promises";
 import consola, { consola as consola$1 } from "consola";
@@ -883,6 +896,7 @@ const integrationSchema = z.object({
 			entrypoint: z.string(),
 			config: z.unknown()
 		}).optional(),
+		contentStorage: contentStorageConfigSchema.optional(),
 		plugins: z.array(pluginDescriptor).default([])
 	}) })
 });
@@ -994,6 +1008,386 @@ async function loadD1Dialect(cwd) {
 	return module.createD1Dialect;
 }
 
+//#endregion
+//#region src/content-storage/capacity.ts
+const CONTENT_CAPACITY_THRESHOLDS = {
+	warning: 6e9,
+	prepare: 7e9,
+	relocate: 8e9
+};
+async function readContentDatabaseCapacity(db) {
+	const binding = d1Database(db);
+	if (!binding) throw new Error("Physical content capacity requires a D1 database binding.");
+	const result = await binding.prepare("SELECT 1 AS content_capacity_probe").all();
+	const metadata = z.object({
+		size_after: z.number().finite().positive().optional(),
+		served_by_region: z.string().optional()
+	}).passthrough().safeParse(result.meta);
+	const bytes = metadata.success ? metadata.data.size_after ?? null : null;
+	return {
+		bytes,
+		source: "D1 result meta.size_after",
+		region: metadata.success ? metadata.data.served_by_region ?? null : null,
+		status: bytes === null ? "unknown" : bytes >= CONTENT_CAPACITY_THRESHOLDS.relocate ? "relocate" : bytes >= CONTENT_CAPACITY_THRESHOLDS.prepare ? "prepare" : bytes >= CONTENT_CAPACITY_THRESHOLDS.warning ? "warning" : "healthy",
+		thresholdBytes: CONTENT_CAPACITY_THRESHOLDS,
+		measuredAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+
+//#endregion
+//#region src/cli/content-archive.ts
+/** Private, immutable archives survive a process crash before or after the atomic file link. */
+function createFileContentArchive(directory) {
+	const root = resolve(directory);
+	const filename = async (key) => join(root, `${await contentDigest(key)}.json`);
+	return {
+		async put(key, snapshot) {
+			await mkdir(root, {
+				recursive: true,
+				mode: 448
+			});
+			const data = canonicalContentJson(contentMigrationSnapshotSchema.parse(snapshot));
+			const target = await filename(key);
+			const temporary = join(root, `.pending-${randomUUID()}`);
+			try {
+				const file = await open(temporary, "wx", 384);
+				try {
+					await file.writeFile(data);
+					await file.sync();
+				} finally {
+					await file.close();
+				}
+				try {
+					await link(temporary, target);
+				} catch (error) {
+					if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+					if (await readFile(target, "utf8") !== data) throw new Error("An immutable archive already exists with different or incomplete data.", { cause: error });
+				}
+				const folder = await open(root, "r");
+				try {
+					await folder.sync();
+				} finally {
+					await folder.close();
+				}
+			} finally {
+				await rm(temporary, { force: true });
+			}
+		},
+		async get(key) {
+			return contentMigrationSnapshotSchema.parse(JSON.parse(await readFile(await filename(key), "utf8")));
+		}
+	};
+}
+
+//#endregion
+//#region src/cli/content-storage-project.ts
+async function readContentStorageProject(options) {
+	if (options.local === options.remote) throw new Error("Choose exactly one target: --local or --remote.");
+	const cwd = resolve(options.cwd);
+	const project = await readProjectDinewayConfig(cwd);
+	if (project?.database?.entrypoint !== "@dineway-ai/cloudflare/db/d1" || !project.contentStorage) throw new Error("Configure D1 and contentStorage before running content storage maintenance.");
+	const config = project.contentStorage;
+	validateContentStorage(config);
+	const main = await loadProjectWrangler(cwd, options.config, options.environment);
+	const mainBinding = z.object({ binding: z.string() }).parse(project.database.config).binding;
+	const accountId = main.config.account_id ?? process.env.CLOUDFLARE_ACCOUNT_ID;
+	if (options.remote && !accountId) throw new Error("Set account_id or CLOUDFLARE_ACCOUNT_ID explicitly for remote maintenance.");
+	const select = (configuration, binding) => {
+		if (configuration.account_id && configuration.account_id !== accountId) throw new Error("All content databases must belong to the explicitly selected account.");
+		const matches = configuration.d1_databases.filter((database) => database.binding === binding);
+		if (matches.length !== 1) throw new Error(`Configure exactly one D1 database for binding ${binding}.`);
+		return matches[0];
+	};
+	const targets = [{
+		store: "primary",
+		binding: "CONTENT_PRIMARY",
+		database: select(main.config, mainBinding)
+	}];
+	for (const [store, descriptor] of Object.entries(config.stores)) {
+		const target = z.object({
+			config: z.string().min(1),
+			binding: z.string().min(1)
+		}).parse(descriptor.config.database);
+		const worker = await loadProjectWrangler(cwd, target.config, options.environment);
+		targets.push({
+			store,
+			binding: `CONTENT_STORE_${targets.length}`,
+			database: select(worker.config, target.binding)
+		});
+	}
+	if (new Set(targets.map((target) => target.database.database_id)).size !== targets.length) throw new Error("Content stores must select distinct physical D1 databases.");
+	return {
+		cwd,
+		config,
+		main,
+		targets,
+		accountId
+	};
+}
+async function openContentStorageProject(options) {
+	const project = await readContentStorageProject(options);
+	const directory = await mkdtemp(join(tmpdir(), "dineway-content-"));
+	let proxy;
+	const databases = {};
+	const close = async () => {
+		try {
+			await Promise.all(Object.values(databases).map((db) => db.destroy()));
+		} finally {
+			try {
+				await proxy?.dispose();
+			} finally {
+				await rm(directory, {
+					recursive: true,
+					force: true
+				});
+			}
+		}
+	};
+	try {
+		const path = join(directory, "wrangler.json");
+		await writeFile(path, JSON.stringify({
+			name: "dineway-content-maintenance",
+			account_id: project.accountId,
+			compatibility_date: project.main.config.compatibility_date ?? "2026-09-01",
+			d1_databases: project.targets.map((target) => ({
+				...target.database,
+				binding: target.binding,
+				remote: options.remote
+			}))
+		}));
+		proxy = await project.main.api.getPlatformProxy({
+			configPath: path,
+			remoteBindings: options.remote,
+			persist: options.remote ? false : { path: join(project.cwd, ".wrangler/state/v3") }
+		});
+		const dialect = await loadD1Dialect(project.cwd);
+		for (const target of project.targets) {
+			const binding = proxy.env[target.binding];
+			if (!binding || typeof binding.batch !== "function") throw new Error(`Missing D1 binding for store ${target.store}.`);
+			databases[target.store] = new Kysely({ dialect: dialect(binding) });
+		}
+		const jiti = createJiti(join(project.cwd, "package.json"), {
+			fsCache: false,
+			moduleCache: false
+		});
+		const resolvers = {};
+		for (const [collection, rule] of Object.entries(project.config.rules)) {
+			if (!("entrypoint" in rule.partitionBy)) continue;
+			const imported = await jiti.import(rule.partitionBy.entrypoint, { default: true });
+			if (typeof imported !== "function") throw new Error(`Partition resolver for ${collection} must export a default function.`);
+			resolvers[collection] = async (context, config) => z.string().parse(await imported(context, config));
+		}
+		const primary = databases.primary;
+		registerContentStorage(primary, {
+			config: project.config,
+			resolvers,
+			createStores: () => Object.fromEntries(Object.keys(project.config.stores).map((store) => [store, new ContentVersionStore(databases[store], store, project.config.version)]))
+		});
+		return {
+			...project,
+			databases,
+			primary,
+			close
+		};
+	} catch (error) {
+		await close();
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/cli/commands/content-storage.ts
+const actions = [
+	"install",
+	"schema",
+	"config",
+	"inventory",
+	"bootstrap",
+	"begin",
+	"copy",
+	"freeze",
+	"verify",
+	"activate",
+	"resume",
+	"rollback",
+	"cancel"
+];
+async function runContentStorageCommand(options) {
+	if (options.dryRun) {
+		const project = await readContentStorageProject(options);
+		return {
+			dryRun: true,
+			action: options.action,
+			location: options.remote ? "remote" : "local",
+			routingVersion: project.config.version,
+			targets: project.targets
+		};
+	}
+	const project = await openContentStorageProject(options);
+	try {
+		const { primary, config, databases } = project;
+		if (options.action === "install" || options.action === "schema") {
+			if (options.action === "schema") await assertContentStorageConfiguration(primary, config);
+			const schemas = Object.fromEntries(await Promise.all(Object.keys(config.rules).map(async (collection) => {
+				const row = await primary.selectFrom("_dineway_collections").select("id").where("slug", "=", collection).executeTakeFirst();
+				if (!row) throw new Error(`Install the primary schema for ${collection} first.`);
+				const fields = await primary.selectFrom("_dineway_fields").select(["slug", "column_type"]).where("collection_id", "=", row.id).execute();
+				return [collection, contentStoreCollectionSchema.parse({ fields: Object.fromEntries(fields.map((field) => [field.slug, field.column_type.toLowerCase()])) })];
+			})));
+			for (const [name, store] of Object.entries(config.stores)) await installContentVersionStore(databases[name], store.identity, schemas, { upgrade: options.action === "schema" });
+			if (options.action === "install") await installContentStorageConfig(primary, config, { initial: "primary" });
+			return {
+				installed: config.version,
+				stores: Object.keys(config.stores),
+				source: "primary"
+			};
+		}
+		if (options.action === "config") {
+			if (!options.previousConfig) throw new Error("Provide --previous-config with the exact previously installed contentStorage JSON.");
+			await migrateContentStorageConfig(primary, contentStorageConfigSchema.parse(JSON.parse(await readFile(resolve(project.cwd, options.previousConfig), "utf8"))), config);
+			return {
+				installed: config.version,
+				sourceStoresPreserved: true
+			};
+		}
+		await assertContentStorageConfiguration(primary, config);
+		for (const [store, definition] of Object.entries(config.stores)) await assertContentVersionStore(databases[store], definition.identity);
+		if (options.action === "inventory") {
+			const partitions = (await sql`SELECT p.*,COUNT(l.entry_id) AS entries FROM _dineway_content_partitions p LEFT JOIN _dineway_content_locations l ON l.collection=p.collection AND l.partition=p.partition GROUP BY p.collection,p.partition ORDER BY p.collection,p.partition`.execute(primary)).rows;
+			const unindexed = [];
+			for (const collection of Object.keys(config.rules)) unindexed.push({
+				collection,
+				...(await sql`SELECT COUNT(*) AS count FROM ${sql.table(`ec_${collection}`)} c WHERE NOT EXISTS (SELECT 1 FROM _dineway_content_locations l WHERE l.collection=${collection} AND l.entry_id=c.id)`.execute(primary)).rows[0]
+			});
+			const migrations = (await sql`SELECT * FROM _dineway_content_migrations ORDER BY created_at DESC LIMIT 100`.execute(primary)).rows;
+			const capacity = [];
+			for (const [store, database] of Object.entries(databases)) capacity.push({
+				store,
+				...await readContentDatabaseCapacity(database)
+			});
+			const delivery = (await sql`SELECT COUNT(*) AS pending,MIN(created_at) AS oldest_created_at,MAX(attempts) AS max_attempts FROM _dineway_content_hook_deliveries WHERE delivered_at IS NULL`.execute(primary)).rows[0];
+			return {
+				routingVersion: config.version,
+				capacity,
+				delivery,
+				partitions,
+				unindexed,
+				migrations,
+				retention: "Archives and old immutable content are never deleted by these commands."
+			};
+		}
+		const collection = options.collection;
+		if (!collection || !Object.hasOwn(config.rules, collection)) throw new Error("Select a configured Content type with --collection.");
+		const limit = Math.min(100, Math.max(1, Math.trunc(options.limit ?? 20)));
+		if (!Number.isFinite(limit)) throw new Error("The page limit must be finite.");
+		if (options.action === "bootstrap") return await bootstrapContentDirectoryPage(primary, collection, {
+			afterId: options.after,
+			limit
+		});
+		const partition = options.partition;
+		if (!partition || !Object.hasOwn(config.rules[collection].stores, partition) || !options.migration) throw new Error("Provide a configured --partition and a stable --migration identifier.");
+		const migration = {
+			collection,
+			partition,
+			id: options.migration
+		};
+		if (options.action === "begin") return await beginContentMigration(primary, config, migration);
+		if (options.action === "freeze") return await freezeContentPartition(primary, migration);
+		if (options.action === "resume") {
+			await completeContentMigration(primary, migration);
+			return {
+				completed: migration,
+				writes: "resumed"
+			};
+		}
+		if (options.action === "cancel") {
+			await cancelContentMigration(primary, migration);
+			return { cancelled: migration };
+		}
+		if (!options.archive) throw new Error("Provide a private --archive directory. Keep the same archive for the entire migration and at least seven days afterward.");
+		const archive = createFileContentArchive(resolve(project.cwd, options.archive));
+		if (options.action === "verify") return await verifyContentMigration(primary, migration, archive);
+		if (options.action === "rollback") {
+			await rollbackContentMigration(primary, migration, archive);
+			return {
+				restored: migration,
+				writes: "resumed on source"
+			};
+		}
+		const entries = options.action === "copy" ? (await sql`SELECT c.id FROM ${sql.table(`ec_${collection}`)} c JOIN _dineway_content_locations l ON l.entry_id=c.id AND l.collection=${collection} WHERE l.partition=${partition} AND c.id>${options.after ?? ""} ORDER BY c.id LIMIT ${limit}`.execute(primary)).rows : (await sql`SELECT entry_id AS id FROM _dineway_content_migration_entries WHERE migration_id=${migration.id} AND state='prepared' AND entry_id>${options.after ?? ""} ORDER BY entry_id LIMIT ${limit}`.execute(primary)).rows;
+		for (const entry of entries) if (options.action === "copy") await stageContentMigrationEntry(primary, migration, entry.id, archive);
+		else await activateContentMigrationEntry(primary, migration, entry.id, archive);
+		return {
+			action: options.action,
+			count: entries.length,
+			nextCursor: entries.length === limit ? entries.at(-1)?.id : void 0
+		};
+	} finally {
+		await project.close();
+	}
+}
+const contentStorageCommand = defineCommand({
+	meta: {
+		name: "content-storage",
+		description: "Explicit Content type storage installation and resumable migration"
+	},
+	args: {
+		action: {
+			type: "positional",
+			required: true,
+			description: actions.join(", ")
+		},
+		cwd: {
+			type: "string",
+			default: process.cwd()
+		},
+		local: {
+			type: "boolean",
+			default: false
+		},
+		remote: {
+			type: "boolean",
+			default: false
+		},
+		"dry-run": {
+			type: "boolean",
+			default: false
+		},
+		config: { type: "string" },
+		env: { type: "string" },
+		collection: { type: "string" },
+		partition: { type: "string" },
+		migration: { type: "string" },
+		archive: { type: "string" },
+		"previous-config": { type: "string" },
+		after: { type: "string" },
+		limit: {
+			type: "string",
+			default: "20"
+		}
+	},
+	async run({ args }) {
+		const action = actions.find((value) => value === args.action);
+		if (!action) throw new Error(`Choose a content storage action: ${actions.join(", ")}.`);
+		consola.log(JSON.stringify(await runContentStorageCommand({
+			action,
+			cwd: args.cwd,
+			local: args.local,
+			remote: args.remote,
+			dryRun: args["dry-run"],
+			config: args.config,
+			environment: args.env,
+			collection: args.collection,
+			partition: args.partition,
+			migration: args.migration,
+			archive: args.archive,
+			previousConfig: args["previous-config"],
+			after: args.after,
+			limit: Number(args.limit)
+		}), null, 2));
+	}
+});
+
 //#endregion
 //#region src/cli/commands/database.ts
 async function migrateProjectD1(options) {
@@ -1120,7 +1514,10 @@ const databaseCommand = defineCommand({
 		name: "database",
 		description: "Explicit database maintenance"
 	},
-	subCommands: { migrate: migrateCommand }
+	subCommands: {
+		migrate: migrateCommand,
+		"content-storage": contentStorageCommand
+	}
 });
 
 //#endregion
@@ -3978,7 +4375,7 @@ const devCommand = defineCommand({
 			const remoteUrl = pkg.dineway?.url || process.env.DINEWAY_URL;
 			if (!remoteUrl) consola.warn("No remote URL configured. Set DINEWAY_URL or dineway.url in package.json");
 			else try {
-				const { createClientFromArgs } = await import("../client-factory-C1ZQCMog.mjs").then((n) => n.t);
+				const { createClientFromArgs } = await import("../client-factory-BLbm250o.mjs").then((n) => n.t);
 				const client = createClientFromArgs({ url: remoteUrl });
 				const schema = await client.schemaExport();
 				const types = await client.schemaTypes();
@@ -4209,6 +4606,24 @@ const exportSeedCommand = defineCommand({
 			description: "Include content (all or comma-separated collection names)",
 			required: false
 		},
+		local: {
+			type: "boolean",
+			description: "Export from the local D1 content storage project",
+			default: false
+		},
+		remote: {
+			type: "boolean",
+			description: "Export from the remote D1 content storage project",
+			default: false
+		},
+		config: {
+			type: "string",
+			description: "Primary Wrangler configuration"
+		},
+		environment: {
+			type: "string",
+			description: "Wrangler environment"
+		},
 		pretty: {
 			type: "boolean",
 			description: "Pretty print JSON output",
@@ -4216,7 +4631,26 @@ const exportSeedCommand = defineCommand({
 		}
 	},
 	async run({ args }) {
-		const database = resolveCliDatabaseTarget(resolve(args.cwd), args.database);
+		const cwd = resolve(args.cwd);
+		if (args.local || args.remote) {
+			const project = await openContentStorageProject({
+				cwd,
+				local: args.local,
+				remote: args.remote,
+				config: args.config,
+				environment: args.environment
+			});
+			try {
+				await assertContentStorageConfiguration(project.primary, project.config);
+				for (const [store, definition] of Object.entries(project.config.stores)) await assertContentVersionStore(project.databases[store], definition.identity);
+				const seed = await exportSeed(project.primary, args["with-content"]);
+				console.log(JSON.stringify(seed, null, args.pretty ? "	" : void 0));
+			} finally {
+				await project.close();
+			}
+			return;
+		}
+		const database = resolveCliDatabaseTarget(cwd, args.database);
 		consola.info(`Database: ${database.display}`);
 		const db = createDatabase({ url: database.url });
 		try {
@@ -4587,8 +5021,12 @@ async function exportContent(db, collections, includeCollections, bylineIdToSeed
 			cursor = result.nextCursor;
 		} while (cursor);
 	} catch {}
+	const configured = await db.introspection.getTables().then((tables) => tables.some((table) => table.name === "_dineway_content_partitions"));
 	for (const collection of collections) {
 		if (includeCollections && !includeCollections.includes(collection.slug)) continue;
+		if (configured) {
+			if ((await sql`SELECT 1 FROM _dineway_content_partitions WHERE collection=${collection.slug} LIMIT 1`.execute(db)).rows.length > 0) await assertContentStorageConfiguration(db, getContentStorage(db, collection.slug)?.runtime.config);
+		}
 		const entries = [];
 		let cursor;
 		const translationGroupToSeedId = /* @__PURE__ */ new Map();
@@ -5991,7 +6429,7 @@ const publishCommand = defineCommand({
 			const pluginDir = resolve(args.dir);
 			try {
 				const { runCommand } = await import("citty");
-				const { bundleCommand } = await import("../bundle-bhiszAui.mjs").then((n) => n.n);
+				const { bundleCommand } = await import("../bundle-DWn5eFKz.mjs").then((n) => n.n);
 				await runCommand(bundleCommand, { rawArgs: ["--dir", pluginDir] });
 			} catch {
 				consola.error("Build failed");

package/dist/cli/plugin-kit.d.mts

@@ -1,14 +1,17 @@
-import "../types-D5JfvPvx.mjs";
-import "../types-B--VyN3n.mjs";
-import "../runner-SoP1rphP.mjs";
-import "../index-BVGe04wF.mjs";
-import "../types-B03h5jt_.mjs";
-import "../adapters-C8nRpUuj.mjs";
-import "../scheduled-publish-BxdShRGs.mjs";
-import "../public-url-Ccv0Xmue.mjs";
-import "../validate-kmN2lS8H.mjs";
-import "../byline-fields-D-b9CWux.mjs";
-import "../types-DsJTXStN.mjs";
+import "../types-C3jUu4Bc.mjs";
+import "../types-Dpv_MvwZ.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 "../scheduled-publish-eCNGpvNm.mjs";
+import "../public-url-CEC1vj02.mjs";
+import "../validate-DUscf6VG.mjs";
+import "../byline-fields-Bne2v0ti.mjs";
+import "../types-BJztoTbF.mjs";
 import { DinewayClient, PluginRequestOptions } from "../client/index.mjs";
 import { SubCommandsDef } from "citty";
 

package/dist/cli/plugin-kit.mjs

@@ -1,4 +1,4 @@
-import { n as output, t as configureOutputMode } from "../output-7HDrYTSQ.mjs";
-import { n as connectionArgs, r as createClientFromArgs } from "../client-factory-C1ZQCMog.mjs";
+import { n as output, t as configureOutputMode } from "../output-ljHaxIHX.mjs";
+import { n as connectionArgs, r as createClientFromArgs } from "../client-factory-BLbm250o.mjs";
 
 export { configureOutputMode, connectionArgs, createClientFromArgs, output };

package/dist/client/external-auth-headers.d.mts

@@ -1,4 +1,4 @@
-import { t as Interceptor } from "../transport-CZbtxgKZ.mjs";
+import { t as Interceptor } from "../transport-CVU5rp7W.mjs";
 
 //#region src/client/external-auth-headers.d.ts
 /**