dineway 0.2.39 → 0.2.41

package/dist/version-store-BXv2D0de.mjs

@@ -0,0 +1,208 @@
+import { atomicBatch, ensureAtomicBatchSchema, rowUnchanged } from "./database/batch.mjs";
+import { n as contentDigest, o as ContentStorageError, t as canonicalContentJson } from "./config-6R0bchVE.mjs";
+import { sql } from "kysely";
+import { z } from "zod";
+
+//#region src/content-storage/version-store.ts
+const CONTENT_NAME = /^[a-z][a-z0-9_]{0,62}$/;
+const locationSchema = z.object({
+	collection: z.string().regex(CONTENT_NAME),
+	entryId: z.string().min(1).max(128),
+	store: z.string().min(1).max(63),
+	partition: z.string().min(1).max(256),
+	routingVersion: z.string().min(1).max(128),
+	version: z.string().min(1).max(128),
+	digest: z.string().regex(/^[a-f0-9]{64}$/)
+});
+const contentStoreCollectionSchema = z.object({ fields: z.record(z.string().regex(/^[a-z][a-z0-9_]{0,62}$/).refine((name) => name !== "id"), z.enum([
+	"text",
+	"integer",
+	"real",
+	"json"
+])).refine((fields) => Object.keys(fields).length <= 98, "Content stores support at most 98 data columns.") }).strict();
+const storedMetadata = z.object({
+	fields: z.record(z.string(), z.enum([
+		"text",
+		"integer",
+		"real",
+		"json",
+		"boolean"
+	])),
+	extra: z.record(z.string(), z.json())
+}).strict();
+const contentVersionSchema = z.object({
+	command: locationSchema.extend({
+		partitionEpoch: z.number().int().positive().optional(),
+		kind: z.enum(["content", "revision"]).optional(),
+		operationId: z.string().min(1).max(128),
+		principalId: z.string().min(1).max(128),
+		expectedVersion: z.string().min(1).max(128).nullable()
+	}).strict(),
+	data: z.record(z.string(), z.json())
+}).strict();
+const contentStoreRequestSchema = z.discriminatedUnion("action", [z.object({
+	action: z.literal("prepare"),
+	value: contentVersionSchema
+}).strict(), z.object({
+	action: z.literal("read"),
+	locations: z.array(locationSchema.strict()).min(1).max(16),
+	fields: z.array(z.string().regex(CONTENT_NAME)).max(98).optional()
+}).strict()]);
+/** Install on content databases explicitly; never called from a content request. */
+async function installContentVersionStore(db, identity, collections, options = {}) {
+	if (!identity || identity.length > 128) throw new ContentStorageError("INVALID_CONFIG", "A physical content database identity is required.");
+	await ensureAtomicBatchSchema(db);
+	await db.schema.createTable("_dineway_content_store_identity").ifNotExists().addColumn("id", "integer", (c) => c.primaryKey()).addColumn("identity", "text", (c) => c.notNull()).addColumn("schema_version", "integer", (c) => c.notNull()).execute();
+	await atomicBatch(db, {
+		checks: [sql`NOT EXISTS (SELECT 1 FROM _dineway_content_store_identity WHERE id = 1 AND (identity <> ${identity} OR schema_version <> 1))`],
+		statements: [sql`INSERT INTO _dineway_content_store_identity (id, identity, schema_version) VALUES (1, ${identity}, 1) ON CONFLICT (id) DO NOTHING`.compile(db)]
+	});
+	await db.schema.createTable("_dineway_content_versions").ifNotExists().addColumn("collection", "text", (c) => c.notNull()).addColumn("entry_id", "text", (c) => c.notNull()).addColumn("version", "text", (c) => c.notNull()).addColumn("operation_id", "text", (c) => c.notNull().unique()).addColumn("digest", "text", (c) => c.notNull()).addColumn("command", "text", (c) => c.notNull()).addColumn("data", "text", (c) => c.notNull()).addColumn("created_at", "text", (c) => c.notNull()).addPrimaryKeyConstraint("pk_content_versions", [
+		"collection",
+		"entry_id",
+		"version"
+	]).execute();
+	await db.schema.createIndex("idx_content_versions_created_at").ifNotExists().on("_dineway_content_versions").column("created_at").execute();
+	await db.schema.createTable("_dineway_content_store_collections").ifNotExists().addColumn("collection", "text", (c) => c.primaryKey()).addColumn("schema", "text", (c) => c.notNull()).addColumn("physical_schema", "text", (c) => c.notNull()).addColumn("digest", "text", (c) => c.notNull()).execute();
+	await db.schema.createTable("_dineway_content_store_schema_history").ifNotExists().addColumn("collection", "text", (c) => c.notNull()).addColumn("digest", "text", (c) => c.notNull()).addColumn("schema", "text", (c) => c.notNull()).addColumn("installed_at", "text", (c) => c.notNull()).addPrimaryKeyConstraint("pk_content_store_schema_history", ["collection", "digest"]).execute();
+	for (const [collection, input] of Object.entries(collections)) {
+		if (!CONTENT_NAME.test(collection)) throw new ContentStorageError("INVALID_CONFIG", "Invalid content type name.");
+		const definition = contentStoreCollectionSchema.parse(input);
+		const serialized = canonicalContentJson(definition);
+		const digest = await contentDigest(definition);
+		const previous = (await sql`SELECT collection,schema,physical_schema,digest FROM _dineway_content_store_collections WHERE collection=${collection}`.execute(db)).rows[0];
+		if (previous && previous.digest !== digest && !options.upgrade) throw new ContentStorageError("INVALID_CONFIG", "Content store schema changes require the explicit schema upgrade command.");
+		const physical = previous ? contentStoreCollectionSchema.parse(JSON.parse(previous.physical_schema)) : { fields: {} };
+		const added = Object.entries(definition.fields).filter(([field]) => !Object.hasOwn(physical.fields, field));
+		for (const [field, type] of Object.entries(definition.fields)) if (Object.hasOwn(physical.fields, field) && physical.fields[field] !== type) throw new ContentStorageError("INVALID_CONFIG", `Changing the stored type of ${collection}.${field} requires a separate data migration. Use a new field name.`);
+		const nextPhysical = contentStoreCollectionSchema.parse({ fields: {
+			...physical.fields,
+			...definition.fields
+		} });
+		const statements = [];
+		if (previous) for (const [field, type] of added) statements.push(db.schema.alterTable(`ec_${collection}`).addColumn(field, type === "json" ? "text" : type).compile());
+		else {
+			let table = db.schema.createTable(`ec_${collection}`).addColumn("id", "text", (c) => c.notNull()).addColumn("_dineway_storage_version", "text", (c) => c.notNull());
+			for (const [field, type] of Object.entries(definition.fields)) table = table.addColumn(field, type === "json" ? "text" : type);
+			statements.push(table.addPrimaryKeyConstraint(`pk_ec_${collection}_version`, ["id", "_dineway_storage_version"]).compile());
+		}
+		statements.push(sql`INSERT INTO _dineway_content_store_collections (collection,schema,physical_schema,digest) VALUES (${collection},${serialized},${canonicalContentJson(nextPhysical)},${digest}) ON CONFLICT (collection) DO UPDATE SET schema=excluded.schema,physical_schema=excluded.physical_schema,digest=excluded.digest`.compile(db), sql`INSERT INTO _dineway_content_store_schema_history (collection,digest,schema,installed_at) VALUES (${collection},${digest},${serialized},${(/* @__PURE__ */ new Date()).toISOString()}) ON CONFLICT (collection,digest) DO NOTHING`.compile(db));
+		await atomicBatch(db, {
+			checks: [previous ? rowUnchanged("_dineway_content_store_collections", previous) : sql`NOT EXISTS (SELECT 1 FROM _dineway_content_store_collections WHERE collection=${collection})`],
+			statements
+		});
+	}
+}
+/** Validate the physical binding and deployed schema once at request entry. */
+async function assertContentVersionStore(db, identity) {
+	const result = await sql`SELECT identity, schema_version FROM _dineway_content_store_identity WHERE id = 1`.execute(db);
+	if (result.rows[0]?.identity !== identity || result.rows[0]?.schema_version !== 1) throw new ContentStorageError("UNAVAILABLE", "Content database identity or schema does not match the deployed content service.");
+}
+/** Immutable staging versions; only the primary directory can make one visible. */
+var ContentVersionStore = class {
+	schemas = /* @__PURE__ */ new Map();
+	constructor(db, name, routingVersion) {
+		this.db = db;
+		this.name = name;
+		this.routingVersion = routingVersion;
+	}
+	async prepare(input) {
+		const { command, data } = contentVersionSchema.parse(input);
+		this.assertTarget(command, true);
+		const serialized = canonicalContentJson(command);
+		const payload = canonicalContentJson(data);
+		const definition = await this.schema(command.collection);
+		const fields = {};
+		const extra = {};
+		const columns = ["id", "_dineway_storage_version"];
+		const values = [command.entryId, command.version];
+		for (const [field, value] of Object.entries(data)) {
+			if (field.startsWith("_")) {
+				extra[field] = value;
+				continue;
+			}
+			const type = definition.fields[field];
+			if (!type && command.kind === "revision") {
+				extra[field] = value;
+				continue;
+			}
+			if (!type) throw new ContentStorageError("INVALID_CONFIG", `Content field ${field} is absent from the deployed store schema.`);
+			let encoded = value;
+			let codec = type;
+			if (value !== null) {
+				if (type === "json") encoded = canonicalContentJson(value);
+				else if (type === "integer" && typeof value === "boolean") {
+					encoded = Number(value);
+					codec = "boolean";
+				} else if (type === "text" ? typeof value !== "string" : typeof value !== "number" || !Number.isFinite(value) || type === "integer" && !Number.isSafeInteger(value)) throw new ContentStorageError("CONFLICT", `Content field ${field} does not match its deployed column type.`);
+			}
+			fields[field] = codec;
+			columns.push(field);
+			values.push(encoded);
+		}
+		const metadata = canonicalContentJson({
+			fields,
+			extra
+		});
+		if (await contentDigest(data) !== command.digest) throw new ContentStorageError("CONFLICT", "The prepared content digest does not match.");
+		if (new TextEncoder().encode(payload + serialized + command.collection + command.entryId + command.version + command.operationId + command.digest).length > 1999e3) throw new ContentStorageError("CONFLICT", "The content version exceeds the D1 row size limit; no data was truncated.");
+		await atomicBatch(this.db, {
+			checks: [sql`NOT EXISTS (SELECT 1 FROM _dineway_content_versions WHERE operation_id = ${command.operationId} AND command <> ${serialized})`, sql`NOT EXISTS (SELECT 1 FROM _dineway_content_versions WHERE collection = ${command.collection} AND entry_id = ${command.entryId} AND version = ${command.version} AND (command <> ${serialized} OR data <> ${metadata}))`],
+			statements: [sql`INSERT INTO ${sql.table(`ec_${command.collection}`)} (${sql.join(columns.map((column) => sql.ref(column)))}) VALUES (${sql.join(values)}) ON CONFLICT (id, _dineway_storage_version) DO NOTHING`.compile(this.db), sql`INSERT INTO _dineway_content_versions (collection, entry_id, version, operation_id, digest, command, data, created_at) VALUES (${command.collection}, ${command.entryId}, ${command.version}, ${command.operationId}, ${command.digest}, ${serialized}, ${metadata}, ${(/* @__PURE__ */ new Date()).toISOString()}) ON CONFLICT (collection, entry_id, version) DO NOTHING`.compile(this.db)]
+		});
+	}
+	async read(locations, fields) {
+		if (!locations.length) return [];
+		if (locations.length > 16) throw new ContentStorageError("CONFLICT", "Content reads must be split into batches of at most 16 versions.");
+		for (const location of locations) this.assertTarget(locationSchema.parse(location));
+		const versions = [];
+		for (const collection of new Set(locations.map((location) => location.collection))) {
+			const schema = await this.schema(collection);
+			const columns = fields?.filter((field) => Object.hasOwn(schema.physicalFields, field));
+			const clauses = locations.filter((location) => location.collection === collection).map((location) => sql`(v.entry_id = ${location.entryId} AND v.version = ${location.version} AND v.digest = ${location.digest})`);
+			const result = await sql`SELECT ${columns ? sql.join([
+				...columns.map((field) => sql.ref(`c.${field}`)),
+				sql`v.command AS _command`,
+				sql`v.data AS _metadata`
+			]) : sql`c.*, v.command AS _command, v.data AS _metadata`} FROM _dineway_content_versions v JOIN ${sql.table(`ec_${collection}`)} c ON c.id = v.entry_id AND c._dineway_storage_version = v.version WHERE v.collection = ${collection} AND (${sql.join(clauses, sql` OR `)})`.execute(this.db);
+			for (const row of result.rows) {
+				const metadata = storedMetadata.parse(JSON.parse(row._metadata));
+				const data = fields ? Object.fromEntries(Object.entries(metadata.extra).filter(([field]) => fields.includes(field))) : { ...metadata.extra };
+				for (const [field, type] of Object.entries(metadata.fields)) {
+					if (fields && !fields.includes(field)) continue;
+					if (!Object.hasOwn(row, field)) throw new ContentStorageError("UNAVAILABLE", "A stored content field is missing from its physical table.");
+					const value = row[field];
+					data[field] = value === null ? null : type === "json" ? JSON.parse(z.string().parse(value)) : type === "boolean" ? value === 1 : value;
+				}
+				versions.push(contentVersionSchema.parse({
+					command: JSON.parse(row._command),
+					data
+				}));
+			}
+		}
+		return versions;
+	}
+	schema(collection) {
+		let pending = this.schemas.get(collection);
+		if (!pending) {
+			pending = sql`SELECT schema,physical_schema, digest FROM _dineway_content_store_collections WHERE collection = ${collection}`.execute(this.db).then(async (result) => {
+				const row = result.rows[0];
+				if (!row) throw new ContentStorageError("INVALID_CONFIG", "Content type schema is not installed in this store.");
+				const definition = contentStoreCollectionSchema.parse(JSON.parse(row.schema));
+				if (await contentDigest(definition) !== row.digest) throw new ContentStorageError("UNAVAILABLE", "Content store schema fingerprint does not match.");
+				return {
+					...definition,
+					physicalFields: contentStoreCollectionSchema.parse(JSON.parse(row.physical_schema)).fields
+				};
+			});
+			this.schemas.set(collection, pending);
+		}
+		return pending;
+	}
+	assertTarget(location, write = false) {
+		if (location.store !== this.name || write && location.routingVersion !== this.routingVersion) throw new ContentStorageError("ROUTE_CHANGED", "The content request targets a different store or routing version.");
+	}
+};
+
+//#endregion
+export { contentVersionSchema as a, contentStoreRequestSchema as i, assertContentVersionStore as n, installContentVersionStore as o, contentStoreCollectionSchema as r, ContentVersionStore as t };

package/dist/version-store-B_THJCc0.d.mts

@@ -0,0 +1,98 @@
+import { d as ContentStore, n as ContentPartitionContext, p as PreparedContentVersion, r as ContentPartitionResolver, s as ContentStorageConfig, t as ContentLocation } from "./types-qOEot0UQ.mjs";
+import { Kysely } from "kysely";
+import { z } from "zod";
+
+//#region src/content-storage/config.d.ts
+declare function canonicalContentJson(value: unknown): string;
+declare function contentDigest(value: unknown): Promise<string>;
+declare function validateContentStorage(config: ContentStorageConfig): void;
+declare function resolveContentPartition(config: ContentStorageConfig, context: ContentPartitionContext, resolvers?: Readonly<Record<string, ContentPartitionResolver>>): Promise<{
+  store: string;
+  partition: string;
+} | null>;
+//#endregion
+//#region src/content-storage/version-store.d.ts
+declare const contentStoreCollectionSchema: z.ZodObject<{
+  fields: z.ZodRecord<z.ZodString, z.ZodEnum<{
+    json: "json";
+    text: "text";
+    integer: "integer";
+    real: "real";
+  }>>;
+}, z.core.$strict>;
+type ContentStoreCollection = z.infer<typeof contentStoreCollectionSchema>;
+declare const contentVersionSchema: z.ZodObject<{
+  command: z.ZodObject<{
+    collection: z.ZodString;
+    entryId: z.ZodString;
+    store: z.ZodString;
+    partition: z.ZodString;
+    routingVersion: z.ZodString;
+    version: z.ZodString;
+    digest: z.ZodString;
+    partitionEpoch: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodOptional<z.ZodEnum<{
+      content: "content";
+      revision: "revision";
+    }>>;
+    operationId: z.ZodString;
+    principalId: z.ZodString;
+    expectedVersion: z.ZodNullable<z.ZodString>;
+  }, z.core.$strict>;
+  data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strict>;
+declare const contentStoreRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  action: z.ZodLiteral<"prepare">;
+  value: z.ZodObject<{
+    command: z.ZodObject<{
+      collection: z.ZodString;
+      entryId: z.ZodString;
+      store: z.ZodString;
+      partition: z.ZodString;
+      routingVersion: z.ZodString;
+      version: z.ZodString;
+      digest: z.ZodString;
+      partitionEpoch: z.ZodOptional<z.ZodNumber>;
+      kind: z.ZodOptional<z.ZodEnum<{
+        content: "content";
+        revision: "revision";
+      }>>;
+      operationId: z.ZodString;
+      principalId: z.ZodString;
+      expectedVersion: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+  }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+  action: z.ZodLiteral<"read">;
+  locations: z.ZodArray<z.ZodObject<{
+    collection: z.ZodString;
+    entryId: z.ZodString;
+    store: z.ZodString;
+    partition: z.ZodString;
+    routingVersion: z.ZodString;
+    version: z.ZodString;
+    digest: z.ZodString;
+  }, z.core.$strict>>;
+  fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>], "action">;
+/** Install on content databases explicitly; never called from a content request. */
+declare function installContentVersionStore<DB>(db: Kysely<DB>, identity: string, collections: Record<string, ContentStoreCollection>, options?: {
+  upgrade?: boolean;
+}): Promise<void>;
+/** Validate the physical binding and deployed schema once at request entry. */
+declare function assertContentVersionStore<DB>(db: Kysely<DB>, identity: string): Promise<void>;
+/** Immutable staging versions; only the primary directory can make one visible. */
+declare class ContentVersionStore<DB> implements ContentStore {
+  private readonly db;
+  private readonly name;
+  private readonly routingVersion;
+  private readonly schemas;
+  constructor(db: Kysely<DB>, name: string, routingVersion: string);
+  prepare(input: PreparedContentVersion): Promise<void>;
+  read(locations: readonly ContentLocation[], fields?: readonly string[]): Promise<PreparedContentVersion[]>;
+  private schema;
+  private assertTarget;
+}
+//#endregion
+export { contentStoreRequestSchema as a, canonicalContentJson as c, validateContentStorage as d, contentStoreCollectionSchema as i, contentDigest as l, ContentVersionStore as n, contentVersionSchema as o, assertContentVersionStore as r, installContentVersionStore as s, ContentStoreCollection as t, resolveContentPartition as u };

package/dist/{widgets-BOrDZdQ3.mjs → widgets-9xHBhL_L.mjs}

@@ -1,6 +1,6 @@
-import { r as getDb } from "./loader-Dp6zLmQm.mjs";
-import { r as requestCached } from "./request-cache-8_ifFzVw.mjs";
-import { t as getWidgetComponents$1 } from "./components-rFN8NH3N.mjs";
+import { r as getDb } from "./loader-CCwWFQSh.mjs";
+import { r as requestCached } from "./request-cache-CizvDoxV.mjs";
+import { t as getWidgetComponents$1 } from "./components-JA6tFHmE.mjs";
 
 //#region src/widgets/index.ts
 /**

package/dist/{wordpress-slugs-ROzITIBK.mjs → wordpress-slugs-yaeD7cxn.mjs}

@@ -1,4 +1,4 @@
-import { a as RESERVED_COLLECTION_SLUGS } from "./types-COvyXIp7.mjs";
+import { a as RESERVED_COLLECTION_SLUGS } from "./types-BgUxCuwu.mjs";
 
 //#region src/import/wordpress-slugs.ts
 const INVALID_SLUG_CHARS = /[^a-z0-9_]/g;

package/dist/{worker-Bg35R37I.mjs → worker-CC_Rt1pB.mjs}

@@ -1,15 +1,15 @@
 import { getRequestContext, runWithContext } from "./request-context.mjs";
 import { AtomicWriteConflict, atomicBatch, isD1Database, rowUnchanged } from "./database/batch.mjs";
-import { t as ContentRepository } from "./content-CIKsrvU9.mjs";
-import { t as SiteActivityRepository } from "./site-activity-DU0UPDji.mjs";
-import { t as buildStableHash } from "./stable-hash-B9Tbb2f_.mjs";
-import { r as ReviewRequestRepository } from "./review-requests-CUVn0RBl.mjs";
-import { t as PublicationAuthorizationError } from "./publication-authorization-B_HJSnzR.mjs";
-import { t as ReviewPayloadBuilder } from "./review-payload-Bap86e75.mjs";
-import { t as DinewayToolsError } from "./service-kQ5ljRzX.mjs";
-import { i as REVIEW_MODEL, o as matchesDecisionModel } from "./runs-BtaAiLTw.mjs";
-import { i as reviewDraft, n as loadReviewContext, r as loadReviewImages, t as ReviewEvidenceError } from "./evidence-Vnp_fQbC.mjs";
-import { a as reviewQuestions, n as classifyReview, r as getReviewPolicy, t as REVIEW_THRESHOLDS } from "./policy-B6mVa7ib.mjs";
+import { t as ContentRepository } from "./content-BigS8BAv.mjs";
+import { t as SiteActivityRepository } from "./site-activity-hpfJkmxQ.mjs";
+import { t as buildStableHash } from "./stable-hash-9RDJgfif.mjs";
+import { r as ReviewRequestRepository } from "./review-requests-DZYM51yI.mjs";
+import { t as PublicationAuthorizationError } from "./publication-authorization-wMR-tEQ_.mjs";
+import { t as ReviewPayloadBuilder } from "./review-payload-Bhi52CbI.mjs";
+import { t as DinewayToolsError } from "./service-DeX1PRNt.mjs";
+import { i as REVIEW_MODEL, o as matchesDecisionModel } from "./runs-BjgLfqCn.mjs";
+import { i as reviewDraft, n as loadReviewContext, r as loadReviewImages, t as ReviewEvidenceError } from "./evidence-B3O9_VKm.mjs";
+import { a as reviewQuestions, n as classifyReview, r as getReviewPolicy, t as REVIEW_THRESHOLDS } from "./policy-DbceGc4P.mjs";
 import { sql } from "kysely";
 import { z } from "zod";
 

package/dist/write-intent-DuHVqks9.mjs

@@ -0,0 +1,108 @@
+import { getRequestContext, runWithContext } from "./request-context.mjs";
+import { atomicBatch } from "./database/batch.mjs";
+import { n as contentDigest, o as ContentStorageError, s as ContentStorageReplay } from "./config-6R0bchVE.mjs";
+import { r as getContentStorage } from "./runtime-Ch5G-tnG.mjs";
+import { t as contentWriteChecks } from "./atomic-authority-Bf5QZboB.mjs";
+import { a as contentVersionSchema } from "./version-store-BXv2D0de.mjs";
+import { sql } from "kysely";
+import { ulid } from "ulidx";
+import { z } from "zod";
+
+//#region src/content-storage/write-intent.ts
+const seedSchema = z.object({
+	entryId: z.string(),
+	revisionId: z.string(),
+	rootVersion: z.string(),
+	now: z.string(),
+	publishAuthority: z.boolean()
+});
+/** Persist generated identities before staging, so a process restart can resume the same write. */
+async function beginContentWriteIntent(db, collection, input, request) {
+	const principal = getRequestContext()?.writePrincipal?.id ?? "system";
+	const key = input.operationId ?? ulid();
+	if (!key || key.length > 256) throw new ContentStorageError("CONFLICT", "Content operation identifiers must contain 1 to 256 characters.");
+	const operationId = await contentDigest({
+		principal,
+		collection,
+		key
+	});
+	const context = getRequestContext()?.contentWriteRequest;
+	const requestDigest = context && context.operationId === input.operationId ? context.digest : await contentDigest(request);
+	const generated = {
+		entryId: input.id ?? ulid(),
+		revisionId: ulid(),
+		rootVersion: ulid(),
+		now: (/* @__PURE__ */ new Date()).toISOString(),
+		publishAuthority: !!(input.publish || input.unpublish)
+	};
+	await atomicBatch(db, {
+		checks: [sql`NOT EXISTS (SELECT 1 FROM _dineway_content_write_intents WHERE id=${operationId} AND request_digest<>${requestDigest})`],
+		statements: [sql`INSERT INTO _dineway_content_write_intents (id,collection,entry_id,principal_id,request_digest,seed,created_at) VALUES (${operationId},${collection},${generated.entryId},${principal},${requestDigest},${JSON.stringify(generated)},${generated.now}) ON CONFLICT (id) DO NOTHING`.compile(db)]
+	});
+	const row = (await sql`SELECT seed FROM _dineway_content_write_intents WHERE id=${operationId}`.execute(db)).rows[0];
+	const seed = seedSchema.parse(JSON.parse(row.seed));
+	const operation = (await sql`SELECT state,command FROM _dineway_content_operations WHERE id=${operationId}`.execute(db)).rows[0];
+	if (operation?.state === "committed") {
+		await atomicBatch(db, {
+			checks: [...contentWriteChecks(collection, seed.entryId, "edit"), ...input.publish || input.unpublish ? contentWriteChecks(collection, seed.entryId, "publish") : []],
+			statements: []
+		});
+		throw new ContentStorageReplay(contentVersionSchema.shape.command.parse(JSON.parse(operation.command)));
+	}
+	if (operation?.state === "aborted") throw new ContentStorageError("ROUTE_CHANGED", "This save was interrupted by a routing migration. Reload the entry before saving again.");
+	return {
+		...seed,
+		operationId
+	};
+}
+const REPLAYS = Symbol.for("dineway:content-write-replays");
+const shared = globalThis;
+const replayResults = shared[REPLAYS] ??= /* @__PURE__ */ new WeakSet();
+function markContentWriteReplay(result) {
+	replayResults.add(result);
+	return result;
+}
+function isContentWriteReplay(result) {
+	return replayResults.has(result);
+}
+/** A committed retry returns the current entry without rerunning hooks or business actions. */
+async function runIdempotentContentWrite(db, collection, key, request, operation, read) {
+	if (!key || !getContentStorage(db, collection)) return operation();
+	try {
+		if (key.length > 256) throw new ContentStorageError("CONFLICT", "Content operation identifiers must contain 1 to 256 characters.");
+		const operationId = await contentDigest({
+			principal: getRequestContext()?.writePrincipal?.id ?? "system",
+			collection,
+			key
+		});
+		const digest = await contentDigest(JSON.parse(JSON.stringify(request)));
+		const previous = (await sql`SELECT i.entry_id,i.request_digest,o.state,i.seed FROM _dineway_content_write_intents i LEFT JOIN _dineway_content_operations o ON o.id=i.id WHERE i.id=${operationId}`.execute(db)).rows[0];
+		if (previous && previous.request_digest !== digest) throw new ContentStorageError("CONFLICT", "This operation identifier belongs to a different save.");
+		if (previous?.state === "committed") {
+			await atomicBatch(db, {
+				checks: [...contentWriteChecks(collection, previous.entry_id, "edit"), ...seedSchema.parse(JSON.parse(previous.seed)).publishAuthority ? contentWriteChecks(collection, previous.entry_id, "publish") : []],
+				statements: []
+			});
+			return markContentWriteReplay(await read(previous.entry_id));
+		}
+		return await runWithContext({
+			editMode: false,
+			...getRequestContext(),
+			contentWriteRequest: {
+				operationId: key,
+				digest
+			}
+		}, operation);
+	} catch (error) {
+		return {
+			success: false,
+			error: {
+				code: error instanceof ContentStorageError ? error.code : "CONFLICT",
+				message: error instanceof ContentStorageError ? error.message : "The save could not be resumed. Reload the entry and retry."
+			}
+		};
+	}
+}
+
+//#endregion
+export { runIdempotentContentWrite as i, isContentWriteReplay as n, markContentWriteReplay as r, beginContentWriteIntent as t };

package/dist/{zod-generator-DkrWuID7.mjs → zod-generator-B5Pt8fv0.mjs}

@@ -1,5 +1,5 @@
-import { c as __exportAll } from "./runner-CRU7BXjr.mjs";
-import { n as hashString } from "./hash-D2Rqd2J2.mjs";
+import { c as __exportAll } from "./runner-CuG8o1uW.mjs";
+import { n as hashString } from "./hash-qSYPMJ8w.mjs";
 import { z } from "zod";
 
 //#region src/schema/zod-generator.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dineway",
-  "version": "0.2.39",
+  "version": "0.2.41",
   "description": "Agentic Website builder for restaurants — structured content meets AI via the Model Context Protocol",
   "type": "module",
   "publishConfig": {
@@ -198,6 +198,10 @@
       "types": "./dist/database/batch.d.mts",
       "default": "./dist/database/batch.mjs"
     },
+    "./content-storage": {
+      "types": "./dist/content-storage/index.d.mts",
+      "default": "./dist/content-storage/index.mjs"
+    },
     "./db/d1-migrations": {
       "types": "./dist/database/d1/index.d.mts",
       "default": "./dist/database/d1/index.mjs"
@@ -205,6 +209,10 @@
     "./after": {
       "types": "./dist/after.d.mts",
       "default": "./dist/after.mjs"
+    },
+    "./content-storage/store": {
+      "types": "./dist/content-storage/store.d.mts",
+      "default": "./dist/content-storage/store.mjs"
     }
   },
   "imports": {
@@ -234,6 +242,7 @@
     "#dineway-tools/*": "./src/dineway-tools/*",
     "#integration-credentials/*": "./src/integration-credentials/*",
     "#comments/*": "./src/comments/*",
+    "#content-storage/*": "./src/content-storage/*",
     "#config/*": "./src/config/*",
     "#site-context/*": "./src/site-context/*",
     "#types": "./src/astro/types.js"
@@ -363,6 +372,9 @@
       "db/batch": [
         "dist/database/batch.d.mts"
       ],
+      "content-storage": [
+        "dist/content-storage/index.d.mts"
+      ],
       "db/d1-migrations": [
         "dist/database/d1/index.d.mts"
       ],
@@ -401,7 +413,7 @@
     "jose": "^6.1.3",
     "jiti": "^2.6.1",
     "jpeg-js": "^0.4.4",
-    "kysely": "^0.27.0",
+    "kysely": "0.28.17",
     "mime": "^4.1.0",
     "minisearch": "^7.2.0",
     "modern-tar": "^0.7.5",
@@ -412,9 +424,9 @@
     "ulidx": "^2.4.1",
     "upng-js": "^2.1.0",
     "zod": "^4.4.1",
-    "@dineway-ai/admin": "^0.2.13",
+    "@dineway-ai/admin": "^0.2.14",
     "@dineway-ai/gutenberg-to-portable-text": "^0.2.3",
-    "@dineway-ai/auth": "^0.2.6"
+    "@dineway-ai/auth": "^0.2.7"
   },
   "optionalDependencies": {
     "@aws-sdk/client-s3": "^3.1049.0",

package/dist/cache-B5NSHhxG.mjs

@@ -1,52 +0,0 @@
-import { c as __exportAll } from "./runner-CRU7BXjr.mjs";
-import { i as matchPattern, n as interpolateDestination, t as compilePattern } from "./patterns-Ay-4KImK.mjs";
-
-//#region src/redirects/cache.ts
-var cache_exports = /* @__PURE__ */ __exportAll({
-	compileRedirectRules: () => compileRedirectRules,
-	getCachedRedirects: () => getCachedRedirects,
-	invalidateRedirectCache: () => invalidateRedirectCache,
-	matchCachedPatterns: () => matchCachedPatterns,
-	setCachedRedirects: () => setCachedRedirects
-});
-let cachedRedirects = null;
-function invalidateRedirectCache() {
-	cachedRedirects = null;
-}
-function getCachedRedirects() {
-	return cachedRedirects;
-}
-function compileRedirectRules(redirects) {
-	return redirects.map((redirect) => ({
-		redirect,
-		compiled: compilePattern(redirect.source)
-	}));
-}
-function setCachedRedirects(redirects) {
-	const exact = /* @__PURE__ */ new Map();
-	const patterns = [];
-	for (const redirect of redirects) if (redirect.isPattern) patterns.push({
-		redirect,
-		compiled: compilePattern(redirect.source)
-	});
-	else exact.set(redirect.source, redirect);
-	cachedRedirects = {
-		exact,
-		patterns
-	};
-	return cachedRedirects;
-}
-function matchCachedPatterns(rules, pathname) {
-	for (const { redirect, compiled } of rules) {
-		const params = matchPattern(compiled, pathname);
-		if (!params) continue;
-		return {
-			redirect,
-			destination: interpolateDestination(redirect.destination, params)
-		};
-	}
-	return null;
-}
-
-//#endregion
-export { matchCachedPatterns as a, invalidateRedirectCache as i, compileRedirectRules as n, setCachedRedirects as o, getCachedRedirects as r, cache_exports as t };