dineway 0.2.40 → 0.2.42

package/dist/{runner-SoP1rphP.d.mts → runner-DXQkyPeX.d.mts}

@@ -1,4 +1,4 @@
-import { t as Database } from "./types-B--VyN3n.mjs";
+import { n as Database } from "./types-Dpv_MvwZ.mjs";
 import { Kysely } from "kysely";
 
 //#region src/database/migrations/runner.d.ts

package/dist/{runs-BtaAiLTw.mjs → runs-BjgLfqCn.mjs}

@@ -1,8 +1,8 @@
-import { n as decodeBase64url, r as encodeBase64 } from "./base64-Cz-aU0X1.mjs";
-import { i as encodeCursor, r as decodeCursor } from "./types-RFzE_V1M.mjs";
-import { t as buildStableHash } from "./stable-hash-B9Tbb2f_.mjs";
-import { t as DinewayToolsError } from "./service-kQ5ljRzX.mjs";
-import { t as DinewaySecretsError } from "./secrets-D_pergcD.mjs";
+import { n as decodeBase64url, r as encodeBase64 } from "./base64-qvSs0Gxy.mjs";
+import { i as encodeCursor, r as decodeCursor } from "./types-BI3ULB3A.mjs";
+import { t as buildStableHash } from "./stable-hash-9RDJgfif.mjs";
+import { t as DinewayToolsError } from "./service-DeX1PRNt.mjs";
+import { t as DinewaySecretsError } from "./secrets-CIYcw9T9.mjs";
 import { z } from "zod";
 import MiniSearch from "minisearch";
 

package/dist/runtime-Bs2JMbb2.d.mts

@@ -0,0 +1,45 @@
+import { AtomicBatch } from "./database/batch.mjs";
+import { a as ContentStorageActivation, d as ContentStore, p as PreparedContentVersion, r as ContentPartitionResolver, s as ContentStorageConfig, t as ContentLocation } from "./types-qOEot0UQ.mjs";
+import { n as ContentStorageHookName, r as ContentStorageHookTarget } from "./hook-events-BQw73jc7.mjs";
+import { Kysely } from "kysely";
+
+//#region src/content-storage/coordinator.d.ts
+/** Run only during explicit deployment or migration, before serving requests. */
+declare function installContentStorageConfig<DB>(db: Kysely<DB>, config: ContentStorageConfig, options?: {
+  initial?: "primary" | "configured";
+}): Promise<void>;
+declare class ContentStorageCoordinator<DB> {
+  private readonly db;
+  private readonly config;
+  private readonly stores;
+  private readonly resolvers;
+  private readonly configDigest;
+  constructor(db: Kysely<DB>, config: ContentStorageConfig, stores: Readonly<Record<string, ContentStore>>, resolvers?: Readonly<Record<string, ContentPartitionResolver>>);
+  locate(collection: string, entryId: string): Promise<ContentLocation | null>;
+  read(collection: string, entryId: string): Promise<PreparedContentVersion | null>;
+  /** Locations come from the same directory query that selected and paginated the entries. */
+  readLocations(locations: readonly ContentLocation[], fields?: readonly string[]): Promise<PreparedContentVersion[]>;
+  commit(version: PreparedContentVersion, activation: ContentStorageActivation): Promise<ContentLocation>;
+  /** Stage remotely, then compose this activation with other primary-database business writes. */
+  prepareCommit(version: PreparedContentVersion, activation: ContentStorageActivation): Promise<AtomicBatch>;
+  private operation;
+}
+//#endregion
+//#region src/content-storage/runtime.d.ts
+interface ContentStorageRuntime {
+  config: ContentStorageConfig;
+  createStores(primary: boolean): Record<string, ContentStore>;
+  resolvers: Record<string, ContentPartitionResolver>;
+  hookTargets?: (names: readonly ContentStorageHookName[]) => readonly ContentStorageHookTarget[];
+}
+declare function registerContentStorage<DB>(db: Kysely<DB>, runtime: ContentStorageRuntime): void;
+declare function assertContentStorageConfiguration<DB>(db: Kysely<DB>, config?: ContentStorageConfig): Promise<void>;
+declare function getContentStorage<DB>(db: Kysely<DB>, collection: string): {
+  runtime: ContentStorageRuntime;
+  stores: Record<string, ContentStore>;
+  coordinator: ContentStorageCoordinator<DB>;
+} | undefined;
+/** Resolve a bounded primary-index page in bulk, retaining the selected metadata and order. */
+declare function hydrateContentRows<DB>(db: Kysely<DB>, collection: string, rows: Record<string, unknown>[], fields?: readonly string[]): Promise<void>;
+//#endregion
+export { registerContentStorage as a, hydrateContentRows as i, assertContentStorageConfiguration as n, ContentStorageCoordinator as o, getContentStorage as r, installContentStorageConfig as s, ContentStorageRuntime as t };

package/dist/runtime-Ch5G-tnG.mjs

@@ -0,0 +1,400 @@
+import { getRequestContext } from "./request-context.mjs";
+import { atomicBatch, rowUnchanged } from "./database/batch.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 { sql } from "kysely";
+
+//#region src/content-storage/change-journal.ts
+/** Installed explicitly with routing; triggers also capture composed metadata writes and deletion. */
+async function prepareContentChangeJournal(db, collection) {
+	const sources = [
+		{
+			table: `ec_${collection}`,
+			entry: "id",
+			collection: null
+		},
+		{
+			table: "revisions",
+			entry: "entry_id",
+			collection: "collection"
+		},
+		{
+			table: "content_taxonomies",
+			entry: "entry_id",
+			collection: "collection"
+		},
+		{
+			table: "_dineway_content_bylines",
+			entry: "content_id",
+			collection: "collection_slug"
+		},
+		{
+			table: "_dineway_seo",
+			entry: "content_id",
+			collection: "collection"
+		}
+	];
+	const statements = [];
+	for (const source of sources) {
+		if (!(await sql`SELECT 1 FROM sqlite_master WHERE type='table' AND name=${source.table}`.execute(db)).rows.length) continue;
+		for (const action of [
+			"INSERT",
+			"UPDATE",
+			"DELETE"
+		]) {
+			const row = action === "DELETE" ? "OLD" : "NEW";
+			const name = `content_changes_${collection}_${source.table}_${action.toLowerCase()}`;
+			statements.push(sql`CREATE TRIGGER IF NOT EXISTS ${sql.ref(name)} AFTER ${sql.raw(action)} ON ${sql.table(source.table)}
+				${source.collection ? sql`WHEN ${sql.ref(`${row}.${source.collection}`)}=${sql.lit(collection)}` : sql``}
+				BEGIN INSERT INTO _dineway_content_changes (collection,entry_id,source,action,changed_at)
+				VALUES (${sql.lit(collection)},${sql.ref(`${row}.${source.entry}`)},${sql.lit(source.table)},${sql.lit(action.toLowerCase())},strftime('%Y-%m-%dT%H:%M:%fZ','now')); END`.compile(db));
+		}
+	}
+	return statements;
+}
+function contentChangeSequence(collection, entryId) {
+	return sql`(SELECT COALESCE(MAX(sequence),0) FROM _dineway_content_changes WHERE collection=${collection} AND entry_id=${entryId})`;
+}
+
+//#endregion
+//#region src/content-storage/routing.ts
+const MIGRATION_ID = /^[a-zA-Z0-9_-]{1,128}$/;
+async function readContentPartitionRoute(db, collection, partition) {
+	const row = (await sql`SELECT * FROM _dineway_content_partitions WHERE collection = ${collection} AND partition = ${partition}`.execute(db)).rows[0];
+	if (!row) throw new ContentStorageError("ROUTE_CHANGED", "The content partition has not been installed.");
+	return {
+		route: row,
+		check: rowUnchanged("_dineway_content_partitions", { ...row })
+	};
+}
+/** Also fences metadata-only operations, such as trash, scheduling and review activation. */
+function contentPartitionWritable(collection, id) {
+	return sql`NOT EXISTS (SELECT 1 FROM _dineway_content_locations l JOIN _dineway_content_partitions p ON p.collection = l.collection AND p.partition = l.partition WHERE l.collection = ${collection} AND l.entry_id = ${id} AND p.state = 'frozen')`;
+}
+/** Starts copying while the partition remains writable on its current store. */
+async function beginContentMigration(db, config, migration) {
+	if (!MIGRATION_ID.test(migration.id)) throw new ContentStorageError("CONFLICT", "A stable migration identifier is required.");
+	const current = await readContentPartitionRoute(db, migration.collection, migration.partition);
+	if (current.route.migration_id === migration.id && current.route.state !== "active") return current.route;
+	const target = config.rules[migration.collection]?.stores[migration.partition];
+	if (!target || current.route.store === target || current.route.state !== "active" || current.route.migration_id) throw new ContentStorageError("CONFLICT", "The partition cannot start this migration.");
+	await atomicBatch(db, {
+		checks: [current.check, sql`EXISTS (SELECT 1 FROM _dineway_content_storage_config WHERE id='active' AND version=${config.version} AND digest=${await contentDigest(config)})`],
+		statements: [sql`INSERT INTO _dineway_content_migrations (id, collection, partition, source_store, target_store, routing_version, state, created_at, updated_at, retain_until) VALUES (${migration.id}, ${migration.collection}, ${migration.partition}, ${current.route.store}, ${target}, ${config.version}, 'copying', ${(/* @__PURE__ */ new Date()).toISOString()}, ${(/* @__PURE__ */ new Date()).toISOString()}, ${new Date(Date.now() + 7 * 864e5).toISOString()})`.compile(db), sql`UPDATE _dineway_content_partitions SET state='copying', migration_id=${migration.id}, target_store=${target}, epoch=epoch+1, updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE collection=${migration.collection} AND partition=${migration.partition}`.compile(db)]
+	});
+	return (await readContentPartitionRoute(db, migration.collection, migration.partition)).route;
+}
+/** Epoch fencing makes all previously prepared writes fail before primary activation. */
+async function freezeContentPartition(db, migration) {
+	const current = await readContentPartitionRoute(db, migration.collection, migration.partition);
+	if (current.route.migration_id !== migration.id || !["copying", "frozen"].includes(current.route.state)) throw new ContentStorageError("CONFLICT", "The migration does not own this partition.");
+	if (current.route.state === "frozen") return current.route;
+	await atomicBatch(db, {
+		checks: [current.check, sql`NOT EXISTS (SELECT 1 FROM ${sql.table(`ec_${migration.collection}`)} c WHERE NOT EXISTS (SELECT 1 FROM _dineway_content_locations l WHERE l.collection=${migration.collection} AND l.entry_id=c.id))`],
+		statements: [
+			sql`UPDATE _dineway_content_migrations SET state='frozen', updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE id=${migration.id}`.compile(db),
+			sql`UPDATE _dineway_content_partitions SET state='frozen', epoch=epoch+1, updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE collection=${migration.collection} AND partition=${migration.partition}`.compile(db),
+			sql`UPDATE _dineway_content_operations SET state='aborted', updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE collection=${migration.collection} AND state='pending' AND json_extract(command, '$.partition')=${migration.partition}`.compile(db)
+		]
+	});
+	return (await readContentPartitionRoute(db, migration.collection, migration.partition)).route;
+}
+/** Resume the old store only while every entry still points to it. */
+async function cancelContentMigration(db, migration) {
+	const current = await readContentPartitionRoute(db, migration.collection, migration.partition);
+	if (current.route.migration_id !== migration.id || current.route.state === "active") throw new ContentStorageError("CONFLICT", "The migration does not own this partition.");
+	await atomicBatch(db, {
+		checks: [current.check, sql`NOT EXISTS (SELECT 1 FROM _dineway_content_locations WHERE collection=${migration.collection} AND partition=${migration.partition} AND store<>${current.route.store})`],
+		statements: [sql`UPDATE _dineway_content_migrations SET state='cancelled', updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE id=${migration.id}`.compile(db), sql`UPDATE _dineway_content_partitions SET state='active', migration_id=NULL, epoch=epoch+1, updated_at=${(/* @__PURE__ */ new Date()).toISOString()} WHERE collection=${migration.collection} AND partition=${migration.partition}`.compile(db)]
+	});
+}
+
+//#endregion
+//#region src/content-storage/coordinator.ts
+const locationKey = (location) => JSON.stringify([
+	location.collection,
+	location.entryId,
+	location.store,
+	location.partition,
+	location.routingVersion,
+	location.version,
+	location.digest
+]);
+/** Run only during explicit deployment or migration, before serving requests. */
+async function installContentStorageConfig(db, config, options = {}) {
+	validateContentStorage(config);
+	const digest = await contentDigest(config);
+	const checks = [];
+	const statements = [];
+	for (const collection of Object.keys(config.rules)) statements.push(...await prepareContentChangeJournal(db, collection));
+	if (!((await sql`SELECT 1 FROM _dineway_content_storage_config WHERE id = 'active'`.execute(db)).rows.length > 0)) for (const [collection, rule] of Object.entries(config.rules)) {
+		if (options.initial !== "primary") {
+			if ((await sql`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ${`ec_${collection}`}`.execute(db)).rows.length > 0) checks.push(sql`NOT EXISTS (SELECT 1 FROM ${sql.table(`ec_${collection}`)})`);
+		}
+		for (const [partition, target] of Object.entries(rule.stores)) statements.push(sql`INSERT INTO _dineway_content_partitions (collection, partition, store, target_store, state, epoch, migration_id, updated_at) VALUES (${collection}, ${partition}, ${options.initial === "primary" ? "primary" : target}, ${target}, 'active', 1, NULL, ${(/* @__PURE__ */ new Date()).toISOString()})`.compile(db));
+	}
+	await atomicBatch(db, {
+		checks: [...checks, sql`NOT EXISTS (SELECT 1 FROM _dineway_content_storage_config WHERE id = 'active' AND (version <> ${config.version} OR digest <> ${digest}))`],
+		statements: [...statements, sql`INSERT INTO _dineway_content_storage_config (id, version, digest) VALUES ('active', ${config.version}, ${digest}) ON CONFLICT (id) DO NOTHING`.compile(db)]
+	});
+}
+var ContentStorageCoordinator = class {
+	configDigest;
+	constructor(db, config, stores, resolvers = {}) {
+		this.db = db;
+		this.config = config;
+		this.stores = stores;
+		this.resolvers = resolvers;
+		validateContentStorage(config);
+		for (const name of Object.keys(config.stores)) if (!Object.hasOwn(stores, name)) throw new ContentStorageError("INVALID_CONFIG", `Content store ${name} is not loaded.`);
+		this.configDigest = contentDigest(config);
+	}
+	async locate(collection, entryId) {
+		const row = (await sql`SELECT collection, entry_id, store, partition, routing_version, version, digest FROM _dineway_content_locations WHERE collection = ${collection} AND entry_id = ${entryId}`.execute(this.db)).rows[0];
+		if (!row) return null;
+		return {
+			collection: row.collection,
+			entryId: row.entry_id,
+			store: row.store,
+			partition: row.partition,
+			routingVersion: row.routing_version,
+			version: row.version,
+			digest: row.digest
+		};
+	}
+	async read(collection, entryId) {
+		const location = await this.locate(collection, entryId);
+		if (!location) return null;
+		return (await this.readLocations([location]))[0] ?? null;
+	}
+	/** Locations come from the same directory query that selected and paginated the entries. */
+	async readLocations(locations, fields) {
+		const groups = /* @__PURE__ */ new Map();
+		for (const location of locations) {
+			const group = groups.get(location.store) ?? /* @__PURE__ */ new Map();
+			group.set(locationKey(location), location);
+			groups.set(location.store, group);
+		}
+		const result = /* @__PURE__ */ new Map();
+		const entries = [...groups];
+		for (let groupOffset = 0; groupOffset < entries.length; groupOffset += 4) await Promise.all(entries.slice(groupOffset, groupOffset + 4).map(async ([name, group]) => {
+			const store = this.stores[name];
+			if (!store) throw new ContentStorageError("UNAVAILABLE", "The content store is unavailable; the primary database is not a fallback.");
+			const requested = [...group.values()];
+			for (let offset = 0; offset < requested.length; offset += 16) {
+				const batch = requested.slice(offset, offset + 16);
+				const expected = new Set(batch.map(locationKey));
+				const values = await store.read(batch, fields);
+				for (const value of values) {
+					const identity = locationKey(value.command);
+					if (!expected.delete(identity) || (fields ? Object.keys(value.data).some((field) => !fields.includes(field)) : await contentDigest(value.data) !== value.command.digest)) throw new ContentStorageError("UNAVAILABLE", "The committed content version could not be verified.");
+					result.set(identity, value);
+				}
+				if (expected.size) throw new ContentStorageError("UNAVAILABLE", "The content store did not return all committed versions.");
+			}
+		}));
+		return locations.map((location) => result.get(locationKey(location)));
+	}
+	async commit(version, activation) {
+		let batch;
+		try {
+			batch = await this.prepareCommit(version, activation);
+		} catch (error) {
+			if (error instanceof ContentStorageReplay) return error.location;
+			throw error;
+		}
+		try {
+			await atomicBatch(this.db, batch);
+		} catch (error) {
+			const outcome = await this.operation(version.command.operationId);
+			if (outcome?.state !== "committed" || outcome.command !== canonicalContentJson(version.command)) throw error;
+		}
+		return version.command;
+	}
+	/** Stage remotely, then compose this activation with other primary-database business writes. */
+	async prepareCommit(version, activation) {
+		const { command, data } = version;
+		const partition = await readContentPartitionRoute(this.db, command.collection, command.partition);
+		if (partition.route.state === "frozen" || partition.route.store !== command.store || partition.route.epoch !== (command.partitionEpoch ?? 1)) throw new ContentStorageError("ROUTE_CHANGED", "The content partition is migrating or its route has changed.");
+		if (!command.operationId || !command.version || !command.principalId || !command.entryId) throw new ContentStorageError("CONFLICT", "Content writes require stable operation, principal, entry and version identifiers.");
+		if (command.version === command.expectedVersion) throw new ContentStorageError("CONFLICT", "A write must create a new immutable version.");
+		if (command.routingVersion !== this.config.version) throw new ContentStorageError("ROUTE_CHANGED", "The content routing version has changed.");
+		const destination = await resolveContentPartition(this.config, {
+			collection: command.collection,
+			id: command.entryId,
+			data
+		}, this.resolvers);
+		if (!destination || destination.store !== partition.route.target_store || destination.partition !== command.partition) throw new ContentStorageError("INVALID_PARTITION", "The write does not match its configured content partition.");
+		if (await contentDigest(data) !== command.digest) throw new ContentStorageError("CONFLICT", "Content does not match its prepared digest.");
+		const serialized = canonicalContentJson(command);
+		const existing = await this.operation(command.operationId);
+		if (existing && existing.command !== serialized) throw new ContentStorageError("CONFLICT", "An operation identifier cannot be reused for different content or authority.");
+		const routeCheck = sql`(${partition.check}) AND EXISTS (SELECT 1 FROM _dineway_content_storage_config WHERE id = 'active' AND version = ${this.config.version} AND digest = ${await this.configDigest})`;
+		const authority = await activation.authorize(command);
+		if (existing?.state === "committed") {
+			await atomicBatch(this.db, {
+				checks: [routeCheck, ...authority],
+				statements: []
+			});
+			throw new ContentStorageReplay(command);
+		}
+		const locationCheck = command.expectedVersion === null ? sql`NOT EXISTS (SELECT 1 FROM _dineway_content_locations WHERE collection = ${command.collection} AND entry_id = ${command.entryId})` : sql`EXISTS (SELECT 1 FROM _dineway_content_locations WHERE collection = ${command.collection} AND entry_id = ${command.entryId} AND version = ${command.expectedVersion})`;
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		try {
+			await atomicBatch(this.db, {
+				checks: [
+					routeCheck,
+					locationCheck,
+					...authority,
+					sql`NOT EXISTS (SELECT 1 FROM _dineway_content_operations WHERE id = ${command.operationId} AND command <> ${serialized})`
+				],
+				statements: [sql`INSERT INTO _dineway_content_operations (id, collection, entry_id, command, state, created_at, updated_at) VALUES (${command.operationId}, ${command.collection}, ${command.entryId}, ${serialized}, 'pending', ${now}, ${now}) ON CONFLICT (id) DO NOTHING`.compile(this.db)]
+			});
+		} catch (error) {
+			const outcome = await this.operation(command.operationId);
+			if (outcome?.state !== "committed" || outcome.command !== serialized) throw error;
+			await atomicBatch(this.db, {
+				checks: [routeCheck, ...await activation.authorize(command)],
+				statements: []
+			});
+			throw new ContentStorageReplay(command);
+		}
+		await this.stores[command.store].prepare(version);
+		const projection = await activation.prepare(command);
+		return {
+			checks: [
+				routeCheck,
+				locationCheck,
+				...await activation.authorize(command),
+				...projection.checks ?? [],
+				sql`EXISTS (SELECT 1 FROM _dineway_content_operations WHERE id = ${command.operationId} AND command = ${serialized} AND state = 'pending')`
+			],
+			statements: [
+				...projection.statements,
+				sql`INSERT INTO _dineway_content_locations (collection, entry_id, store, partition, routing_version, version, digest) VALUES (${command.collection}, ${command.entryId}, ${command.store}, ${command.partition}, ${command.routingVersion}, ${command.version}, ${command.digest}) ON CONFLICT (collection, entry_id) DO UPDATE SET store = excluded.store, partition = excluded.partition, routing_version = excluded.routing_version, version = excluded.version, digest = excluded.digest`.compile(this.db),
+				sql`UPDATE _dineway_content_operations SET state = 'committed', updated_at = ${now} WHERE id = ${command.operationId}`.compile(this.db),
+				sql`INSERT INTO _dineway_content_commit_events (operation_id, collection, entry_id, command, created_at) VALUES (${command.operationId}, ${command.collection}, ${command.entryId}, ${serialized}, ${now}) ON CONFLICT (operation_id) DO NOTHING`.compile(this.db)
+			]
+		};
+	}
+	async operation(id) {
+		return (await sql`SELECT command, state FROM _dineway_content_operations WHERE id = ${id}`.execute(this.db)).rows[0];
+	}
+};
+
+//#endregion
+//#region src/content-storage/system-fields.ts
+/** Primary directory metadata cannot be overwritten by a remote content payload. */
+const CONTENT_SYSTEM_FIELDS = new Set([
+	"id",
+	"slug",
+	"status",
+	"author_id",
+	"primary_byline_id",
+	"created_at",
+	"updated_at",
+	"published_at",
+	"scheduled_at",
+	"deleted_at",
+	"version",
+	"live_revision_id",
+	"draft_revision_id",
+	"locale",
+	"translation_group"
+]);
+
+//#endregion
+//#region src/content-storage/runtime.ts
+const REGISTRY = Symbol.for("dineway:content-storage-runtimes");
+const root = globalThis;
+const runtimes = root[REGISTRY] ??= /* @__PURE__ */ new WeakMap();
+const REQUEST_STORES = Symbol.for("dineway:request-content-stores");
+const requestStores = root[REQUEST_STORES] ??= /* @__PURE__ */ new WeakMap();
+function registerContentStorage(db, runtime) {
+	runtimes.set(db, runtime);
+}
+/** Namespace object-cache values by deployment routing and stable physical identities. */
+function contentStorageCacheScope() {
+	const context = getRequestContext();
+	if (context?.dbIsIsolated) return "";
+	const database = context?.primaryDb ?? context?.db;
+	const config = (database && typeof database === "object" ? runtimes.get(database) : void 0)?.config ?? globalThis.__dinewayConfig?.contentStorage;
+	if (!config) return "";
+	return canonicalContentJson({
+		version: config.version,
+		stores: Object.fromEntries(Object.entries(config.stores).map(([name, store]) => [name, store.identity]))
+	});
+}
+async function assertContentStorageConfiguration(db, config) {
+	const row = (await sql`SELECT version, digest FROM _dineway_content_storage_config WHERE id = 'active'`.execute(db)).rows[0];
+	if (!config && !row) return;
+	if (!config || !row || row.version !== config.version || row.digest !== await contentDigest(config)) throw new ContentStorageError("UNAVAILABLE", "Content routing configuration does not match the installed database configuration. Apply the explicit content storage migration before serving requests.");
+}
+function getContentStorageRuntime(db) {
+	const context = getRequestContext();
+	if (context?.dbIsIsolated) return void 0;
+	const primary = context?.primaryDb;
+	return runtimes.get(db) ?? (typeof primary === "object" && primary !== null ? runtimes.get(primary) : void 0);
+}
+function getContentStorage(db, collection) {
+	const context = getRequestContext();
+	const runtime = getContentStorageRuntime(db);
+	if (!runtime || !Object.hasOwn(runtime.config.rules, collection)) return void 0;
+	let stores = context ? requestStores.get(context)?.get(runtime) : void 0;
+	if (!stores) {
+		stores = runtime.createStores(context?.databaseMode === "primary" || !!context?.writePrincipal);
+		if (context) {
+			let entries = requestStores.get(context);
+			if (!entries) {
+				entries = /* @__PURE__ */ new Map();
+				requestStores.set(context, entries);
+			}
+			entries.set(runtime, stores);
+		}
+	}
+	return {
+		runtime,
+		stores,
+		coordinator: new ContentStorageCoordinator(db, runtime.config, stores, runtime.resolvers)
+	};
+}
+/** Resolve a bounded primary-index page in bulk, retaining the selected metadata and order. */
+async function hydrateContentRows(db, collection, rows, fields) {
+	const storage = getContentStorage(db, collection);
+	if (!storage || !rows.length) return;
+	const byId = new Map(rows.filter((row) => typeof row.id === "string").map((row) => [String(row.id), row]));
+	const ids = [...byId.keys()];
+	const locations = [];
+	for (let offset = 0; offset < ids.length; offset += 80) {
+		const result = await sql`SELECT l.collection, l.entry_id, l.store, l.partition, l.routing_version, l.version, l.digest, c.version AS _entry_version, c.updated_at AS _entry_updated_at, c.status AS _entry_status, c.deleted_at AS _entry_deleted_at FROM _dineway_content_locations l JOIN ${sql.table(`ec_${collection}`)} c ON c.id = l.entry_id WHERE l.collection = ${collection} AND l.entry_id IN (${sql.join(ids.slice(offset, offset + 80))})`.execute(db);
+		for (const location of result.rows) {
+			const previous = byId.get(location.entry_id);
+			if (previous.version !== location._entry_version || [
+				"updated_at",
+				"status",
+				"deleted_at"
+			].some((field) => Object.hasOwn(previous, field) && previous[field] !== Reflect.get(location, `_entry_${field}`))) throw new ContentStorageError("CONFLICT", "The content index changed while loading its stored version. Retry the read.");
+		}
+		locations.push(...result.rows.filter((row) => row.store !== "primary").map((row) => ({
+			collection: row.collection,
+			entryId: row.entry_id,
+			store: row.store,
+			partition: row.partition,
+			routingVersion: row.routing_version,
+			version: row.version,
+			digest: row.digest
+		})));
+	}
+	const versions = await storage.coordinator.readLocations(locations, fields?.filter((field) => !CONTENT_SYSTEM_FIELDS.has(field) && !field.startsWith("_")));
+	const byEntry = new Map(versions.map((version) => [version.command.entryId, version]));
+	for (const row of rows) {
+		const version = byEntry.get(String(row.id));
+		if (!version) continue;
+		for (const [field, value] of Object.entries(version.data)) {
+			if (field.startsWith("_") || CONTENT_SYSTEM_FIELDS.has(field) || fields && !fields.includes(field)) continue;
+			row[field] = value;
+		}
+	}
+}
+
+//#endregion
+export { hydrateContentRows as a, installContentStorageConfig as c, contentPartitionWritable as d, freezeContentPartition as f, prepareContentChangeJournal as h, getContentStorageRuntime as i, beginContentMigration as l, contentChangeSequence as m, contentStorageCacheScope as n, registerContentStorage as o, readContentPartitionRoute as p, getContentStorage as r, ContentStorageCoordinator as s, assertContentStorageConfiguration as t, cancelContentMigration as u };

package/dist/runtime.d.mts

@@ -1,14 +1,17 @@
-import { $s as getDb, Js as EntryData, Qs as dinewayLoader, Ys as EntryFilter, qs as CollectionFilter } from "./types-D5JfvPvx.mjs";
-import "./types-B--VyN3n.mjs";
-import "./runner-SoP1rphP.mjs";
-import "./index-BVGe04wF.mjs";
-import "./types-B03h5jt_.mjs";
-import "./adapters-C8nRpUuj.mjs";
-import "./scheduled-publish-BxdShRGs.mjs";
-import "./public-url-Ccv0Xmue.mjs";
-import "./validate-kmN2lS8H.mjs";
-import "./byline-fields-D-b9CWux.mjs";
+import { $s as getDb, Js as EntryData, Qs as dinewayLoader, Ys as EntryFilter, qs as CollectionFilter } from "./types-0gRlZbhN.mjs";
+import "./types-Dpv_MvwZ.mjs";
+import "./runner-DXQkyPeX.mjs";
+import "./index-CLj17kW9.mjs";
+import "./types-qOEot0UQ.mjs";
+import "./types-DheoByey.mjs";
+import "./adapters-lDnJjNDz.mjs";
+import "./runtime-Bs2JMbb2.mjs";
+import "./hook-events-BQw73jc7.mjs";
+import "./scheduled-publish-eCNGpvNm.mjs";
+import "./public-url-CEC1vj02.mjs";
+import "./validate-DUscf6VG.mjs";
+import "./byline-fields-B7pQ3LMi.mjs";
 import { withPrimaryDatabase } from "./request-context.mjs";
-import "./types-DsJTXStN.mjs";
-import { t as getMediaProvider } from "./provider-loader-DT7vQ5FI.mjs";
+import "./types-BJztoTbF.mjs";
+import { t as getMediaProvider } from "./provider-loader-oLKm1AU8.mjs";
 export { type CollectionFilter, type EntryData, type EntryFilter, dinewayLoader, getDb, getMediaProvider, withPrimaryDatabase };

package/dist/runtime.mjs

@@ -1,8 +1,13 @@
 import { withPrimaryDatabase } from "./request-context.mjs";
+import "./d1-binding-DrLMBUxu.mjs";
 import "./dialect-helpers-C6xtO-Ui.mjs";
-import "./base64-Cz-aU0X1.mjs";
-import "./types-RFzE_V1M.mjs";
-import { n as dinewayLoader, r as getDb } from "./loader-Dp6zLmQm.mjs";
-import { t as getMediaProvider } from "./provider-loader-DERzBMUz.mjs";
+import "./config-6R0bchVE.mjs";
+import "./runtime-Ch5G-tnG.mjs";
+import "./revisions-qNkae-Dq.mjs";
+import "./runtime-env-DpYGy4pT.mjs";
+import "./base64-qvSs0Gxy.mjs";
+import "./types-BI3ULB3A.mjs";
+import { n as dinewayLoader, r as getDb } from "./loader-Bq1aW12P.mjs";
+import { t as getMediaProvider } from "./provider-loader-DlaT1usE.mjs";
 
 export { dinewayLoader, getDb, getMediaProvider, withPrimaryDatabase };

package/dist/schema-DVeOJpqA.mjs

@@ -0,0 +1,8 @@
+import { c as __exportAll } from "./runner-CuG8o1uW.mjs";
+import { n as SchemaRegistry } from "./registry-B-HULaJI.mjs";
+
+//#region src/schema/index.ts
+var schema_exports = /* @__PURE__ */ __exportAll({ SchemaRegistry: () => SchemaRegistry });
+
+//#endregion
+export { schema_exports as t };

package/dist/{search-BI9uKr7U.mjs → search-zMoM2_uq.mjs}

@@ -1,9 +1,8 @@
-import { c as __exportAll } from "./runner-CRU7BXjr.mjs";
+import { c as __exportAll } from "./runner-CuG8o1uW.mjs";
 import { t as validateIdentifier } from "./validate-Co3j6T_K.mjs";
-import { r as getDb } from "./loader-Dp6zLmQm.mjs";
-import { t as FTSManager } from "./fts-manager-BrPpYtK0.mjs";
+import { r as getDb } from "./loader-Bq1aW12P.mjs";
+import { t as FTSManager } from "./fts-manager-Zu5ITic0.mjs";
 import { sql } from "kysely";
-import { toPlainText } from "@portabletext/toolkit";
 
 //#region src/search/query.ts
 /** Pattern to split on whitespace for query term extraction */
@@ -238,102 +237,9 @@ function escapeQuery(query) {
 	return terms.map((t) => `"${t}"*`).join(" ");
 }
 
-//#endregion
-//#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
 //#region src/search/index.ts
 var search_exports = /* @__PURE__ */ __exportAll({ searchWithDb: () => searchWithDb });
 
 //#endregion
-export { getSuggestions as a, searchWithDb as c, getSearchStats as i, extractPlainText as n, search as o, extractSearchableFields as r, searchCollection as s, search_exports as t };
+export { searchCollection as a, search as i, getSearchStats as n, searchWithDb as o, getSuggestions as r, search_exports as t };