dineway 0.2.40 → 0.2.41

package/dist/content-Dr22fzA_.mjs

@@ -0,0 +1,390 @@
+import { t as contentTermChangesSchema } from "./terms-EskuqbKE.mjs";
+import { z } from "zod";
+
+//#region src/api/schemas/common.ts
+/** Valid role level values */
+const VALID_ROLE_LEVELS = new Set([
+	10,
+	20,
+	30,
+	40,
+	50
+]);
+/** Role level — coerces string/number to valid RoleLevel (10|20|30|40|50) */
+const roleLevel = z.coerce.number().int().refine((n) => VALID_ROLE_LEVELS.has(n), { message: "Invalid role level. Must be 10, 20, 30, 40, or 50" });
+/** Pagination query params — cursor-based */
+const cursorPaginationQuery = z.object({
+	cursor: z.string().optional().meta({ description: "Opaque cursor for pagination" }),
+	limit: z.coerce.number().int().min(1).max(100).optional().default(50).meta({ description: "Maximum number of items to return (1-100, default 50)" })
+}).meta({ id: "CursorPaginationQuery" });
+/** Pagination query params — offset-based */
+const offsetPaginationQuery = z.object({
+	limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+	offset: z.coerce.number().int().min(0).optional().default(0)
+}).meta({ id: "OffsetPaginationQuery" });
+/** Slug pattern: lowercase letters, digits, underscores; starts with letter */
+const slugPattern = /^[a-z][a-z0-9_]*$/;
+/** Matches http(s) scheme at start of URL */
+const HTTP_SCHEME_RE = /^https?:\/\//i;
+/** Validates that a URL string uses http or https scheme. Rejects javascript:/data: URI XSS vectors. */
+const httpUrl = z.string().url().refine((url) => HTTP_SCHEME_RE.test(url), "URL must use http or https");
+/** BCP 47 locale code — language with optional script/region subtags (e.g. en, en-US, pt-BR, es-419, zh-Hant) */
+const localeCode = z.string().regex(/^[a-z]{2,3}(-[a-z0-9]{2,8})*$/i, "Invalid locale code").transform((v) => v.toLowerCase());
+/** Shared `?locale=xx` query shape for endpoints that filter by locale. */
+const localeFilterQuery = z.object({ locale: z.string().min(1).optional() }).meta({ id: "LocaleFilterQuery" });
+/** Standard API error response */
+const apiErrorSchema = z.object({ error: z.object({
+	code: z.string().meta({
+		description: "Machine-readable error code",
+		example: "NOT_FOUND"
+	}),
+	message: z.string().meta({ description: "Human-readable error message" })
+}) }).meta({ id: "ApiError" });
+/** Wrap a data schema in the standard success envelope: { data: T } */
+function successEnvelope(dataSchema) {
+	return z.object({ data: dataSchema });
+}
+/** Standard delete response */
+const deleteResponseSchema = z.object({ deleted: z.literal(true) }).meta({ id: "DeleteResponse" });
+/** Standard count response */
+const countResponseSchema = z.object({ count: z.number().int().min(0) }).meta({ id: "CountResponse" });
+
+//#endregion
+//#region src/api/schemas/bylines.ts
+/** Slug pattern: lowercase letters, digits, and hyphens; must start with a letter */
+const bylineSlugPattern = /^[a-z][a-z0-9-]*$/;
+const customFieldValue = z.union([
+	z.string(),
+	z.boolean(),
+	z.null()
+]);
+const customFields = z.record(z.string(), customFieldValue);
+const bylineSummarySchema = z.object({
+	id: z.string(),
+	slug: z.string(),
+	displayName: z.string(),
+	bio: z.string().nullable(),
+	avatarMediaId: z.string().nullable(),
+	avatarStorageKey: z.string().nullish(),
+	avatarAlt: z.string().nullish(),
+	avatarBlurhash: z.string().nullish(),
+	avatarDominantColor: z.string().nullish(),
+	websiteUrl: z.string().nullable(),
+	userId: z.string().nullable(),
+	isGuest: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	locale: z.string(),
+	translationGroup: z.string().nullable(),
+	customFields: customFields.optional()
+}).meta({ id: "BylineSummary" });
+const bylineCreditSchema = z.object({
+	byline: bylineSummarySchema,
+	sortOrder: z.number().int(),
+	roleLabel: z.string().nullable(),
+	source: z.enum(["explicit", "inferred"]).optional().meta({ description: "Whether this credit was explicitly assigned or inferred from authorId" })
+}).meta({ id: "BylineCredit" });
+const contentBylineInputSchema = z.object({
+	bylineId: z.string().min(1),
+	roleLabel: z.string().nullish()
+}).meta({ id: "ContentBylineInput" });
+const bylinesListQuery = cursorPaginationQuery.extend({
+	search: z.string().optional(),
+	isGuest: z.coerce.boolean().optional(),
+	userId: z.string().optional(),
+	locale: z.string().min(1).optional()
+}).meta({ id: "BylinesListQuery" });
+const bylineCreateBody = z.object({
+	slug: z.string().min(1).regex(bylineSlugPattern, "Slug must contain only lowercase letters, digits, and hyphens"),
+	displayName: z.string().min(1),
+	bio: z.string().nullish(),
+	avatarMediaId: z.string().nullish(),
+	websiteUrl: httpUrl.nullish(),
+	userId: z.string().nullish(),
+	isGuest: z.boolean().optional(),
+	locale: z.string().min(1).optional(),
+	translationOf: z.string().optional(),
+	customFields: customFields.optional()
+}).meta({ id: "BylineCreateBody" });
+const bylineUpdateBody = z.object({
+	slug: z.string().min(1).regex(bylineSlugPattern, "Slug must contain only lowercase letters, digits, and hyphens").optional(),
+	displayName: z.string().min(1).optional(),
+	bio: z.string().nullish(),
+	avatarMediaId: z.string().nullish(),
+	websiteUrl: httpUrl.nullish(),
+	userId: z.string().nullish(),
+	isGuest: z.boolean().optional(),
+	customFields: customFields.optional()
+}).meta({ id: "BylineUpdateBody" });
+const bylineListResponseSchema = z.object({
+	items: z.array(bylineSummarySchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "BylineListResponse" });
+
+//#endregion
+//#region src/api/schemas/content.ts
+/** SEO input — per-content meta fields */
+const contentSeoInput = z.object({
+	title: z.string().max(200).nullish(),
+	description: z.string().max(500).nullish(),
+	image: z.string().nullish(),
+	canonical: httpUrl.nullish(),
+	noIndex: z.boolean().optional()
+}).meta({ id: "ContentSeoInput" });
+const contentDateBound = z.union([z.iso.datetime({
+	offset: true,
+	message: "must be an ISO 8601 datetime"
+}), z.iso.date({ message: "must be an ISO 8601 date" })]).optional();
+const contentListQuery = cursorPaginationQuery.extend({
+	status: z.string().optional(),
+	orderBy: z.string().optional(),
+	order: z.enum(["asc", "desc"]).optional(),
+	locale: localeCode.optional(),
+	q: z.string().trim().min(1).max(200).optional(),
+	authorId: z.string().min(1).max(64).optional(),
+	dateField: z.enum([
+		"createdAt",
+		"updatedAt",
+		"publishedAt"
+	]).optional(),
+	dateFrom: contentDateBound,
+	dateTo: contentDateBound
+}).meta({ id: "ContentListQuery" });
+const contentDateOverride = z.iso.datetime({
+	offset: true,
+	message: "must be an ISO 8601 datetime"
+}).nullish();
+const publicationPolicyOverrideSchema = z.object({
+	policyId: z.string().min(1),
+	warningCode: z.string().min(1),
+	fingerprint: z.string().min(1)
+});
+const contentCreateBody = z.object({
+	operationId: z.string().min(1).max(256).optional(),
+	data: z.record(z.string(), z.unknown()),
+	terms: contentTermChangesSchema.optional(),
+	slug: z.string().nullish(),
+	status: z.enum(["draft"]).optional(),
+	bylines: z.array(contentBylineInputSchema).optional(),
+	locale: localeCode.optional(),
+	translationOf: z.string().optional(),
+	seo: contentSeoInput.optional(),
+	publishedAt: contentDateOverride,
+	createdAt: contentDateOverride
+}).meta({ id: "ContentCreateBody" });
+const contentUpdateBody = z.object({
+	operationId: z.string().min(1).max(256).optional(),
+	data: z.record(z.string(), z.unknown()).optional(),
+	terms: contentTermChangesSchema.optional(),
+	slug: z.string().nullish(),
+	status: z.enum(["draft"]).optional(),
+	authorId: z.string().nullish(),
+	bylines: z.array(contentBylineInputSchema).optional(),
+	_rev: z.string().optional().meta({ description: "Opaque revision token for optimistic concurrency" }),
+	skipRevision: z.boolean().optional(),
+	seo: contentSeoInput.optional(),
+	publishedAt: contentDateOverride
+}).meta({ id: "ContentUpdateBody" });
+const contentScheduleBody = z.object({
+	scheduledAt: z.string().min(1, "scheduledAt is required").meta({
+		description: "ISO 8601 datetime for scheduled publishing",
+		example: "2025-06-15T09:00:00Z"
+	}),
+	reviewRequestId: z.string().min(1, "reviewRequestId is required").meta({ description: "Approved editorial Review Request bound to the exact Draft Revision" }),
+	releaseAuthorizationId: z.string().min(1).optional().meta({ description: "Approved exact release HITL Request required for token actors" }),
+	policyOverrides: z.array(publicationPolicyOverrideSchema).max(20).optional()
+}).meta({ id: "ContentScheduleBody" });
+const contentPublishBody = z.object({
+	publishedAt: z.iso.datetime({
+		offset: true,
+		message: "must be an ISO 8601 datetime"
+	}).optional().meta({ description: "Optional ISO 8601 datetime to backdate the publish. Requires content:publish_any permission. Without this, existing published_at is preserved on re-publish." }),
+	reviewRequestId: z.string().min(1, "reviewRequestId is required").meta({ description: "Approved editorial Review Request bound to the exact Draft Revision" }),
+	releaseAuthorizationId: z.string().min(1).optional().meta({ description: "Approved exact release HITL Request required for token actors" }),
+	policyOverrides: z.array(publicationPolicyOverrideSchema).max(20).optional()
+}).meta({ id: "ContentPublishBody" });
+const contentPublicationReceiptSchema = z.object({
+	id: z.string(),
+	status: z.enum(["published", "scheduled"]),
+	collection: z.string(),
+	contentId: z.string(),
+	liveRevisionId: z.string().nullable(),
+	draftRevisionId: z.string().nullable(),
+	editorialReviewRequestId: z.string(),
+	releaseHitlRequestId: z.string().nullable(),
+	actionHash: z.string(),
+	policyContributions: z.array(z.object({
+		providerId: z.string(),
+		policyVersion: z.string(),
+		disposition: z.enum([
+			"enforced",
+			"not_applicable",
+			"overridden"
+		]),
+		fingerprint: z.string(),
+		reservationId: z.string().nullable()
+	})),
+	authorizedByActorType: z.enum([
+		"user",
+		"api_token",
+		"system"
+	]),
+	authorizedByActorId: z.string(),
+	createdAt: z.string(),
+	consumedAt: z.string().nullable(),
+	publishedAt: z.string().nullable(),
+	scheduledAt: z.string().nullable()
+}).meta({ id: "ContentPublicationReceipt" });
+const contentReleaseReadinessQuery = z.object({
+	operation: z.enum(["publish", "schedule"]).optional(),
+	reviewRequestId: z.string().optional(),
+	releaseAuthorizationId: z.string().optional(),
+	publishedAt: z.iso.datetime({ offset: true }).optional(),
+	scheduledAt: z.iso.datetime({ offset: true }).optional(),
+	locale: localeCode.optional()
+}).meta({ id: "ContentReleaseReadinessQuery" });
+const contentReleaseReadinessResponseSchema = z.object({
+	ready: z.boolean(),
+	canForce: z.boolean(),
+	generatedAt: z.string(),
+	nextAction: z.enum([
+		"publish",
+		"schedule",
+		"confirm_policy_warnings",
+		"fix_release_blockers"
+	]),
+	target: z.object({
+		collection: z.string(),
+		entryId: z.string(),
+		scope: z.string(),
+		operation: z.enum(["publish", "schedule"]),
+		liveRevisionId: z.string().nullable(),
+		draftRevisionId: z.string().nullable(),
+		reviewedRev: z.string(),
+		publishedAt: z.string().nullable(),
+		scheduledAt: z.string().nullable(),
+		siteTimezone: z.string()
+	}).nullable(),
+	blockers: z.array(z.object({
+		code: z.string(),
+		source: z.enum([
+			"content",
+			"editorial_review",
+			"release_hitl",
+			"authorization",
+			"policy"
+		]),
+		message: z.string(),
+		policyId: z.string().optional()
+	})),
+	warnings: z.array(z.object({
+		severity: z.literal("warning"),
+		code: z.string(),
+		source: z.enum([
+			"content",
+			"editorial_review",
+			"release_hitl",
+			"authorization",
+			"policy"
+		]),
+		message: z.string(),
+		policyId: z.string().optional(),
+		fingerprint: z.string(),
+		overridable: z.boolean()
+	}))
+}).meta({ id: "ContentReleaseReadinessResponse" });
+const contentPreviewUrlBody = z.object({
+	expiresIn: z.union([z.string(), z.number()]).optional(),
+	pathPattern: z.string().optional()
+}).meta({ id: "ContentPreviewUrlBody" });
+const contentTermsBody = z.object({ termIds: z.array(z.string()) }).meta({ id: "ContentTermsBody" });
+const contentTrashQuery = cursorPaginationQuery;
+/** SEO metadata on a content item */
+const contentSeoSchema = z.object({
+	title: z.string().nullable(),
+	description: z.string().nullable(),
+	image: z.string().nullable(),
+	canonical: z.string().nullable(),
+	noIndex: z.boolean()
+}).meta({ id: "ContentSeo" });
+/** A single content item as returned by the API */
+const contentItemSchema = z.object({
+	id: z.string(),
+	type: z.string().meta({ description: "Collection slug this item belongs to" }),
+	slug: z.string().nullable(),
+	status: z.string().meta({ description: "draft, published, or scheduled" }),
+	data: z.record(z.string(), z.unknown()).meta({ description: "User-defined field values" }),
+	authorId: z.string().nullable(),
+	primaryBylineId: z.string().nullable(),
+	byline: bylineSummarySchema.nullable().optional(),
+	bylines: z.array(bylineCreditSchema).optional(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	publishedAt: z.string().nullable(),
+	scheduledAt: z.string().nullable(),
+	liveRevisionId: z.string().nullable(),
+	draftRevisionId: z.string().nullable(),
+	version: z.number().int(),
+	locale: z.string().nullable(),
+	translationGroup: z.string().nullable(),
+	seo: contentSeoSchema.optional()
+}).meta({ id: "ContentItem" });
+/** Response for single content item endpoints (get, create, update) */
+const contentResponseSchema = z.object({
+	item: contentItemSchema,
+	_rev: z.string().optional().meta({ description: "Opaque revision token for optimistic concurrency" })
+}).meta({ id: "ContentResponse" });
+const contentPublishResponseSchema = contentResponseSchema.extend({ publicationReceipt: contentPublicationReceiptSchema }).meta({ id: "ContentPublishResponse" });
+/** Response for content list endpoints */
+const contentListResponseSchema = z.object({
+	items: z.array(contentItemSchema),
+	nextCursor: z.string().optional(),
+	total: z.number().int().nonnegative().optional()
+}).meta({ id: "ContentListResponse" });
+const contentAuthorSchema = z.object({
+	id: z.string(),
+	name: z.string().nullable(),
+	email: z.string(),
+	avatarUrl: z.string().nullable()
+}).meta({ id: "ContentAuthor" });
+const contentAuthorsResponseSchema = z.object({ items: z.array(contentAuthorSchema) }).meta({ id: "ContentAuthorsResponse" });
+/** Trashed content item */
+const trashedContentItemSchema = z.object({
+	id: z.string(),
+	type: z.string(),
+	slug: z.string().nullable(),
+	status: z.string(),
+	data: z.record(z.string(), z.unknown()),
+	authorId: z.string().nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	publishedAt: z.string().nullable(),
+	deletedAt: z.string()
+}).meta({ id: "TrashedContentItem" });
+/** Response for trashed content list */
+const trashedContentListResponseSchema = z.object({
+	items: z.array(trashedContentItemSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "TrashedContentListResponse" });
+/** Response for content compare (live vs draft) */
+const contentCompareResponseSchema = z.object({
+	hasChanges: z.boolean(),
+	live: z.record(z.string(), z.unknown()).nullable(),
+	draft: z.record(z.string(), z.unknown()).nullable()
+}).meta({ id: "ContentCompareResponse" });
+/** Translation summary for a content item */
+const contentTranslationSchema = z.object({
+	id: z.string(),
+	locale: z.string().nullable(),
+	slug: z.string().nullable(),
+	status: z.string(),
+	updatedAt: z.string()
+});
+/** Response for content translations endpoint */
+const contentTranslationsResponseSchema = z.object({
+	translationGroup: z.string(),
+	translations: z.array(contentTranslationSchema)
+}).meta({ id: "ContentTranslationsResponse" });
+
+//#endregion
+export { bylinesListQuery as A, offsetPaginationQuery as B, trashedContentItemSchema as C, bylineListResponseSchema as D, bylineCreditSchema as E, cursorPaginationQuery as F, slugPattern as H, deleteResponseSchema as I, httpUrl as L, VALID_ROLE_LEVELS as M, apiErrorSchema as N, bylineSummarySchema as O, countResponseSchema as P, localeCode as R, contentUpdateBody as S, bylineCreateBody as T, successEnvelope as U, roleLevel as V, contentSeoSchema as _, contentItemSchema as a, contentTranslationsResponseSchema as b, contentPreviewUrlBody as c, contentPublishResponseSchema as d, contentReleaseReadinessQuery as f, contentSeoInput as g, contentScheduleBody as h, contentCreateBody as i, contentBylineInputSchema as j, bylineUpdateBody as k, contentPublicationReceiptSchema as l, contentResponseSchema as m, contentAuthorsResponseSchema as n, contentListQuery as o, contentReleaseReadinessResponseSchema as p, contentCompareResponseSchema as r, contentListResponseSchema as s, contentAuthorSchema as t, contentPublishBody as u, contentTermsBody as v, trashedContentListResponseSchema as w, contentTrashQuery as x, contentTranslationSchema as y, localeFilterQuery as z };

package/dist/{content-refresh-BilzqcLt.mjs → content-refresh-DJuFIqQ4.mjs}

@@ -1,10 +1,12 @@
 import { AtomicWriteConflict, atomicBatch } from "./database/batch.mjs";
 import { t as validateIdentifier } from "./validate-Co3j6T_K.mjs";
 import { r as isI18nEnabled } from "./config-XW5tMrH8.mjs";
-import { i as encodeCursor, r as decodeCursor } from "./types-RFzE_V1M.mjs";
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-C8vSD_5L.mjs";
-import { n as normalizeMime } from "./mime-BnVhH671.mjs";
-import { n as hashString } from "./hash-D2Rqd2J2.mjs";
+import { a as hydrateContentRows } from "./runtime-Ch5G-tnG.mjs";
+import { t as readRevisionData } from "./revisions-CQ7rMP5d.mjs";
+import { i as encodeCursor, r as decodeCursor } from "./types-BI3ULB3A.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-Bb56aCtB.mjs";
+import { n as normalizeMime } from "./mime-FkfazULS.mjs";
+import { n as hashString } from "./hash-qSYPMJ8w.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 
@@ -1058,13 +1060,16 @@ async function loadContentMediaUsageSnapshots(db, collectionSlug, contentId, fie
 }
 async function loadContentRow(db, collectionSlug, contentId, fieldSlugs) {
 	const tableName = getContentTableName(collectionSlug);
-	const columnRefs = uniqueColumns([...CONTENT_SYSTEM_COLUMNS, ...fieldSlugs]).map((column) => sql.ref(column));
-	return (await sql`
+	const columns = uniqueColumns([...CONTENT_SYSTEM_COLUMNS, ...fieldSlugs]);
+	const columnRefs = columns.map((column) => sql.ref(column));
+	const result = await sql`
 		SELECT ${sql.join(columnRefs, sql`, `)}
 		FROM ${sql.ref(tableName)}
 		WHERE id = ${contentId}
 		LIMIT 1
-	`.execute(db)).rows[0] ?? null;
+	`.execute(db);
+	await hydrateContentRows(db, collectionSlug, result.rows, columns);
+	return result.rows[0] ?? null;
 }
 async function loadRevisionRow(db, revisionId) {
 	const row = await db.selectFrom("revisions").select([
@@ -1074,7 +1079,8 @@ async function loadRevisionRow(db, revisionId) {
 		"data"
 	]).where("id", "=", revisionId).executeTakeFirst();
 	if (!row) return null;
-	const data = parseRevisionData(row.data);
+	const parsed = parseRevisionData(row.data);
+	const data = parsed && Object.hasOwn(parsed, "__dineway_content_storage__") ? await readRevisionData(db, row) : parsed;
 	if (!data) return { success: false };
 	return {
 		success: true,

package/dist/content-storage/index.d.mts

@@ -0,0 +1,180 @@
+import { n as Database } from "../types-Dpv_MvwZ.mjs";
+import "../database/batch.mjs";
+import { a as ContentStorageActivation, c as ContentStorageError, d as ContentStore, f as ContentStoreDescriptor, i as ContentPartitionRule, l as ContentStorageReplay, n as ContentPartitionContext, o as ContentStorageCommand, p as PreparedContentVersion, r as ContentPartitionResolver, s as ContentStorageConfig, t as ContentLocation, u as ContentStorageValue } from "../types-qOEot0UQ.mjs";
+import { a as registerContentStorage, i as hydrateContentRows, n as assertContentStorageConfiguration, o as ContentStorageCoordinator, r as getContentStorage, s as installContentStorageConfig, t as ContentStorageRuntime } from "../runtime-Bs2JMbb2.mjs";
+import "../hook-events-BQw73jc7.mjs";
+import { a as contentStoreRequestSchema, c as canonicalContentJson, d as validateContentStorage, i as contentStoreCollectionSchema, l as contentDigest, n as ContentVersionStore, o as contentVersionSchema, r as assertContentVersionStore, s as installContentVersionStore, t as ContentStoreCollection, u as resolveContentPartition } from "../version-store-B_THJCc0.mjs";
+import * as kysely from "kysely";
+import { Kysely } from "kysely";
+import { z } from "zod";
+
+//#region src/content-storage/config-migration.d.ts
+/** Explicit deployment step. Mapping changes retain the source until its data migration completes. */
+declare function migrateContentStorageConfig<DB>(db: Kysely<DB>, previous: ContentStorageConfig, next: ContentStorageConfig): Promise<void>;
+//#endregion
+//#region src/content-storage/migration-snapshot.d.ts
+declare const contentMigrationSnapshotSchema: z.ZodObject<{
+  collection: z.ZodString;
+  entryId: z.ZodString;
+  schemaDigest: z.ZodString;
+  changeSequence: z.ZodNumber;
+  row: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+  item: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    slug: z.ZodNullable<z.ZodString>;
+    status: z.ZodString;
+    authorId: z.ZodNullable<z.ZodString>;
+    primaryBylineId: z.ZodNullable<z.ZodString>;
+    byline: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+      id: z.ZodString;
+      slug: z.ZodString;
+      displayName: z.ZodString;
+      bio: z.ZodNullable<z.ZodString>;
+      avatarMediaId: z.ZodNullable<z.ZodString>;
+      avatarStorageKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      avatarAlt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      avatarBlurhash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      avatarDominantColor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      websiteUrl: z.ZodNullable<z.ZodString>;
+      userId: z.ZodNullable<z.ZodString>;
+      isGuest: z.ZodBoolean;
+      createdAt: z.ZodString;
+      updatedAt: z.ZodString;
+      locale: z.ZodString;
+      translationGroup: z.ZodNullable<z.ZodString>;
+      customFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNull]>>>;
+    }, z.core.$strip>>>;
+    bylines: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      byline: z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        displayName: z.ZodString;
+        bio: z.ZodNullable<z.ZodString>;
+        avatarMediaId: z.ZodNullable<z.ZodString>;
+        avatarStorageKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        avatarAlt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        avatarBlurhash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        avatarDominantColor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        websiteUrl: z.ZodNullable<z.ZodString>;
+        userId: z.ZodNullable<z.ZodString>;
+        isGuest: z.ZodBoolean;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        locale: z.ZodString;
+        translationGroup: z.ZodNullable<z.ZodString>;
+        customFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNull]>>>;
+      }, z.core.$strip>;
+      sortOrder: z.ZodNumber;
+      roleLabel: z.ZodNullable<z.ZodString>;
+      source: z.ZodOptional<z.ZodEnum<{
+        explicit: "explicit";
+        inferred: "inferred";
+      }>>;
+    }, z.core.$strip>>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    scheduledAt: z.ZodNullable<z.ZodString>;
+    liveRevisionId: z.ZodNullable<z.ZodString>;
+    draftRevisionId: z.ZodNullable<z.ZodString>;
+    version: z.ZodNumber;
+    locale: z.ZodNullable<z.ZodString>;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    seo: z.ZodOptional<z.ZodObject<{
+      title: z.ZodNullable<z.ZodString>;
+      description: z.ZodNullable<z.ZodString>;
+      image: z.ZodNullable<z.ZodString>;
+      canonical: z.ZodNullable<z.ZodString>;
+      noIndex: z.ZodBoolean;
+    }, z.core.$strip>>;
+    data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+  }, z.core.$strip>;
+  location: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+  partitionDependencies: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+  revisions: z.ZodArray<z.ZodObject<{
+    row: z.ZodObject<{
+      id: z.ZodString;
+      collection: z.ZodString;
+      entry_id: z.ZodString;
+      data: z.ZodString;
+      author_id: z.ZodNullable<z.ZodString>;
+      created_at: z.ZodString;
+    }, z.core.$strip>;
+    data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+  }, z.core.$strip>>;
+  owned: z.ZodObject<{
+    terms: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    bylines: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    seo: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+  }, z.core.$strip>;
+}, z.core.$strict>;
+type ContentMigrationSnapshot = z.infer<typeof contentMigrationSnapshotSchema>;
+/** The host supplies durable private storage, such as R2 or an fsynced local archive. */
+interface ContentMigrationArchive {
+  put(key: string, snapshot: ContentMigrationSnapshot): Promise<void>;
+  get(key: string): Promise<unknown>;
+}
+/** Capture an entry, complete history and owned metadata without changing its visibility. */
+declare function captureContentMigrationSnapshot(db: Kysely<Database>, collection: string, entryId: string): Promise<ContentMigrationSnapshot>;
+/** Index legacy primary rows in resumable pages before taking a partition's write freeze. */
+declare function bootstrapContentDirectoryPage(db: Kysely<Database>, collection: string, options?: {
+  afterId?: string;
+  limit?: number;
+}): Promise<{
+  indexed: number;
+  nextCursor: string | undefined;
+}>;
+//#endregion
+//#region src/content-storage/routing.d.ts
+interface ContentPartitionRoute {
+  collection: string;
+  partition: string;
+  store: string;
+  target_store: string;
+  state: "active" | "copying" | "frozen";
+  epoch: number;
+  migration_id: string | null;
+  updated_at: string;
+}
+declare function readContentPartitionRoute<DB>(db: Kysely<DB>, collection: string, partition: string): Promise<{
+  route: ContentPartitionRoute;
+  check: kysely.RawBuilder<boolean>;
+}>;
+interface ContentMigrationIdentity {
+  collection: string;
+  partition: string;
+  id: string;
+}
+/** Starts copying while the partition remains writable on its current store. */
+declare function beginContentMigration<DB>(db: Kysely<DB>, config: ContentStorageConfig, migration: ContentMigrationIdentity): Promise<ContentPartitionRoute>;
+/** Epoch fencing makes all previously prepared writes fail before primary activation. */
+declare function freezeContentPartition<DB>(db: Kysely<DB>, migration: ContentMigrationIdentity): Promise<ContentPartitionRoute>;
+/** Resume the old store only while every entry still points to it. */
+declare function cancelContentMigration<DB>(db: Kysely<DB>, migration: ContentMigrationIdentity): Promise<void>;
+//#endregion
+//#region src/content-storage/migration.d.ts
+interface MigrationEntry {
+  migration_id: string;
+  entry_id: string;
+  source_digest: string;
+  archive_key: string;
+  target_location: string;
+  state: string;
+  updated_at: string;
+}
+/** Idempotent pre-copy. Full source data must be durably archived and read back first. */
+declare function stageContentMigrationEntry(db: Kysely<Database>, migration: ContentMigrationIdentity, entryId: string, archive: ContentMigrationArchive): Promise<MigrationEntry>;
+/** Activate one verified entry while the city remains frozen; retries use its persisted receipt. */
+declare function activateContentMigrationEntry(db: Kysely<Database>, migration: ContentMigrationIdentity, entryId: string, archive: ContentMigrationArchive): Promise<void>;
+/** Refresh the frozen delta, verify all current IDs, and seal the activation manifest. */
+declare function verifyContentMigration(db: Kysely<Database>, migration: ContentMigrationIdentity, archive: ContentMigrationArchive): Promise<{
+  count: number;
+  digest: string;
+}>;
+/** Reopen writes only after every sealed entry has activated; old archives remain retained. */
+declare function completeContentMigration(db: Kysely<Database>, migration: ContentMigrationIdentity): Promise<void>;
+/** Restore the archived source only before writes have reopened. Never deletes either copy. */
+declare function rollbackContentMigration(db: Kysely<Database>, migration: ContentMigrationIdentity, archive: ContentMigrationArchive): Promise<void>;
+//#endregion
+export { type ContentLocation, type ContentMigrationArchive, type ContentMigrationIdentity, type ContentMigrationSnapshot, type ContentPartitionContext, type ContentPartitionResolver, type ContentPartitionRoute, type ContentPartitionRule, type ContentStorageActivation, type ContentStorageCommand, type ContentStorageConfig, ContentStorageCoordinator, ContentStorageError, ContentStorageReplay, type ContentStorageRuntime, type ContentStorageValue, type ContentStore, type ContentStoreCollection, type ContentStoreDescriptor, ContentVersionStore, type PreparedContentVersion, activateContentMigrationEntry, assertContentStorageConfiguration, assertContentVersionStore, beginContentMigration, bootstrapContentDirectoryPage, cancelContentMigration, canonicalContentJson, captureContentMigrationSnapshot, completeContentMigration, contentDigest, contentMigrationSnapshotSchema, contentStoreCollectionSchema, contentStoreRequestSchema, contentVersionSchema, freezeContentPartition, getContentStorage, hydrateContentRows, installContentStorageConfig, installContentVersionStore, migrateContentStorageConfig, readContentPartitionRoute, registerContentStorage, resolveContentPartition, rollbackContentMigration, stageContentMigrationEntry, validateContentStorage, verifyContentMigration };

package/dist/content-storage/index.mjs

@@ -0,0 +1,29 @@
+import "../d1-binding-DrLMBUxu.mjs";
+import "../dialect-helpers-C6xtO-Ui.mjs";
+import { a as validateContentStorage, i as resolveContentPartition, n as contentDigest, o as ContentStorageError, s as ContentStorageReplay, t as canonicalContentJson } from "../config-6R0bchVE.mjs";
+import { a as hydrateContentRows, c as installContentStorageConfig, f as freezeContentPartition, l as beginContentMigration, o as registerContentStorage, p as readContentPartitionRoute, r as getContentStorage, s as ContentStorageCoordinator, t as assertContentStorageConfiguration, u as cancelContentMigration } from "../runtime-Ch5G-tnG.mjs";
+import "../revisions-CQ7rMP5d.mjs";
+import "../base64-qvSs0Gxy.mjs";
+import "../types-BI3ULB3A.mjs";
+import "../actor-D0AW80ld.mjs";
+import "../atomic-authority-Bf5QZboB.mjs";
+import "../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 "../byline-3qjp1-oa.mjs";
+import "../owned-metadata-BPmUjZqI.mjs";
+import "../revision-B_HYO2AE.mjs";
+import "../user-Bl2_8rhJ.mjs";
+import "../terms-EskuqbKE.mjs";
+import "../redirect-CJ-FAbNK.mjs";
+import "../content-write-DAZCNKWl.mjs";
+import "../text-extraction-CdqMGYQK.mjs";
+import { a as contentVersionSchema, i as contentStoreRequestSchema, 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 "../content-Dr22fzA_.mjs";
+import { a as verifyContentMigration, c as contentMigrationSnapshotSchema, i as stageContentMigrationEntry, l as migrateContentStorageConfig, n as completeContentMigration, o as bootstrapContentDirectoryPage, r as rollbackContentMigration, s as captureContentMigrationSnapshot, t as activateContentMigrationEntry } from "../migration-DJuj7ZwN.mjs";
+
+export { ContentStorageCoordinator, ContentStorageError, ContentStorageReplay, ContentVersionStore, activateContentMigrationEntry, assertContentStorageConfiguration, assertContentVersionStore, beginContentMigration, bootstrapContentDirectoryPage, cancelContentMigration, canonicalContentJson, captureContentMigrationSnapshot, completeContentMigration, contentDigest, contentMigrationSnapshotSchema, contentStoreCollectionSchema, contentStoreRequestSchema, contentVersionSchema, freezeContentPartition, getContentStorage, hydrateContentRows, installContentStorageConfig, installContentVersionStore, migrateContentStorageConfig, readContentPartitionRoute, registerContentStorage, resolveContentPartition, rollbackContentMigration, stageContentMigrationEntry, validateContentStorage, verifyContentMigration };

package/dist/content-storage/store.d.mts

@@ -0,0 +1,3 @@
+import { c as ContentStorageError, d as ContentStore, p as PreparedContentVersion, t as ContentLocation } from "../types-qOEot0UQ.mjs";
+import { a as contentStoreRequestSchema, l as contentDigest, n as ContentVersionStore, o as contentVersionSchema, r as assertContentVersionStore, s as installContentVersionStore } from "../version-store-B_THJCc0.mjs";
+export { type ContentLocation, ContentStorageError, type ContentStore, ContentVersionStore, type PreparedContentVersion, assertContentVersionStore, contentDigest, contentStoreRequestSchema, contentVersionSchema, installContentVersionStore };

package/dist/content-storage/store.mjs

@@ -0,0 +1,5 @@
+import "../d1-binding-DrLMBUxu.mjs";
+import { n as contentDigest, o as ContentStorageError } from "../config-6R0bchVE.mjs";
+import { a as contentVersionSchema, i as contentStoreRequestSchema, n as assertContentVersionStore, o as installContentVersionStore, t as ContentVersionStore } from "../version-store-BXv2D0de.mjs";
+
+export { ContentStorageError, ContentVersionStore, assertContentVersionStore, contentDigest, contentStoreRequestSchema, contentVersionSchema, installContentVersionStore };