dineway 0.2.40 → 0.2.42

package/dist/{taxonomies-lWGNLKgn.mjs → taxonomies-BI26Bk-M.mjs}

@@ -1,10 +1,10 @@
-import { c as __exportAll } from "./runner-CRU7BXjr.mjs";
+import { c as __exportAll } from "./runner-CuG8o1uW.mjs";
 import { getRequestContext } from "./request-context.mjs";
-import { a as resetTaxonomyNamesCache, o as isMissingTableError, r as getDb } from "./loader-Dp6zLmQm.mjs";
-import { d as invalidateTaxonomyObjectCache, f as isObjectCacheActive, n as cachedQuery, t as CacheNamespace } from "./object-cache-mxCW-Rpt.mjs";
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-C8vSD_5L.mjs";
-import { i as setRequestCacheEntry, n as peekRequestCache, r as requestCached } from "./request-cache-8_ifFzVw.mjs";
-import { n as resolveLocaleChain, t as resolveLocale } from "./resolve-DEKC4qVa.mjs";
+import { a as resetTaxonomyNamesCache, o as isMissingTableError, r as getDb } from "./loader-Bq1aW12P.mjs";
+import { i as setRequestCacheEntry, n as peekRequestCache, r as requestCached } from "./request-cache-CizvDoxV.mjs";
+import { d as invalidateTaxonomyObjectCache, f as isObjectCacheActive, n as cachedQuery, t as CacheNamespace } from "./object-cache-DyI1SOBK.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-Bb56aCtB.mjs";
+import { n as resolveLocaleChain, t as resolveLocale } from "./resolve-BxFGSKYu.mjs";
 
 //#region src/taxonomies/index.ts
 /**
@@ -393,7 +393,7 @@ function primeFoldedEntryTerms(collection, perEntry, options = {}) {
 * Get entries by term.
 */
 async function getEntriesByTerm(collection, taxonomyName, termSlug, options = {}) {
-	const { getDinewayCollection } = await import("./query-xspvw7Ui.mjs").then((n) => n.o);
+	const { getDinewayCollection } = await import("./query-CLWTwcTr.mjs").then((n) => n.o);
 	const queryOptions = { where: { [taxonomyName]: termSlug } };
 	if (options.locale !== void 0) queryOptions.locale = options.locale;
 	const { entries } = await getDinewayCollection(collection, queryOptions);

package/dist/{taxonomy-DN6i1upz.mjs → taxonomy-B8w8F2Cs.mjs}

@@ -1,5 +1,9 @@
-import { c as __exportAll } from "./runner-CRU7BXjr.mjs";
-import { d as invalidateTaxonomyObjectCache } from "./object-cache-mxCW-Rpt.mjs";
+import { c as __exportAll } from "./runner-CuG8o1uW.mjs";
+import { atomicBatch } from "./database/batch.mjs";
+import { r as getContentStorage } from "./runtime-Ch5G-tnG.mjs";
+import { d as invalidateTaxonomyObjectCache } from "./object-cache-DyI1SOBK.mjs";
+import { r as snapshotContentTermChanges } from "./terms-EskuqbKE.mjs";
+import { sql } from "kysely";
 import { ulid } from "ulidx";
 
 //#region src/database/repositories/taxonomy.ts
@@ -120,9 +124,30 @@ var TaxonomyRepository = class {
 		if (deleted) invalidateTaxonomyObjectCache();
 		return deleted;
 	}
+	async writeRoutedTerms(collection, entryId, terms, checks = []) {
+		const { prepareContentWrite } = await import("./content-write-43KZZ7dz.mjs").then((n) => n.t);
+		const prepared = await prepareContentWrite(this.db, collection, {
+			id: entryId,
+			terms,
+			stageDraft: false
+		});
+		await atomicBatch(this.db, {
+			checks: [...prepared.batch.checks ?? [], ...checks],
+			statements: prepared.batch.statements
+		});
+		prepared.afterCommit();
+		invalidateTaxonomyObjectCache();
+	}
 	async attachToEntry(collection, entryId, taxonomyId) {
 		const group = await this.resolveTranslationGroup(taxonomyId);
 		if (!group) return;
+		if (getContentStorage(this.db, collection)) {
+			const source = await snapshotContentTermChanges(this.db, collection, entryId);
+			const term = (await this.findTranslations(group))[0];
+			if (!term || source.changes[term.name]?.includes(group)) return;
+			await this.writeRoutedTerms(collection, entryId, { [term.name]: [...source.changes[term.name] ?? [], group] }, source.checks);
+			return;
+		}
 		const row = {
 			collection,
 			entry_id: entryId,
@@ -134,6 +159,13 @@ var TaxonomyRepository = class {
 	async detachFromEntry(collection, entryId, taxonomyId) {
 		const group = await this.resolveTranslationGroup(taxonomyId);
 		if (!group) return;
+		if (getContentStorage(this.db, collection)) {
+			const source = await snapshotContentTermChanges(this.db, collection, entryId);
+			const term = (await this.findTranslations(group))[0];
+			if (!term || !source.changes[term.name]?.includes(group)) return;
+			await this.writeRoutedTerms(collection, entryId, { [term.name]: source.changes[term.name].filter((id) => id !== group) }, source.checks);
+			return;
+		}
 		await this.db.deleteFrom("content_taxonomies").where("collection", "=", collection).where("entry_id", "=", entryId).where("taxonomy_id", "=", group).execute();
 		invalidateTaxonomyObjectCache();
 	}
@@ -153,6 +185,10 @@ var TaxonomyRepository = class {
 	* Term ids OR translation_groups are accepted and normalised to groups.
 	*/
 	async setTermsForEntry(collection, entryId, taxonomyName, termIds) {
+		if (getContentStorage(this.db, collection)) {
+			await this.writeRoutedTerms(collection, entryId, { [taxonomyName]: termIds });
+			return;
+		}
 		const groups = [];
 		for (const id of termIds) {
 			const group = await this.resolveTranslationGroup(id);
@@ -172,6 +208,12 @@ var TaxonomyRepository = class {
 		if (toRemove.length > 0 || toAdd.length > 0) invalidateTaxonomyObjectCache();
 	}
 	async clearEntryTerms(collection, entryId) {
+		if (getContentStorage(this.db, collection) && (await sql`SELECT id FROM ${sql.table(`ec_${collection}`)} WHERE id=${entryId}`.execute(this.db)).rows.length) {
+			const source = await snapshotContentTermChanges(this.db, collection, entryId);
+			const count = Object.values(source.changes).reduce((sum, ids) => sum + ids.length, 0);
+			if (count) await this.writeRoutedTerms(collection, entryId, Object.fromEntries(Object.keys(source.changes).map((name) => [name, []])), source.checks);
+			return count;
+		}
 		const result = await this.db.deleteFrom("content_taxonomies").where("collection", "=", collection).where("entry_id", "=", entryId).executeTakeFirst();
 		const removed = Number(result.numDeletedRows ?? 0);
 		if (removed > 0) invalidateTaxonomyObjectCache();
@@ -183,6 +225,14 @@ var TaxonomyRepository = class {
 	* source's term assignments. Safe to call when the source has no terms.
 	*/
 	async copyEntryTerms(collection, sourceEntryId, targetEntryId) {
+		if (getContentStorage(this.db, collection)) {
+			const source = await snapshotContentTermChanges(this.db, collection, sourceEntryId);
+			const target = await snapshotContentTermChanges(this.db, collection, targetEntryId);
+			const changed = Object.entries(source.changes).filter(([name, ids]) => ids.some((id) => !target.changes[name]?.includes(id)));
+			if (!changed.length) return;
+			await this.writeRoutedTerms(collection, targetEntryId, Object.fromEntries(changed.map(([name, ids]) => [name, [...new Set([...target.changes[name] ?? [], ...ids])]])), [...source.checks, ...target.checks]);
+			return;
+		}
 		const rows = await this.db.selectFrom("content_taxonomies").select(["taxonomy_id"]).where("collection", "=", collection).where("entry_id", "=", sourceEntryId).execute();
 		if (rows.length === 0) return;
 		await this.db.insertInto("content_taxonomies").values(rows.map((r) => ({
@@ -226,7 +276,7 @@ var TaxonomyRepository = class {
 	*/
 	async countEntriesForTerms(translationGroups) {
 		if (translationGroups.length === 0) return /* @__PURE__ */ new Map();
-		const { chunks, SQL_BATCH_SIZE } = await import("./chunks-C8vSD_5L.mjs").then((n) => n.r);
+		const { chunks, SQL_BATCH_SIZE } = await import("./chunks-Bb56aCtB.mjs").then((n) => n.r);
 		const counts = /* @__PURE__ */ new Map();
 		for (const chunk of chunks(translationGroups, SQL_BATCH_SIZE)) {
 			const rows = await this.db.selectFrom("content_taxonomies").select(["taxonomy_id", (eb) => eb.fn.count("entry_id").as("count")]).where("taxonomy_id", "in", chunk).groupBy("taxonomy_id").execute();

package/dist/terms-EskuqbKE.mjs

@@ -0,0 +1,104 @@
+import { rowUnchanged } from "./database/batch.mjs";
+import { t as DinewayValidationError } from "./types-BI3ULB3A.mjs";
+import { sql } from "kysely";
+import { z } from "zod";
+
+//#region src/content-storage/terms.ts
+const contentTermChangesSchema = z.record(z.string().regex(/^[a-z][a-z0-9_]{0,62}$/), z.array(z.string().min(1).max(128)).max(100));
+async function snapshotContentTermChanges(db, collection, entryId) {
+	const rows = await db.selectFrom("content_taxonomies").selectAll().where("collection", "=", collection).where("entry_id", "=", entryId).execute();
+	const checks = [...rows.map((row) => rowUnchanged("content_taxonomies", row)), sql`(SELECT COUNT(*) FROM content_taxonomies WHERE collection = ${collection} AND entry_id = ${entryId}) = ${rows.length}`];
+	const changes = {};
+	for (const row of rows) {
+		const term = await db.selectFrom("taxonomies").selectAll().where("translation_group", "=", row.taxonomy_id).orderBy("locale").executeTakeFirst();
+		if (!term) throw new DinewayValidationError("An assigned term is missing.");
+		checks.push(rowUnchanged("taxonomies", term));
+		(changes[term.name] ??= []).push(row.taxonomy_id);
+	}
+	return {
+		changes,
+		checks
+	};
+}
+/** Prepare assignments together with content, so partition resolution sees the submitted terms. */
+async function prepareContentTerms(db, collection, entryId, input, locale) {
+	const changes = contentTermChangesSchema.parse(input);
+	const checks = [];
+	const statements = [];
+	const replaced = [];
+	const assignments = [];
+	for (const [name, ids] of Object.entries(changes)) {
+		const definitions = await db.selectFrom("_dineway_taxonomy_defs").selectAll().where("name", "=", name).execute();
+		if (!definitions.some((definition) => definition.collections === null || z.array(z.string()).parse(JSON.parse(definition.collections)).includes(collection))) throw new DinewayValidationError(`Taxonomy ${name} is not assigned to ${collection}.`);
+		checks.push(...definitions.map((definition) => rowUnchanged("_dineway_taxonomy_defs", definition)));
+		const groups = /* @__PURE__ */ new Set();
+		for (const id of new Set(ids)) {
+			const rows = await db.selectFrom("taxonomies").selectAll().where("name", "=", name).where((eb) => eb.or([eb("id", "=", id), eb("translation_group", "=", id)])).execute();
+			const term = rows.find((row) => row.locale === locale) ?? rows.find((row) => row.id === id);
+			if (!term?.translation_group) throw new DinewayValidationError(`Term ${id} is unavailable in taxonomy ${name}.`);
+			checks.push(rowUnchanged("taxonomies", term));
+			groups.add(term.translation_group);
+		}
+		const current = await db.selectFrom("content_taxonomies").selectAll().where("collection", "=", collection).where("entry_id", "=", entryId).where("taxonomy_id", "in", db.selectFrom("taxonomies").select("translation_group").where("name", "=", name)).execute();
+		replaced.push(...current.map((row) => row.taxonomy_id));
+		assignments.push(...groups);
+		checks.push(...current.map((row) => rowUnchanged("content_taxonomies", row)), sql`(SELECT COUNT(*) FROM content_taxonomies WHERE collection = ${collection} AND entry_id = ${entryId} AND taxonomy_id IN (SELECT translation_group FROM taxonomies WHERE name = ${name})) = ${current.length}`);
+		statements.push(db.deleteFrom("content_taxonomies").where("collection", "=", collection).where("entry_id", "=", entryId).where("taxonomy_id", "in", db.selectFrom("taxonomies").select("translation_group").where("name", "=", name)).compile());
+		for (const group of groups) statements.push(db.insertInto("content_taxonomies").values({
+			collection,
+			entry_id: entryId,
+			taxonomy_id: group
+		}).onConflict((oc) => oc.doNothing()).compile());
+	}
+	return {
+		checks,
+		statements,
+		replaced,
+		assignments
+	};
+}
+async function snapshotPartitionTerms(db, collection, entryId, name, locale, selected) {
+	const checks = [];
+	const assignments = await db.selectFrom("content_taxonomies").selectAll().where("collection", "=", collection).where("entry_id", "=", entryId).execute();
+	checks.push(...assignments.map((row) => rowUnchanged("content_taxonomies", row)), sql`(SELECT COUNT(*) FROM content_taxonomies WHERE collection = ${collection} AND entry_id = ${entryId}) = ${assignments.length}`);
+	const ids = selected ?? assignments.map((row) => row.taxonomy_id);
+	const terms = [];
+	const seen = /* @__PURE__ */ new Set();
+	const ancestors = /* @__PURE__ */ new Set();
+	const visit = async (id, isSelected) => {
+		const rows = await db.selectFrom("taxonomies").selectAll().where("name", "=", name).where((eb) => eb.or([eb("id", "=", id), eb("translation_group", "=", id)])).execute();
+		const term = rows.find((row) => row.locale === locale) ?? rows.find((row) => row.id === id) ?? rows.toSorted((a, b) => a.locale.localeCompare(b.locale))[0];
+		if (!term?.translation_group) {
+			if (selected) throw new DinewayValidationError(`Partition term ${id} is missing from ${name}.`);
+			return;
+		}
+		if (ancestors.has(term.id)) throw new DinewayValidationError("Partition taxonomy contains a parent cycle.");
+		if (seen.has(term.id)) {
+			if (isSelected) terms.find((value) => value.id === term.id).selected = true;
+			return;
+		}
+		if (seen.size >= 100) throw new DinewayValidationError("Partition taxonomy exceeds 100 terms and ancestors.");
+		seen.add(term.id);
+		checks.push(rowUnchanged("taxonomies", term));
+		terms.push({
+			id: term.id,
+			group: term.translation_group,
+			name: term.name,
+			slug: term.slug,
+			parentId: term.parent_id,
+			selected: isSelected,
+			data: term.data ? z.record(z.string(), z.json()).parse(JSON.parse(term.data)) : null
+		});
+		ancestors.add(term.id);
+		if (term.parent_id) await visit(term.parent_id, false);
+		ancestors.delete(term.id);
+	};
+	for (const id of [...ids].toSorted()) await visit(id, true);
+	return {
+		terms,
+		checks
+	};
+}
+
+//#endregion
+export { snapshotPartitionTerms as i, prepareContentTerms as n, snapshotContentTermChanges as r, contentTermChangesSchema as t };

package/dist/text-extraction-CdqMGYQK.mjs

@@ -0,0 +1,96 @@
+import { toPlainText } from "@portabletext/toolkit";
+
+//#region src/search/text-extraction.ts
+/**
+* Text Extraction
+*
+* Extracts plain text from Portable Text blocks for FTS indexing.
+* Uses @portabletext/toolkit as base with extensions for custom block types.
+*/
+/**
+* Validate that a value looks like a Portable Text block array.
+* Each element must have at least a `_type` string property.
+*/
+function isPortableTextArray(value) {
+	return value.every((item) => typeof item === "object" && item !== null && "_type" in item && typeof item._type === "string");
+}
+/**
+* Extract additional text from custom block types that toPlainText doesn't handle
+*/
+function extractCustomBlockText(block) {
+	if (block._type === "code" && "code" in block && typeof block.code === "string") return block.code;
+	if (block._type === "image") {
+		const parts = [];
+		if ("alt" in block && typeof block.alt === "string" && block.alt) parts.push(block.alt);
+		if ("caption" in block && typeof block.caption === "string" && block.caption) parts.push(block.caption);
+		return parts.join(" ");
+	}
+	return "";
+}
+/**
+* Extract plain text from Portable Text blocks
+*
+* Uses @portabletext/toolkit's toPlainText for standard blocks,
+* plus extracts text from custom block types (code, images with alt/caption).
+*
+* @param blocks - Array of Portable Text blocks (or a JSON string)
+* @returns Plain text content
+*
+* @example
+* ```typescript
+* const text = extractPlainText([
+*   {
+*     _type: "block",
+*     _key: "abc",
+*     children: [{ _type: "span", _key: "s1", text: "Hello World" }]
+*   }
+* ]);
+* // Returns: "Hello World"
+* ```
+*/
+function extractPlainText(blocks) {
+	if (!blocks) return "";
+	let parsedBlocks;
+	if (typeof blocks === "string") try {
+		parsedBlocks = JSON.parse(blocks);
+	} catch {
+		return blocks;
+	}
+	else parsedBlocks = blocks;
+	if (!Array.isArray(parsedBlocks)) return "";
+	return [toPlainText(parsedBlocks.map((b) => {
+		const obj = { _type: b._type };
+		for (const [key, val] of Object.entries(b)) obj[key] = val;
+		return obj;
+	})), ...parsedBlocks.map(extractCustomBlockText).filter((text) => text.length > 0)].filter((t) => t.length > 0).join("\n");
+}
+/**
+* Extract searchable text from a content entry
+*
+* Extracts text from specified fields, handling both plain text and Portable Text.
+*
+* @param entry - Content entry data
+* @param fields - Field names to extract text from
+* @returns Object mapping field names to extracted text
+*/
+function extractSearchableFields(entry, fields) {
+	const result = {};
+	for (const field of fields) {
+		const value = entry[field];
+		if (value === null || value === void 0) {
+			result[field] = "";
+			continue;
+		}
+		if (typeof value === "string") if (value.startsWith("[")) result[field] = extractPlainText(value);
+		else result[field] = value;
+		else if (Array.isArray(value)) if (isPortableTextArray(value)) result[field] = extractPlainText(value);
+		else result[field] = JSON.stringify(value);
+		else if (typeof value === "object") result[field] = JSON.stringify(value);
+		else if (typeof value === "number" || typeof value === "boolean") result[field] = `${value}`;
+		else result[field] = "";
+	}
+	return result;
+}
+
+//#endregion
+export { extractSearchableFields as n, extractPlainText as t };

package/dist/{tokens-D-StaTAQ.mjs → tokens-D8HEH277.mjs}

@@ -1,4 +1,4 @@
-import { i as encodeBase64url, n as decodeBase64url } from "./base64-Cz-aU0X1.mjs";
+import { i as encodeBase64url, n as decodeBase64url } from "./base64-qvSs0Gxy.mjs";
 
 //#region src/preview/tokens.ts
 /**

package/dist/{trusted-proxy-hYufGFPK.mjs → trusted-proxy-Dg3U9Lrv.mjs}

@@ -1,4 +1,4 @@
-import { t as readRuntimeEnv } from "./runtime-env-CPTzh0mZ.mjs";
+import { t as readRuntimeEnv } from "./runtime-env-DpYGy4pT.mjs";
 
 //#region src/auth/trusted-proxy.ts
 /**

package/dist/{types-D5JfvPvx.d.mts → types-0gRlZbhN.d.mts}

@@ -1,21 +1,24 @@
-import { _ as UpdateCollectionInput, d as FieldType, f as FieldValidation, i as CollectionWithFields, o as CreateCollectionInput, s as CreateFieldInput, t as Collection, u as Field, v as UpdateFieldInput } from "./types-SlLXjRpg.mjs";
-import { f as UpdateContentInput, i as ContentItem$1, l as FindManyOptions, o as ContentSeoInput, r as ContentDateField, s as CreateContentInput, t as BylineSummary, u as FindManyResult } from "./types-CgcOeaiQ.mjs";
-import { Ot as ReviewJobTable, t as Database } from "./types-B--VyN3n.mjs";
-import { _ as MediaValue, f as MediaProvider, m as MediaProviderDescriptor, p as MediaProviderCapabilities } from "./placeholder-DJLP_HY7.mjs";
+import { _ as UpdateCollectionInput, d as FieldType, f as FieldValidation, i as CollectionWithFields, o as CreateCollectionInput, s as CreateFieldInput, t as Collection, u as Field, v as UpdateFieldInput } from "./types-I5LHzk_M.mjs";
+import { f as UpdateContentInput, i as ContentItem$1, l as FindManyOptions, o as ContentSeoInput, r as ContentDateField, s as CreateContentInput, t as BylineSummary, u as FindManyResult } from "./types-ex-UrNlz.mjs";
+import { kt as ReviewJobTable, n as Database } from "./types-Dpv_MvwZ.mjs";
+import { _ as MediaValue, f as MediaProvider, m as MediaProviderDescriptor, p as MediaProviderCapabilities } from "./placeholder-DdZV3I8x.mjs";
 import { AtomicBatch } from "./database/batch.mjs";
-import { D as ContentBylineInput } from "./index-BVGe04wF.mjs";
-import { r as AuthProviderDescriptor, t as AuthDescriptor } from "./types-B03h5jt_.mjs";
-import { t as DatabaseDescriptor } from "./adapters-C8nRpUuj.mjs";
-import { r as ObjectCacheDescriptor } from "./types-CtGSEKEJ.mjs";
+import { D as ContentBylineInput } from "./index-CLj17kW9.mjs";
+import { s as ContentStorageConfig } from "./types-qOEot0UQ.mjs";
+import { r as AuthProviderDescriptor, t as AuthDescriptor } from "./types-DheoByey.mjs";
+import { t as DatabaseDescriptor } from "./adapters-lDnJjNDz.mjs";
+import { r as ObjectCacheDescriptor } from "./types-PxxPTFSl.mjs";
+import { t as ContentStorageRuntime } from "./runtime-Bs2JMbb2.mjs";
+import { n as ContentStorageHookName, r as ContentStorageHookTarget, t as ContentStorageHookEvent } from "./hook-events-BQw73jc7.mjs";
 import { ServerTimingMetric } from "./database/instrumentation.mjs";
-import { d as Storage } from "./types-KFzuijKE.mjs";
-import { t as PublishedRef } from "./scheduled-publish-BxdShRGs.mjs";
-import { C as SiteSettingKey, w as SiteSettings } from "./validate-kmN2lS8H.mjs";
+import { d as Storage } from "./types-C0heD9oI.mjs";
+import { t as PublishedRef } from "./scheduled-publish-eCNGpvNm.mjs";
+import { C as SiteSettingKey, w as SiteSettings } from "./validate-DUscf6VG.mjs";
 import { DinewayManifest, HandlerResponse } from "./astro/types.mjs";
 import * as kysely from "kysely";
-import { CompiledQuery, Dialect, Kysely, Migration, RawBuilder, Transaction } from "kysely";
-import { Permission, RoleLevel } from "@dineway-ai/auth";
+import { CompiledQuery, Dialect, Kysely, Migration, RawBuilder, Selectable, Transaction } from "kysely";
 import { z } from "zod";
+import { Permission, RoleLevel } from "@dineway-ai/auth";
 import { z as z$1 } from "astro/zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import "@forgeway/sdk";
@@ -542,13 +545,20 @@ declare function dinewayLoader(): LiveLoader<EntryData, EntryFilter, CollectionF
  */
 declare class ContentRepository {
   private db;
-  constructor(db: Kysely<Database>);
+  private options;
+  constructor(db: Kysely<Database>, options?: {
+    prepareIndexWrites?: boolean;
+  });
+  private assertIndexWrite;
+  private writeChecks;
   normalizePreparedData(type: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
   /**
    * Create a new content item
    */
   prepareCreate(input: CreateContentInput, options?: {
     captureDefaults?: boolean;
+    id?: string;
+    now?: string;
   }): Promise<{
     id: string;
     batch: AtomicBatch;
@@ -628,6 +638,8 @@ declare class ContentRepository {
    */
   prepareDelete(type: string, id: string): AtomicBatch;
   delete(type: string, id: string): Promise<boolean>;
+  /** Compose a routed soft delete with primary business writes without dropping its event. */
+  prepareSoftDelete(type: string, id: string): Promise<AtomicBatch>;
   /**
    * Restore content from trash
    */
@@ -636,6 +648,7 @@ declare class ContentRepository {
    * Permanently delete a soft-deleted content row.
    */
   permanentDelete(type: string, id: string): Promise<boolean>;
+  preparePermanentDelete(type: string, id: string): Promise<AtomicBatch | null>;
   /**
    * Find trashed content items
    */
@@ -910,12 +923,19 @@ interface CreateRevisionInput {
  */
 declare class RevisionRepository {
   private db;
-  constructor(db: Kysely<Database>);
+  private options;
+  constructor(db: Kysely<Database>, options?: {
+    prepareIndexWrites?: boolean;
+  });
+  private assertIndexWrite;
   /**
    * Create a new revision
    */
   prepareCreateSnapshot(input: Omit<CreateRevisionInput, "data"> & {
     data: RawBuilder<string>;
+  }, options?: {
+    id?: string;
+    createdAt?: string;
   }): {
     id: string;
     statement: kysely.CompiledQuery<kysely.InsertResult>;
@@ -1385,15 +1405,28 @@ declare function portableText(options?: {
   required?: boolean;
 }): FieldDefinition<PortableTextBlock$1[] | undefined>;
 //#endregion
+//#region src/content-storage/terms.d.ts
+declare const contentTermChangesSchema: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+type ContentTermChanges = z.infer<typeof contentTermChangesSchema>;
+//#endregion
 //#region src/api/handlers/content-write.d.ts
 interface ContentWriteInput$1 {
+  /** Reuse this identity when retrying an identical save after an unknown outcome. */
+  operationId?: string;
+  bylines?: ContentBylineInput[];
+  seo?: ContentSeoInput;
   id?: string;
   data?: Record<string, unknown>;
   draftData?: Record<string, unknown>;
+  terms?: ContentTermChanges;
   slug?: string;
   status?: "draft";
-  authorId?: string;
+  authorId?: string | null;
   locale?: string;
+  translationOf?: string;
+  createdAt?: string | null;
+  publishedAt?: string | null;
+  reuseDraftRevision?: boolean;
   expectedRev?: string;
   stageDraft?: boolean;
   unpublish?: boolean;
@@ -1512,7 +1545,9 @@ declare function handleContentGetIncludingTrashed(db: Kysely<Database>, collecti
  * API returns a validation error rather than silently dropping it.
  */
 declare function handleContentCreate(db: Kysely<Database>, collection: string, body: {
+  operationId?: string;
   data: Record<string, unknown>;
+  terms?: ContentTermChanges;
   slug?: string;
   status?: string;
   authorId?: string;
@@ -1531,7 +1566,9 @@ declare function handleContentCreate(db: Kysely<Database>, collection: string, b
  * Content + SEO writes are wrapped in a transaction for atomicity.
  */
 declare function handleContentUpdate(db: Kysely<Database>, collection: string, id: string, body: {
+  operationId?: string;
   data?: Record<string, unknown>;
+  terms?: ContentTermChanges;
   slug?: string;
   status?: string;
   authorId?: string | null;
@@ -1829,6 +1866,8 @@ interface DinewayConfig {
    * ```
    */
   database?: DatabaseDescriptor;
+  /** Optional Content type routing. Unconfigured types remain in the primary database. */
+  contentStorage?: ContentStorageConfig;
   /**
    * Storage configuration (for media)
    */
@@ -2488,6 +2527,9 @@ declare class HookPipeline {
    * should only run via invokeExclusiveHook(), not in the regular pipeline.
    */
   private getTypedHooks;
+  assertContentStorageHooks(): void;
+  contentStorageTargets(names: readonly ContentStorageHookName[]): ContentStorageHookTarget[];
+  deliverContentStorageHook(target: ContentStorageHookTarget, event: ContentStorageHookEvent): Promise<void>;
   /**
    * Register all hooks from plugins.
    *
@@ -2980,6 +3022,7 @@ interface MediaProviderContext {
  */
 interface RuntimeDependencies {
   config: DinewayConfig;
+  contentStorageRuntime?: ContentStorageRuntime | null;
   plugins: ResolvedPlugin[];
   createDialect: (config: any) => Dialect;
   createCoalescingDialect?: (config: any) => Dialect;
@@ -3180,7 +3223,9 @@ declare class DinewayRuntime {
   handleContentGet(collection: string, id: string, locale?: string): Promise<ApiResult<ContentResponse>>;
   handleContentGetIncludingTrashed(collection: string, id: string, locale?: string): Promise<ApiResult<ContentResponse>>;
   handleContentCreate(collection: string, body: {
+    operationId?: string;
     data: Record<string, unknown>;
+    terms?: Record<string, string[]>;
     slug?: string;
     status?: string;
     authorId?: string;
@@ -3192,7 +3237,9 @@ declare class DinewayRuntime {
     translationOf?: string;
   }): Promise<ApiResult<ContentResponse>>;
   handleContentUpdate(collection: string, id: string, body: {
+    operationId?: string;
     data?: Record<string, unknown>;
+    terms?: Record<string, string[]>;
     slug?: string;
     status?: string;
     authorId?: string | null;
@@ -3342,6 +3389,7 @@ declare class DinewayRuntime {
   private runSandboxedBeforeSave;
   private runSandboxedBeforeDelete;
   private previousContentForNotification;
+  private drainContentHooks;
   private runAfterSaveHooks;
   private runAfterDeleteHooks;
   private runAfterPublishHooks;
@@ -5027,19 +5075,19 @@ declare const pluginManifestSchema: z.ZodObject<{
     uniqueIndexes: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
   }, z.core.$strip>>;
   hooks: z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
-    "plugin:install": "plugin:install";
-    "plugin:activate": "plugin:activate";
-    "plugin:deactivate": "plugin:deactivate";
-    "plugin:uninstall": "plugin:uninstall";
-    "content:beforeSave": "content:beforeSave";
     "content:afterSave": "content:afterSave";
-    "content:beforeDelete": "content:beforeDelete";
-    "content:afterDelete": "content:afterDelete";
     "content:afterPublish": "content:afterPublish";
     "content:afterUnpublish": "content:afterUnpublish";
+    "content:afterDelete": "content:afterDelete";
     "content:afterRestore": "content:afterRestore";
     "content:afterSchedule": "content:afterSchedule";
     "content:afterUnschedule": "content:afterUnschedule";
+    "plugin:install": "plugin:install";
+    "plugin:activate": "plugin:activate";
+    "plugin:deactivate": "plugin:deactivate";
+    "plugin:uninstall": "plugin:uninstall";
+    "content:beforeSave": "content:beforeSave";
+    "content:beforeDelete": "content:beforeDelete";
     "media:beforeUpload": "media:beforeUpload";
     "media:afterUpload": "media:afterUpload";
     cron: "cron";
@@ -5054,19 +5102,19 @@ declare const pluginManifestSchema: z.ZodObject<{
     "page:fragments": "page:fragments";
   }>, z.ZodObject<{
     name: z.ZodEnum<{
-      "plugin:install": "plugin:install";
-      "plugin:activate": "plugin:activate";
-      "plugin:deactivate": "plugin:deactivate";
-      "plugin:uninstall": "plugin:uninstall";
-      "content:beforeSave": "content:beforeSave";
       "content:afterSave": "content:afterSave";
-      "content:beforeDelete": "content:beforeDelete";
-      "content:afterDelete": "content:afterDelete";
       "content:afterPublish": "content:afterPublish";
       "content:afterUnpublish": "content:afterUnpublish";
+      "content:afterDelete": "content:afterDelete";
       "content:afterRestore": "content:afterRestore";
       "content:afterSchedule": "content:afterSchedule";
       "content:afterUnschedule": "content:afterUnschedule";
+      "plugin:install": "plugin:install";
+      "plugin:activate": "plugin:activate";
+      "plugin:deactivate": "plugin:deactivate";
+      "plugin:uninstall": "plugin:uninstall";
+      "content:beforeSave": "content:beforeSave";
+      "content:beforeDelete": "content:beforeDelete";
       "media:beforeUpload": "media:beforeUpload";
       "media:afterUpload": "media:afterUpload";
       cron: "cron";
@@ -5159,9 +5207,9 @@ declare const pluginManifestSchema: z.ZodObject<{
         json: "json";
         slug: "slug";
         image: "image";
-        datetime: "datetime";
         text: "text";
         integer: "integer";
+        datetime: "datetime";
         select: "select";
         multiSelect: "multiSelect";
         portableText: "portableText";
@@ -7086,7 +7134,9 @@ interface StorageCollection<T = unknown> {
   putMany(items: Array<{
     id: string;
     data: T;
-  }>): Promise<void>;
+  }>, options?: {
+    ifAbsent?: boolean;
+  }): Promise<void>;
   deleteMany(ids: string[]): Promise<number>;
   query(options?: QueryOptions): Promise<PaginatedResult<{
     id: string;
@@ -7559,6 +7609,8 @@ type CommentAfterModerateHandler = (event: CommentAfterModerateEvent, ctx: Plugi
  * Hook configuration
  */
 interface HookConfig<THandler> {
+  /** Required for durable delivery of routed content events; deduplicate with event.idempotencyKey. */
+  idempotent?: boolean;
   /** Explicit ordering - lower numbers run first (default: 100) */
   priority?: number;
   /** Max execution time in ms (default: 5000) */
@@ -7580,6 +7632,7 @@ interface HookConfig<THandler> {
  * Content hook event
  */
 interface ContentHookEvent {
+  idempotencyKey?: string;
   /** Persisted item before a successful mutation; absent for creations and before hooks. */
   previousContent?: Record<string, unknown>;
   content: Record<string, unknown>;
@@ -7590,6 +7643,7 @@ interface ContentHookEvent {
  * Content delete hook event
  */
 interface ContentDeleteEvent {
+  idempotencyKey?: string;
   /** Persisted item before a successful mutation; absent for creations and before hooks. */
   previousContent?: Record<string, unknown>;
   id: string;
@@ -7600,6 +7654,7 @@ interface ContentDeleteEvent {
  * Content state change hook event.
  */
 interface ContentStateChangeEvent {
+  idempotencyKey?: string;
   /** Persisted item before a successful mutation; absent for creations and before hooks. */
   previousContent?: Record<string, unknown>;
   content: Record<string, unknown>;
@@ -7852,6 +7907,7 @@ interface ManifestRouteEntry {
  * Resolved hook with normalized config
  */
 interface ResolvedHook<THandler> {
+  idempotent?: boolean;
   priority: number;
   timeout: number;
   dependencies: string[];