@hot-updater/server 1.0.0-rc.18 → 1.0.0-rc.21

package/dist/database/kv/kvAdapter.mjs

@@ -1,284 +0,0 @@
-import { DATABASE_VERSION_COLUMN, DatabaseAdapterContractError, canonicalJson, compareUtf8, expiresAt, findPhysicalIndex, indexEntries, indexOrderColumns, indexOrderTuple, matchesQuery, rowKey } from "@hot-updater/plugin-core/internal";
-//#region src/database/kv/kvAdapter.ts
-const SEPARATOR = "
";
-/** Order-preserving text for key values; each value ends in the lowest code point any encoding uses. */
-const encodeKvKey = (values) => values.map((value) => {
-	if (typeof value === "boolean") return `${Number(value)}${SEPARATOR}`;
-	if (typeof value === "number") {
-		const view = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
-		view.setFloat64(0, value === 0 ? 0 : value);
-		const mask = view.getUint32(0) >>> 31 ? [-1, -1] : [1 << 31, 0];
-		return `${[0, 4].map((at, word) => ((view.getUint32(at) ^ mask[word]) >>> 0).toString(16).padStart(8, "0")).join("")}${SEPARATOR}`;
-	}
-	let text = "";
-	for (const char of value) text += char < "" ? `\u0002${String.fromCharCode(char.charCodeAt(0) + 1)}` : char;
-	return `${text}${SEPARATOR}`;
-}).join("");
-/** The first sort key after every key that starts with `prefix`. */
-const pastPrefix = (prefix) => `${prefix.slice(0, -1)}\u0002`;
-/** A unique item's sort key, and an index item's when its order is empty. */
-const ONLY = "#";
-/** An index whose eq and order columns are the key, in order, reads the row items. */
-const inKeyOrder = (table, index) => {
-	const columns = [...index.eq, ...indexOrderColumns(table, index)];
-	return !index.unique && columns.length === table.key.length && columns.every((column, position) => column === table.key[position]);
-};
-const same = (left, right, columns) => columns.every((name) => canonicalJson(left[name]) === canonicalJson(right[name]));
-/**
-* The storage adapter over a key-value store. A row is one item at
-* `pk = <table>`, `sk = enc(key)`; each index not in key order adds an item
-* per entry at `pk = <table>#<index>#enc(eq)`, `sk = enc(order)`, and each
-* unique entry one item at `sk = "#"`, written only where no other row holds
-* it. Index items hold a copy of the row without `_v` or counters, so an
-* increment, which changes only those, never makes them stale.
-*/
-const createKvAdapter = ({ store, tablePrefix = "" }) => {
-	const layouts = /* @__PURE__ */ new WeakMap();
-	const layoutOf = (table) => {
-		const known = layouts.get(table);
-		if (known) return known;
-		const counters = table.columns.filter((column) => column.default !== void 0 && column.name !== DATABASE_VERSION_COLUMN).map((column) => column.name);
-		const layout = {
-			table,
-			rows: tablePrefix + table.name,
-			copied: table.columns.map((column) => column.name).filter((name) => name !== DATABASE_VERSION_COLUMN && !counters.includes(name)),
-			counters,
-			indexed: table.indexes.filter((index) => !inKeyOrder(table, index))
-		};
-		layouts.set(table, layout);
-		return layout;
-	};
-	const rowItem = (layout, key) => ({
-		pk: layout.rows,
-		sk: encodeKvKey(key)
-	});
-	const partition = (layout, index, eq) => `${layout.rows}#${index.name}#${encodeKvKey(eq)}`;
-	const copyOf = (layout, row) => Object.fromEntries(layout.copied.map((name) => [name, row[name] ?? null]));
-	/** The expiry every item of `row` carries, for a table with retention. */
-	const stamp = (table, row) => {
-		const at = row && expiresAt(table, row);
-		return at === void 0 ? {} : { expiresAt: at };
-	};
-	/** Every index and unique item a row has, by address. */
-	const itemsOf = (layout, row) => {
-		const items = /* @__PURE__ */ new Map();
-		for (const index of row === null ? [] : layout.indexed) for (const eq of indexEntries(layout.table, index, row)) {
-			const pk = partition(layout, index, eq);
-			const sk = index.unique ? ONLY : encodeKvKey(indexOrderTuple(layout.table, index, row)) || ONLY;
-			items.set(JSON.stringify([pk, sk]), {
-				key: {
-					pk,
-					sk
-				},
-				unique: index.unique === true
-			});
-		}
-		return items;
-	};
-	/** Moves a row's index items from `before` to `after`; a unique entry is taken only where no row holds it. */
-	const indexOps = (layout, before, after) => {
-		const old = itemsOf(layout, before);
-		const next = itemsOf(layout, after);
-		const ops = [...old].filter(([id]) => !next.has(id)).map(([, item]) => ({
-			type: "delete",
-			key: item.key
-		}));
-		const copy = after && copyOf(layout, after);
-		const unchanged = before !== null && copy !== null && same(before, copy, layout.copied);
-		for (const [id, item] of next) {
-			if (old.has(id) && unchanged) continue;
-			const taken = item.unique && !old.has(id);
-			ops.push({
-				type: "put",
-				key: item.key,
-				value: copy,
-				condition: taken ? { exists: false } : void 0,
-				...stamp(layout.table, after)
-			});
-		}
-		return ops;
-	};
-	/** The item ops of one adapter op: its row item first, then its index items. */
-	const plan = (op) => {
-		const layout = layoutOf(op.table);
-		const key = rowItem(layout, op.type === "insert" ? rowKey(op.table, op.row) : op.key);
-		const guard = op.type === "insert" ? { exists: false } : op.guard;
-		const condition = guard && ("v" in guard ? { v: guard.v } : guard);
-		switch (op.type) {
-			case "check": return [{
-				type: "check",
-				key,
-				condition
-			}];
-			case "increment":
-				if (layout.indexed.length > 0 && (op.init !== void 0 || Object.keys(op.by).some((name) => layout.copied.includes(name)))) throw new DatabaseAdapterContractError(`${op.table.name} has index copies: an increment may change only counters of an existing row.`);
-				return [{
-					type: "add",
-					key,
-					by: {
-						...op.by,
-						[DATABASE_VERSION_COLUMN]: 1
-					},
-					init: op.init,
-					condition: condition ?? (op.init ? void 0 : { exists: true }),
-					...stamp(op.table, op.init)
-				}];
-			case "delete": return [{
-				type: "delete",
-				key,
-				condition
-			}, ...indexOps(layout, op.previous, null)];
-			default: {
-				const before = op.type === "insert" ? null : op.previous;
-				const row = op.type === "insert" ? op.row : {
-					...op.previous,
-					...op.set,
-					[DATABASE_VERSION_COLUMN]: op.guard.v + 1
-				};
-				return [{
-					type: "put",
-					key,
-					value: row,
-					condition,
-					...stamp(op.table, row)
-				}, ...indexOps(layout, before, row)];
-			}
-		}
-	};
-	/**
-	* One op per item. Only unique items of two rows can meet: one op frees
-	* the value and another takes it. That becomes one unconditional put, as
-	* the freeing op's guard already holds the value's owner. Two rows taking
-	* one value fail at the later op.
-	*/
-	const compile = (ops) => {
-		const items = /* @__PURE__ */ new Map();
-		for (const [origin, op] of ops.entries()) for (const kv of plan(op)) {
-			const id = JSON.stringify([kv.key.pk, kv.key.sk]);
-			const earlier = items.get(id);
-			const put = [earlier, {
-				op: kv,
-				origin
-			}].find((planned) => planned?.op.type === "put");
-			if (earlier === void 0) items.set(id, {
-				op: kv,
-				origin
-			});
-			else if (put?.op.type === "put" && [earlier.op, kv].some(({ type }) => type === "delete")) items.set(id, {
-				op: {
-					...put.op,
-					condition: void 0
-				},
-				origin
-			});
-			else return { failedOp: origin };
-		}
-		return { items: [...items.values()] };
-	};
-	const encoder = new TextEncoder();
-	const sizeOf = ({ op }) => encoder.encode(op.key.pk + op.key.sk + JSON.stringify(op.type === "put" ? op.value : op.type === "add" ? op.init : null)).length;
-	/** Fills counters from the rows; a row that still equals its copy is returned whole, `_v` included. */
-	const complete = async (layout, copies) => {
-		if (layout.counters.length === 0 || copies.length === 0) return copies;
-		const rows = await store.get(copies.map((copy) => rowItem(layout, rowKey(layout.table, copy))));
-		return copies.map((copy, at) => {
-			const row = rows[at];
-			if (row && same(row, copy, layout.copied)) return row;
-			const counters = layout.counters.map((name) => [name, row?.[name] ?? 0]);
-			return {
-				...copy,
-				...Object.fromEntries(counters)
-			};
-		});
-	};
-	/**
-	* A request's sort keys within its partition, from `gte` up to `lt`; null
-	* when none can match. Every encoding ends in the separator, so the keys
-	* that start with a prefix end right before `pastPrefix` of it.
-	*/
-	const rangeOf = (prefix, request) => {
-		const edge = (bound, lower) => {
-			if (bound === void 0) return prefix === "" ? void 0 : lower ? prefix : pastPrefix(prefix);
-			const text = prefix + encodeKvKey(bound.values);
-			if (text === "") return bound.inclusive ? void 0 : null;
-			return lower === bound.inclusive ? text : pastPrefix(text);
-		};
-		const gte = edge(request.lower, true);
-		const lt = edge(request.upper, false);
-		if (gte === null || lt === null) return null;
-		if (gte !== void 0 && lt !== void 0 && compareUtf8(gte, lt) >= 0) return null;
-		if (lt === void 0) return {
-			gte,
-			lt
-		};
-		return {
-			gte,
-			lt,
-			lte: lt.endsWith(SEPARATOR) ? lt.slice(0, -1) : lt
-		};
-	};
-	return {
-		id: store.id,
-		fits(ops) {
-			const { items } = compile(ops);
-			if (items === void 0) return true;
-			const { items: most, bytes, itemBytes = bytes, keyBytes } = store.limits;
-			const sizes = items.map(sizeOf);
-			const length = (text) => encoder.encode(text).length;
-			return items.length <= most && sizes.reduce((sum, size) => sum + size, 0) <= bytes && sizes.every((size) => size <= itemBytes) && (keyBytes === void 0 || items.every(({ op }) => length(op.key.pk) <= keyBytes.pk && length(op.key.sk) <= keyBytes.sk));
-		},
-		get: (table, keys) => store.get(keys.map((key) => rowItem(layoutOf(table), key))),
-		async query(table, request) {
-			const layout = layoutOf(table);
-			const index = findPhysicalIndex(table, request.index);
-			if (index.unique) {
-				const key = {
-					pk: partition(layout, index, request.eq),
-					sk: ONLY
-				};
-				const [copy] = await store.get([key]);
-				const found = copy && matchesQuery(table, index, request, copy);
-				return complete(layout, found ? [copy] : []);
-			}
-			const own = inKeyOrder(table, index);
-			const range = rangeOf(own ? encodeKvKey(request.eq) : "", request);
-			if (range === null) return [];
-			const pk = own ? layout.rows : partition(layout, index, request.eq);
-			const rows = [];
-			let after;
-			while (rows.length < request.limit) {
-				const { items, more } = await store.query({
-					pk,
-					...range,
-					order: request.order,
-					limit: request.limit - rows.length,
-					after
-				});
-				rows.push(...items.map((item) => item.value));
-				if (!more || items.length === 0) break;
-				after = items.at(-1).sk;
-			}
-			return own ? rows : complete(layout, rows);
-		},
-		async write(ops) {
-			const { items, failedOp } = compile(ops);
-			if (items === void 0) return {
-				ok: false,
-				failedOp
-			};
-			const result = await store.write(items.map(({ op }) => op));
-			return !result.ok && "failedOp" in result ? {
-				ok: false,
-				failedOp: items[result.failedOp].origin
-			} : result;
-		},
-		...store.deleteConsumed === void 0 ? {} : { deleteConsumed: (table, rows) => {
-			const layout = layoutOf(table);
-			return store.deleteConsumed(rows.flatMap((row) => [rowItem(layout, rowKey(table, row)), ...[...itemsOf(layout, row).values()].map(({ key }) => key)]));
-		} },
-		migrations: { apply: async () => store.migrations?.apply() },
-		...store.dispose === void 0 ? {} : { dispose: () => store.dispose() }
-	};
-};
-//#endregion
-export { createKvAdapter, encodeKvKey };

package/dist/database/resolveSchema.cjs

@@ -1,199 +0,0 @@
-const require_retention = require("./retention.cjs");
-let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
-//#region src/database/resolveSchema.ts
-const SHARD_COLUMN = "_shard";
-const MAX_SHARDS = 64;
-const NAME = /^[a-z][a-z0-9_]*$/u;
-const INDEX_NAME = /^[A-Za-z][A-Za-z0-9_]*$/u;
-const tableName = (module, model) => module.namespace ? `${module.namespace}_${model}` : model;
-const integer = (name, defaulted = false) => ({
-	name,
-	type: "integer",
-	nullable: false,
-	...defaulted ? { default: 0 } : {}
-});
-/** A declared or derived field's type, and whether it holds several values. */
-const fieldType = (model, name) => {
-	const field = model.fields[name] ?? (model.kind === "table" ? model.derived[name] : void 0);
-	return field && {
-		type: field.type,
-		multi: "multi" in field && !!field.multi
-	};
-};
-const metricsOf = (model) => [
-	...model.counters,
-	...model.gauges,
-	...model.distinct
-];
-/** Field names, the key, and each field's options. */
-const fieldProblems = (definition, add) => {
-	const names = [...Object.keys(definition.fields), ...definition.kind === "table" ? Object.keys(definition.derived) : metricsOf(definition)];
-	for (const name of new Set(names)) {
-		if (!NAME.test(name)) add(`field "${name}" must match ${NAME.source}`);
-		if (names.indexOf(name) !== names.lastIndexOf(name)) add(`field "${name}" is declared twice`);
-	}
-	const { key } = definition;
-	if (key.length === 0) add("key is empty");
-	if (new Set(key).size !== key.length) add("key repeats a field");
-	for (const name of key) {
-		const field = definition.fields[name];
-		if (field === void 0) add(`key field "${name}" is not a declared field`);
-		else if (field.required === false) add(`key field "${name}" is nullable`);
-		else if (field.type === "json") add(`key field "${name}" is json`);
-	}
-	for (const [name, { type, maxLength, ascii }] of Object.entries(definition.fields)) {
-		if (maxLength !== void 0 && (type !== "string" || !Number.isSafeInteger(maxLength) || maxLength < 1)) add(`field "${name}" has an invalid maxLength`);
-		if (ascii && type !== "string") add(`field "${name}" is ascii but not a string`);
-	}
-};
-/** A table's derived fields and references. */
-const tableProblems = (definition, add, table) => {
-	for (const [name, derived] of Object.entries(definition.derived)) {
-		if (typeof derived.compute !== "function") add(`derived field "${name}" has no compute function`);
-		if (derived.multi && derived.type === "json") add(`derived field "${name}" cannot be multi-valued json`);
-	}
-	for (const [name, { type, references }] of Object.entries(definition.fields)) {
-		if (references === void 0) continue;
-		const target = table(references.model);
-		const targetKey = target?.key.length === 1 ? target.fields[target.key[0]] : void 0;
-		if (targetKey === void 0) add(`field "${name}" references "${references.model}", which is not a single-key table of this module`);
-		else if (targetKey.type !== type) add(`field "${name}" and the key of "${references.model}" differ in type`);
-		if (references.onDelete === "cascade" && !Object.values(definition.indexes).some(({ eq }) => eq.length === 1 && eq[0] === name)) add(`cascade on "${name}" needs an index whose eq is exactly [${name}]`);
-	}
-};
-/** An aggregate's identity, metrics, and shards. */
-const aggregateProblems = (definition, add) => {
-	const identity = Object.keys(definition.fields);
-	if (definition.key.join("\0") !== identity.join("\0")) add(`key must list the identity fields in declaration order: ${identity.join(", ")}`);
-	if (metricsOf(definition).length === 0) add("aggregate has no metrics");
-	if (definition.distinct.length > 0 && definition.counters.length + definition.gauges.length > 0) add("distinct sketches need an aggregate of their own");
-	const { shards } = definition;
-	if (!Number.isSafeInteger(shards) || shards < 1 || shards > 64) add(`shards must be 1–64`);
-};
-/** Every problem in one model's declaration, its roots and references included. */
-const problemsOf = (module, model, definition) => {
-	const problems = [];
-	const add = (message) => problems.push(`${module.id}.${model}: ${message}`);
-	const table = (name) => {
-		const target = module.schema[name];
-		return target?.kind === "table" ? target : void 0;
-	};
-	if (!NAME.test(model)) add("model names use lowercase letters, digits, and _");
-	fieldProblems(definition, add);
-	for (const [name, index] of Object.entries(definition.indexes)) {
-		const columns = [...index.eq, ...index.sort];
-		if (!INDEX_NAME.test(name)) add(`index "${name}" must match ${INDEX_NAME.source}`);
-		if (columns.length === 0) add(`index "${name}" has no fields`);
-		if (index.unique && index.sort.length > 0) add(`unique index "${name}" cannot sort`);
-		if (columns.filter((column) => {
-			const type = fieldType(definition, column);
-			if (type === void 0) add(`index "${name}" names undeclared field "${column}"`);
-			else if (type.type === "json") add(`index "${name}" names json field "${column}"`);
-			else if (type.multi && index.sort.includes(column)) add(`index "${name}" sorts by multi-valued field "${column}"`);
-			return type?.type !== "json" && type?.multi;
-		}).length > 1) add(`index "${name}" has more than one multi-valued field`);
-		if (index.root === void 0) continue;
-		const root = table(index.root.model);
-		if (root === void 0) add(`index "${name}" is rooted at unknown table "${index.root.model}"`);
-		else if (root.key.length > index.eq.length || root.key.some((field, position) => fieldType(definition, index.eq[position])?.type !== root.fields[field].type)) add(`index "${name}" eq must start with the key of "${index.root.model}"`);
-	}
-	if (definition.kind === "table") tableProblems(definition, add, table);
-	else aggregateProblems(definition, add);
-	for (const problem of require_retention.retentionProblems(module.schema, model)) add(problem);
-	return problems;
-};
-/** Rejects invalid module schemas at startup, listing every problem. */
-const validateSchema = (modules) => {
-	const problems = [];
-	const owners = /* @__PURE__ */ new Map();
-	for (const module of modules) for (const [model, definition] of Object.entries(module.schema)) {
-		const name = tableName(module, model);
-		const owner = owners.get(name);
-		if (owner !== void 0) problems.push(`${module.id}.${model}: table "${name}" is also declared by ${owner}`);
-		owners.set(name, `${module.id}.${model}`);
-		problems.push(...problemsOf(module, model, definition));
-	}
-	if (problems.length > 0) throw new _hot_updater_plugin_core_internal.DatabaseSchemaError(`Invalid database schema:\n- ${problems.join("\n- ")}`);
-};
-const indexesOf = (definition) => [...Object.entries(definition.indexes).map(([name, index]) => ({
-	name,
-	eq: [...index.eq],
-	sort: [...index.sort],
-	...index.unique ? { unique: true } : {}
-})), ...Object.entries(definition.fields).flatMap(([name, field]) => field.unique ? [{
-	name,
-	eq: [name],
-	sort: [],
-	unique: true
-}] : [])];
-/** Validates the modules, then resolves them into physical tables with engine columns. */
-const resolveSchema = (modules) => {
-	validateSchema(modules);
-	const references = [];
-	for (const module of modules) for (const [model, definition] of Object.entries(module.schema)) {
-		if (definition.kind !== "table") continue;
-		const table = tableName(module, model);
-		for (const [field, { references: to }] of Object.entries(definition.fields)) {
-			if (to === void 0) continue;
-			const { onDelete } = to;
-			const target = tableName(module, to.model);
-			const counter = onDelete === "none" ? {} : { counter: `_refs_${table}_${field}` };
-			references.push({
-				table,
-				field,
-				target,
-				onDelete,
-				...counter
-			});
-		}
-	}
-	const models = /* @__PURE__ */ new Map();
-	for (const module of modules) for (const [model, definition] of Object.entries(module.schema)) {
-		const name = tableName(module, model);
-		const referencedBy = references.filter(({ target }) => target === name);
-		const columns = Object.entries(definition.fields).map(([field, { type, required, maxLength, ascii }]) => ({
-			name: field,
-			type,
-			nullable: required === false,
-			...maxLength === void 0 ? {} : { maxLength },
-			...ascii ? { ascii } : {}
-		}));
-		if (definition.kind === "table") for (const [field, { type, multi }] of Object.entries(definition.derived)) columns.push({
-			name: field,
-			type,
-			nullable: true,
-			...multi ? { multi } : {}
-		});
-		else columns.push(integer(SHARD_COLUMN), ...[...definition.counters, ...definition.gauges].map((metric) => integer(metric)), ...definition.distinct.map((metric) => ({
-			name: metric,
-			type: "string",
-			nullable: true
-		})));
-		for (const { counter } of referencedBy) if (counter !== void 0) columns.push(integer(counter, true));
-		columns.push(integer(_hot_updater_plugin_core_internal.DATABASE_VERSION_COLUMN, true));
-		models.set(name, {
-			module: module.id,
-			model,
-			definition,
-			table: {
-				name,
-				columns,
-				key: definition.kind === "aggregate" ? [...definition.key, SHARD_COLUMN] : [...definition.key],
-				indexes: indexesOf(definition),
-				...require_retention.physicalRetention(definition)
-			},
-			references: references.filter(({ table }) => table === name),
-			referencedBy,
-			roots: new Map(Object.entries(definition.indexes).flatMap(([index, { root }]) => root === void 0 ? [] : [[index, tableName(module, root.model)]]))
-		});
-	}
-	return {
-		models,
-		tables: [...models.values()].map(({ table }) => table)
-	};
-};
-//#endregion
-exports.MAX_SHARDS = MAX_SHARDS;
-exports.SHARD_COLUMN = SHARD_COLUMN;
-exports.resolveSchema = resolveSchema;
-exports.validateSchema = validateSchema;

package/dist/database/resolveSchema.d.cts

@@ -1,42 +0,0 @@
-import { ModelShape, ReferenceAction, SchemaShape } from "./definitions.cjs";
-import { PhysicalTable } from "@hot-updater/plugin-core/internal";
-//#region src/database/resolveSchema.d.ts
-declare const SHARD_COLUMN = "_shard";
-declare const MAX_SHARDS = 64;
-interface SchemaModule {
-  readonly id: string;
-  readonly schema: SchemaShape;
-  /** Prefixes this module's table names; a plugin uses its id unless it sets `namespace: false`. */
-  readonly namespace?: string;
-}
-interface ResolvedReference {
-  /** The child table and the field that holds the parent key. */
-  readonly table: string;
-  readonly field: string;
-  readonly target: string;
-  readonly onDelete: ReferenceAction;
-  /** The counter column on the parent; absent for `none`. */
-  readonly counter?: string;
-}
-interface ResolvedModel {
-  readonly module: string;
-  /** The model name as its module declares it. */
-  readonly model: string;
-  readonly table: PhysicalTable;
-  readonly definition: ModelShape;
-  readonly references: readonly ResolvedReference[];
-  readonly referencedBy: readonly ResolvedReference[];
-  /** Index name to the physical name of its root table. */
-  readonly roots: ReadonlyMap<string, string>;
-}
-interface ResolvedSchema {
-  /** By physical table name. */
-  readonly models: ReadonlyMap<string, ResolvedModel>;
-  readonly tables: readonly PhysicalTable[];
-}
-/** Rejects invalid module schemas at startup, listing every problem. */
-declare const validateSchema: (modules: readonly SchemaModule[]) => void;
-/** Validates the modules, then resolves them into physical tables with engine columns. */
-declare const resolveSchema: (modules: readonly SchemaModule[]) => ResolvedSchema;
-//#endregion
-export { MAX_SHARDS, ResolvedModel, ResolvedReference, ResolvedSchema, SHARD_COLUMN, SchemaModule, resolveSchema, validateSchema };

package/dist/database/resolveSchema.d.mts

@@ -1,42 +0,0 @@
-import { ModelShape, ReferenceAction, SchemaShape } from "./definitions.mjs";
-import { PhysicalTable } from "@hot-updater/plugin-core/internal";
-//#region src/database/resolveSchema.d.ts
-declare const SHARD_COLUMN = "_shard";
-declare const MAX_SHARDS = 64;
-interface SchemaModule {
-  readonly id: string;
-  readonly schema: SchemaShape;
-  /** Prefixes this module's table names; a plugin uses its id unless it sets `namespace: false`. */
-  readonly namespace?: string;
-}
-interface ResolvedReference {
-  /** The child table and the field that holds the parent key. */
-  readonly table: string;
-  readonly field: string;
-  readonly target: string;
-  readonly onDelete: ReferenceAction;
-  /** The counter column on the parent; absent for `none`. */
-  readonly counter?: string;
-}
-interface ResolvedModel {
-  readonly module: string;
-  /** The model name as its module declares it. */
-  readonly model: string;
-  readonly table: PhysicalTable;
-  readonly definition: ModelShape;
-  readonly references: readonly ResolvedReference[];
-  readonly referencedBy: readonly ResolvedReference[];
-  /** Index name to the physical name of its root table. */
-  readonly roots: ReadonlyMap<string, string>;
-}
-interface ResolvedSchema {
-  /** By physical table name. */
-  readonly models: ReadonlyMap<string, ResolvedModel>;
-  readonly tables: readonly PhysicalTable[];
-}
-/** Rejects invalid module schemas at startup, listing every problem. */
-declare const validateSchema: (modules: readonly SchemaModule[]) => void;
-/** Validates the modules, then resolves them into physical tables with engine columns. */
-declare const resolveSchema: (modules: readonly SchemaModule[]) => ResolvedSchema;
-//#endregion
-export { MAX_SHARDS, ResolvedModel, ResolvedReference, ResolvedSchema, SHARD_COLUMN, SchemaModule, resolveSchema, validateSchema };