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

package/dist/database/engineReads.d.cts

@@ -1,35 +0,0 @@
-import "./resolveSchema.cjs";
-import { DatabaseAdapter, DatabaseKeyValue, StoredRow } from "@hot-updater/plugin-core/internal";
-//#region src/database/engineReads.d.ts
-declare class DatabaseQueryError extends Error {
-  readonly name = "DatabaseQueryError";
-}
-/** A value of the index's first order field, or a prefix of its order tuple. */
-type RangeValue = DatabaseKeyValue | readonly DatabaseKeyValue[];
-interface ReadRange {
-  readonly gt?: RangeValue;
-  readonly gte?: RangeValue;
-  readonly lt?: RangeValue;
-  readonly lte?: RangeValue;
-}
-interface ReadInput {
-  readonly index: string;
-  /** Values for every eq field of the index. */
-  readonly where?: Readonly<Record<string, DatabaseKeyValue>>;
-  /** Bounds on the index's first order field, or on a prefix of its order tuple. */
-  readonly range?: ReadRange;
-  readonly order?: "asc" | "desc";
-  readonly limit: number;
-  readonly cursor?: string;
-}
-interface Page<TRow> {
-  readonly rows: readonly TRow[];
-  /** Present only after a full page. */
-  readonly next?: string;
-}
-interface EngineReadCount {
-  readonly calls: number;
-  readonly rows: number;
-}
-//#endregion
-export { DatabaseQueryError, EngineReadCount, Page, RangeValue, ReadInput, ReadRange };

package/dist/database/engineReads.d.mts

@@ -1,35 +0,0 @@
-import "./resolveSchema.mjs";
-import { DatabaseAdapter, DatabaseKeyValue, StoredRow } from "@hot-updater/plugin-core/internal";
-//#region src/database/engineReads.d.ts
-declare class DatabaseQueryError extends Error {
-  readonly name = "DatabaseQueryError";
-}
-/** A value of the index's first order field, or a prefix of its order tuple. */
-type RangeValue = DatabaseKeyValue | readonly DatabaseKeyValue[];
-interface ReadRange {
-  readonly gt?: RangeValue;
-  readonly gte?: RangeValue;
-  readonly lt?: RangeValue;
-  readonly lte?: RangeValue;
-}
-interface ReadInput {
-  readonly index: string;
-  /** Values for every eq field of the index. */
-  readonly where?: Readonly<Record<string, DatabaseKeyValue>>;
-  /** Bounds on the index's first order field, or on a prefix of its order tuple. */
-  readonly range?: ReadRange;
-  readonly order?: "asc" | "desc";
-  readonly limit: number;
-  readonly cursor?: string;
-}
-interface Page<TRow> {
-  readonly rows: readonly TRow[];
-  /** Present only after a full page. */
-  readonly next?: string;
-}
-interface EngineReadCount {
-  readonly calls: number;
-  readonly rows: number;
-}
-//#endregion
-export { DatabaseQueryError, EngineReadCount, Page, RangeValue, ReadInput, ReadRange };

package/dist/database/engineReads.mjs

@@ -1,181 +0,0 @@
-import { cursorScope, decodeCursor, encodeCursor } from "./cursor.mjs";
-import { SHARD_COLUMN } from "./resolveSchema.mjs";
-import { DATABASE_MAX_QUERY_LIMIT, indexOrderColumns, indexOrderTuple, isKeyValue, mergeDistinct } from "@hot-updater/plugin-core/internal";
-//#region src/database/engineReads.ts
-var DatabaseQueryError = class extends Error {
-	name = "DatabaseQueryError";
-};
-const sameFields = (left, right) => left.length === right.length && left.every((field) => right.includes(field));
-const keyValue = (value, field) => {
-	if (isKeyValue(value)) return value;
-	throw new DatabaseQueryError(`${field} needs a string, number, or boolean.`);
-};
-const bound = (exclusive, inclusive, columns) => {
-	if (exclusive !== void 0 && inclusive !== void 0) throw new DatabaseQueryError(`range on ${columns[0]} sets both bounds of one side.`);
-	const value = exclusive ?? inclusive;
-	if (value === void 0) return void 0;
-	const values = Array.isArray(value) ? value : [value];
-	if (values.length === 0 || values.length > columns.length) throw new DatabaseQueryError(`range on ${columns[0]} takes 1–${columns.length} values of ${columns.join(", ")}.`);
-	return {
-		values: values.map((item, position) => keyValue(item, columns[position])),
-		inclusive: inclusive !== void 0
-	};
-};
-const createEngineReads = ({ adapter, schema, maxPageSize: requested = DATABASE_MAX_QUERY_LIMIT }) => {
-	const maxPageSize = Math.min(requested, DATABASE_MAX_QUERY_LIMIT);
-	let count = {
-		calls: 0,
-		rows: 0
-	};
-	const returned = (rows) => {
-		const size = Array.isArray(rows) ? rows.length : rows === null ? 0 : 1;
-		count = {
-			calls: count.calls + 1,
-			rows: count.rows + size
-		};
-		return rows;
-	};
-	/** A model of `kind` by physical table name, for reads and transactions. */
-	const modelOf = (name, kind = "table") => {
-		const model = schema.models.get(name);
-		if (model?.definition.kind === kind) return model;
-		throw new DatabaseQueryError(model === void 0 ? `Unknown model ${name}.` : kind === "table" ? `${name} is an aggregate; read it with findAggregates and change it with aggregate.` : `${name} is a table; read it with findMany and change it with create, update, or delete.`);
-	};
-	const plan = ({ table }, input) => {
-		const index = table.indexes.find(({ name }) => name === input.index);
-		if (index === void 0) throw new DatabaseQueryError(`${table.name} has no index ${input.index}.`);
-		const where = input.where ?? {};
-		if (!sameFields(Object.keys(where), index.eq)) throw new DatabaseQueryError(`${table.name}.${index.name} reads need where on exactly: ${index.eq.join(", ") || "(none)"}.`);
-		const { limit, order = "asc", range } = input;
-		if (!Number.isSafeInteger(limit) || limit < 1 || limit > maxPageSize) throw new DatabaseQueryError(`limit must be 1–${maxPageSize}.`);
-		const columns = indexOrderColumns(table, index);
-		const eq = index.eq.map((field) => keyValue(where[field], `${table.name}.${field}`));
-		const scope = cursorScope([
-			table.name,
-			index.name,
-			eq,
-			order,
-			range
-		]);
-		let lower = bound(range?.gt, range?.gte, columns);
-		let upper = bound(range?.lt, range?.lte, columns);
-		if (input.cursor !== void 0) {
-			const values = decodeCursor(scope, input.cursor);
-			if (order === "asc") lower = {
-				values,
-				inclusive: false
-			};
-			else upper = {
-				values,
-				inclusive: false
-			};
-		}
-		return {
-			request: {
-				index: index.name,
-				eq,
-				order,
-				limit,
-				...lower === void 0 ? {} : { lower },
-				...upper === void 0 ? {} : { upper }
-			},
-			index,
-			scope
-		};
-	};
-	/** Reads rows by key in one batch; the results follow the keys' order. */
-	const findByKeys = async (name, lookups) => {
-		const { table } = modelOf(name, "table");
-		const keys = lookups.map((lookup) => {
-			if (!sameFields(Object.keys(lookup), table.key)) throw new DatabaseQueryError(`findByKeys on ${name} takes its key: ${table.key.join(", ")}.`);
-			return table.key.map((field) => keyValue(lookup[field], `${name}.${field}`));
-		});
-		const rows = keys.length === 0 ? [] : await adapter.get(table, keys);
-		returned(rows.filter((row) => row !== null));
-		return rows.map((row) => row ?? null);
-	};
-	return {
-		maxPageSize,
-		modelOf,
-		reads: {
-			total: () => count,
-			reset: () => {
-				count = {
-					calls: 0,
-					rows: 0
-				};
-			}
-		},
-		findByKeys,
-		/** Reads one row by its key or by the eq fields of a unique index. */
-		async findOne(name, lookup) {
-			const { table } = modelOf(name, "table");
-			const fields = Object.keys(lookup);
-			if (sameFields(fields, table.key)) return (await findByKeys(name, [lookup]))[0];
-			const index = table.indexes.find(({ unique, eq }) => unique && sameFields(fields, eq));
-			if (index === void 0) throw new DatabaseQueryError(`findOne on ${name} needs its key or a unique field, not ${fields.join(", ")}.`);
-			const [row] = await adapter.query(table, {
-				index: index.name,
-				eq: index.eq.map((field) => keyValue(lookup[field], `${name}.${field}`)),
-				order: "asc",
-				limit: 1
-			});
-			return returned(row ?? null);
-		},
-		/** Reads one page of an index range; `next` resumes right after it. */
-		async findMany(name, input) {
-			const model = modelOf(name, "table");
-			const { request, index, scope } = plan(model, input);
-			const rows = returned(await adapter.query(model.table, request));
-			const last = rows.at(-1);
-			return rows.length === input.limit && last !== void 0 ? {
-				rows,
-				next: encodeCursor(scope, indexOrderTuple(model.table, index, last))
-			} : { rows };
-		},
-		/**
-		* Reads one page of logical aggregate rows, summing counters and gauges
-		* and merging sketches across each row's shards. A row cut off by the
-		* limit is completed by reading only its remaining shards.
-		*/
-		async findAggregates(name, input) {
-			const model = modelOf(name, "aggregate");
-			const { table, definition } = model;
-			if (definition.kind !== "aggregate") throw new DatabaseQueryError(name);
-			const { request, index, scope } = plan(model, input);
-			const rows = await adapter.query(table, request);
-			const logicalKey = (row) => definition.key.map((column) => keyValue(row[column], column));
-			const groups = /* @__PURE__ */ new Map();
-			for (const row of rows) {
-				const key = JSON.stringify(logicalKey(row));
-				groups.set(key, [...groups.get(key) ?? [], row]);
-			}
-			const full = rows.length === input.limit;
-			const last = [...groups.values()].at(-1);
-			if (full && last !== void 0) {
-				const seen = new Set(last.map((row) => row[SHARD_COLUMN]));
-				const missing = Array.from({ length: definition.shards }, (_, shard) => shard).filter((shard) => !seen.has(shard));
-				if (missing.length > 0) {
-					const key = logicalKey(last[0]);
-					const rest = await adapter.get(table, missing.map((shard) => [...key, shard]));
-					last.push(...rest.filter((row) => row !== null));
-				}
-			}
-			const merged = [...groups.values()].map((shards) => {
-				const row = Object.fromEntries(definition.key.map((field) => [field, shards[0][field]]));
-				for (const metric of [...definition.counters, ...definition.gauges]) row[metric] = shards.reduce((sum, shard) => sum + Number(shard[metric] ?? 0), 0);
-				for (const metric of definition.distinct) row[metric] = mergeDistinct(shards.map((shard) => shard[metric]));
-				return row;
-			});
-			returned(merged);
-			if (!full || last === void 0) return { rows: merged };
-			const tuple = indexOrderTuple(table, index, last[0]);
-			return {
-				rows: merged,
-				next: encodeCursor(scope, tuple.slice(0, -1))
-			};
-		}
-	};
-};
-//#endregion
-export { DatabaseQueryError, createEngineReads };

package/dist/database/engineTransaction.cjs

@@ -1,399 +0,0 @@
-const require_errors = require("./errors.cjs");
-const require_engineAggregates = require("./engineAggregates.cjs");
-const require_engineReads = require("./engineReads.cjs");
-let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
-//#region src/database/engineTransaction.ts
-/** A row this attempt read changed while it ran; the attempt reruns. */
-var StaleReadError = class extends Error {};
-const idOf = (table, key) => JSON.stringify([table, key]);
-const versionOf = (row) => Number(row[_hot_updater_plugin_core_internal.DATABASE_VERSION_COLUMN]);
-const isKeyed = (value) => value !== null && value !== void 0;
-const misuse = (table, message) => new require_errors.DatabaseTransactionError(`${table}: ${message}`);
-const once = (table) => misuse(table, "a transaction writes one key once.");
-const hooks = globalThis.process?.getBuiltinModule?.("node:async_hooks");
-/** Where the runtime tracks async context, `db.*` inside a transaction throws. */
-const transactionScope = hooks && new hooks.AsyncLocalStorage();
-const assertOutsideTransaction = () => {
-	if (transactionScope?.getStore() !== void 0) throw new require_errors.DatabaseTransactionError("Inside transaction(), read and write through its handle; db and core are not part of it.");
-};
-const createTransactions = ({ adapter, schema, reads, retry = {} }) => {
-	const { attempts = 8, baseDelayMs = 5, maxDelayMs = 250, onRetry } = retry;
-	const { modelOf } = reads;
-	/**
-	* A key-value index copy has no `_v`. A transaction guards what it reads,
-	* so it reads such a row whole, and reruns if it changed since the copy.
-	*/
-	const complete = async ({ table }, rows) => {
-		const copies = rows.filter((row) => !(_hot_updater_plugin_core_internal.DATABASE_VERSION_COLUMN in row));
-		if (copies.length === 0) return [...rows];
-		const current = await adapter.get(table, copies.map((copy) => (0, _hot_updater_plugin_core_internal.rowKey)(table, copy)));
-		return rows.map((row) => {
-			const at = copies.indexOf(row);
-			if (at < 0) return row;
-			const whole = current[at];
-			if (!whole || Object.keys(row).some((column) => (0, _hot_updater_plugin_core_internal.canonicalJson)(row[column]) !== (0, _hot_updater_plugin_core_internal.canonicalJson)(whole[column]))) throw new StaleReadError();
-			return whole;
-		});
-	};
-	const attempt = async (fn) => {
-		const read = /* @__PURE__ */ new Map();
-		/** Rows of rooted ranges: their root guards them, so they need no check of their own. */
-		const ranged = /* @__PURE__ */ new Map();
-		const writes = /* @__PURE__ */ new Map();
-		/** Deleted keys, children before their parents. */
-		const deleted = [];
-		const aggregates = /* @__PURE__ */ new Map();
-		let open = true;
-		let failure;
-		/** A failed call fails the attempt even when `fn` catches it. */
-		const step = (method) => (...args) => {
-			if (!open) throw new require_errors.DatabaseTransactionError("The transaction has ended.");
-			const fail = (error) => {
-				failure ??= { error };
-				throw error;
-			};
-			try {
-				const result = method(...args);
-				return result instanceof Promise ? result.catch(fail) : result;
-			} catch (error) {
-				return fail(error);
-			}
-		};
-		const remember = (model, key, row) => {
-			const id = idOf(model.table.name, key);
-			const known = read.get(id);
-			if (known !== void 0 && (known && row ? versionOf(known) !== versionOf(row) : known !== row)) throw new StaleReadError();
-			read.set(id, row);
-			return row;
-		};
-		const readRow = ({ table }, row) => {
-			const id = idOf(table.name, (0, _hot_updater_plugin_core_internal.rowKey)(table, row));
-			const known = read.get(id) ?? ranged.get(id);
-			if (known && versionOf(known) === versionOf(row)) return known;
-			throw misuse(table.name, "update and delete take a row this transaction read.");
-		};
-		const checkFields = ({ table, definition: { fields } }, values, creating) => {
-			for (const field of Object.keys(values)) if (!(field in fields) || !creating && table.key.includes(field)) throw misuse(table.name, `${field} cannot be ${creating ? "set" : "changed"}.`);
-			for (const [field, { required }] of Object.entries(fields)) if (required !== false && (creating || field in values) && !isKeyed(values[field])) throw misuse(table.name, `${field} is required.`);
-		};
-		/** Adds counter deltas to a key's pending op; an empty `by` still bumps `_v`. */
-		const bump = (model, key, by) => {
-			const id = idOf(model.table.name, key);
-			const pending = writes.get(id);
-			if (pending === void 0) writes.set(id, {
-				model,
-				key,
-				type: "increment",
-				row: { ...by }
-			});
-			else if (pending.type !== "delete") for (const [column, delta] of Object.entries(by)) pending.row[column] = Number(pending.row[column] ?? pending.read?.[column] ?? 0) + delta;
-			else if (Object.values(by).some((delta) => delta > 0)) throw new require_errors.DatabaseConstraintError("not_found", model.table.name);
-		};
-		/** Moves parent counters when a reference changes and bumps every rooted parent. */
-		const touchParents = (model, before, after) => {
-			for (const { field, counter, target } of model.references) {
-				const [from, to] = [before?.[field], after?.[field]];
-				if (counter === void 0 || from === to) continue;
-				if (isKeyed(from)) bump(modelOf(target), [from], { [counter]: -1 });
-				if (isKeyed(to)) bump(modelOf(target), [to], { [counter]: 1 });
-			}
-			for (const [index, root] of model.roots) {
-				const parent = modelOf(root);
-				const { eq } = model.table.indexes.find(({ name }) => name === index);
-				for (const row of [before, after]) {
-					const key = eq.slice(0, parent.table.key.length).map((field) => row?.[field]);
-					if (row && key.every(isKeyed)) bump(parent, key, {});
-				}
-			}
-		};
-		const derive = ({ definition }, row) => {
-			if (definition.kind === "table") for (const [name, derived] of Object.entries(definition.derived)) row[name] = derived.compute(row);
-			return row;
-		};
-		/** Deletes a row after its cascaded children, or refuses a restricted delete. */
-		const remove = async (model, known) => {
-			const { table } = model;
-			const key = (0, _hot_updater_plugin_core_internal.rowKey)(table, known);
-			const id = idOf(table.name, key);
-			const pending = writes.get(id);
-			if (pending?.type === "delete") return;
-			if (pending && pending.type !== "increment") throw once(table.name);
-			writes.set(id, {
-				model,
-				key,
-				type: "delete",
-				row: {},
-				read: known
-			});
-			touchParents(model, known, null);
-			for (const reference of model.referencedBy) {
-				const { counter, field, onDelete, table: name } = reference;
-				if (counter === void 0) continue;
-				const stored = Number(known[counter] ?? 0);
-				const added = Number(pending?.row[counter] ?? 0);
-				if (added > 0) throw new require_errors.DatabaseConstraintError("referenced", table.name);
-				if (stored + added <= 0) continue;
-				if (onDelete === "restrict") {
-					const [current] = await adapter.get(table, [key]);
-					if (current && versionOf(current) === versionOf(known)) throw new require_errors.DatabaseConstraintError("referenced", table.name);
-					throw new StaleReadError();
-				}
-				const child = modelOf(name);
-				const index = child.table.indexes.find(({ eq }) => eq.length === 1 && eq[0] === field);
-				let cursor;
-				let seen = 0;
-				do {
-					const page = await reads.findMany(name, {
-						index: index.name,
-						where: { [field]: key[0] },
-						limit: Math.min(stored - seen, reads.maxPageSize),
-						...cursor === void 0 ? {} : { cursor }
-					});
-					for (const row of await complete(child, page.rows)) {
-						remember(child, (0, _hot_updater_plugin_core_internal.rowKey)(child.table, row), row);
-						await remove(child, row);
-					}
-					seen += page.rows.length;
-					cursor = page.next;
-				} while (cursor !== void 0 && seen < stored);
-			}
-			deleted.push(id);
-		};
-		const tx = {
-			findOne: step(async (name, lookup) => {
-				const model = modelOf(name);
-				const { table } = model;
-				const found = await reads.findOne(name, lookup);
-				if (found === null && !table.key.every((field) => field in lookup)) return null;
-				const [row = null] = found ? await complete(model, [found]) : [];
-				const key = row ? (0, _hot_updater_plugin_core_internal.rowKey)(table, row) : table.key.map((field) => lookup[field]);
-				return remember(model, key, row);
-			}),
-			findMany: step(async (name, input) => {
-				const model = modelOf(name);
-				const root = model.roots.get(input.index);
-				if (root === void 0) throw new require_engineReads.DatabaseQueryError(`${name}.${input.index} is not rooted; a transaction reads a range only under a guarded parent.`);
-				const parent = modelOf(root);
-				const { eq } = model.table.indexes.find(({ name: index }) => index === input.index);
-				const where = input.where ?? {};
-				const lookup = Object.fromEntries(parent.table.key.map((field, at) => [field, where[eq[at]]]));
-				remember(parent, Object.values(lookup), await reads.findOne(root, lookup));
-				const found = await reads.findMany(name, input);
-				const rows = await complete(model, found.rows);
-				for (const row of rows) ranged.set(idOf(name, (0, _hot_updater_plugin_core_internal.rowKey)(model.table, row)), row);
-				return {
-					...found,
-					rows
-				};
-			}),
-			create: step((name, values) => {
-				const model = modelOf(name);
-				checkFields(model, values, true);
-				const defaults = model.table.columns.flatMap((column) => column.nullable || column.default !== void 0 ? [[column.name, column.default ?? null]] : []);
-				const row = derive(model, {
-					...Object.fromEntries(defaults),
-					...values
-				});
-				const key = (0, _hot_updater_plugin_core_internal.rowKey)(model.table, row);
-				const id = idOf(name, key);
-				const pending = writes.get(id);
-				if (pending && pending.type !== "increment") throw once(name);
-				for (const [column, delta] of Object.entries(pending?.row ?? {})) row[column] = Number(row[column]) + Number(delta);
-				writes.set(id, {
-					model,
-					key,
-					type: "insert",
-					row
-				});
-				touchParents(model, null, row);
-			}),
-			update: step((name, row, set) => {
-				const model = modelOf(name);
-				const known = readRow(model, row);
-				checkFields(model, set, false);
-				const key = (0, _hot_updater_plugin_core_internal.rowKey)(model.table, known);
-				const id = idOf(name, key);
-				const pending = writes.get(id);
-				if (pending?.type === "insert" || pending?.type === "delete") throw once(name);
-				const before = pending?.type === "patch" ? {
-					...known,
-					...pending.row
-				} : known;
-				const next = derive(model, {
-					...before,
-					...set
-				});
-				const changed = Object.entries(next).filter(([column, value]) => column !== _hot_updater_plugin_core_internal.DATABASE_VERSION_COLUMN && JSON.stringify(value) !== JSON.stringify(known[column]));
-				const patch = Object.fromEntries(changed);
-				writes.set(id, {
-					model,
-					key,
-					type: "patch",
-					row: patch,
-					read: known
-				});
-				if (pending?.type === "increment") bump(model, key, pending.row);
-				touchParents(model, before, next);
-			}),
-			delete: step(async (name, row) => {
-				const model = modelOf(name);
-				await remove(model, readRow(model, row));
-			}),
-			aggregate: step((name, identity, values, options) => {
-				const model = modelOf(name, "aggregate");
-				require_engineAggregates.recordAggregate(aggregates, model, identity, values, options?.shardBy);
-			})
-		};
-		try {
-			const result = await (transactionScope ? transactionScope.run(tx, () => fn(tx)) : fn(tx));
-			if (failure) throw failure.error;
-			return {
-				result,
-				read,
-				ops: compile(writes, read, deleted),
-				aggregates: [...aggregates.values()]
-			};
-		} catch (error) {
-			throw failure?.error instanceof StaleReadError ? failure.error : error;
-		} finally {
-			open = false;
-		}
-	};
-	/** Inserts first, then patches and increments, then checks, then deletes, children before parents. */
-	const compile = (writes, read, deleted) => {
-		const toOp = (id) => {
-			const { model, key, type, row, read: previous } = writes.get(id);
-			const { table } = model;
-			if (type === "insert") return {
-				type,
-				table,
-				row
-			};
-			if (type === "increment") {
-				const known = read.get(id);
-				const by = row;
-				return known ? {
-					type,
-					table,
-					key,
-					by,
-					guard: { v: versionOf(known) }
-				} : {
-					type,
-					table,
-					key,
-					by
-				};
-			}
-			const guard = { v: versionOf(previous) };
-			return type === "patch" ? {
-				type,
-				table,
-				key,
-				set: row,
-				guard,
-				previous
-			} : {
-				type,
-				table,
-				key,
-				guard,
-				previous
-			};
-		};
-		const checks = [...read].flatMap(([id, row]) => {
-			if (row === null || writes.has(id)) return [];
-			const { table } = schema.models.get(JSON.parse(id)[0]);
-			const guard = { v: versionOf(row) };
-			return [{
-				type: "check",
-				table,
-				key: (0, _hot_updater_plugin_core_internal.rowKey)(table, row),
-				guard
-			}];
-		});
-		const ofType = (...types) => [...writes.keys()].filter((id) => types.includes(writes.get(id).type));
-		return [
-			...[...ofType("insert"), ...ofType("patch", "increment")].map(toOp),
-			...checks,
-			...deleted.map(toOp)
-		];
-	};
-	/** Only a constraint the current state confirms is reported; anything else reruns. */
-	const classify = async (op, read) => {
-		if (op.type === "check" || op.type === "delete") return void 0;
-		if (op.type === "increment" && op.guard) return void 0;
-		const { table } = op;
-		const key = op.type === "insert" ? (0, _hot_updater_plugin_core_internal.rowKey)(table, op.row) : op.key;
-		const [current] = await adapter.get(table, [key]);
-		if (op.type === "increment") return current ? void 0 : "not_found";
-		if (op.type === "insert" && current) {
-			const known = read.get(idOf(table.name, key));
-			return known === null || known !== void 0 && versionOf(known) !== versionOf(current) ? void 0 : "exists";
-		}
-		if (op.type === "patch" && current?.[_hot_updater_plugin_core_internal.DATABASE_VERSION_COLUMN] !== op.guard.v) return;
-		const row = op.type === "insert" ? op.row : {
-			...current,
-			...op.set
-		};
-		for (const index of table.indexes) {
-			if (!index.unique) continue;
-			for (const eq of (0, _hot_updater_plugin_core_internal.indexEntries)(table, index, row)) if ((await adapter.query(table, {
-				index: index.name,
-				eq,
-				order: "asc",
-				limit: 2
-			})).some((other) => (0, _hot_updater_plugin_core_internal.compareTuples)((0, _hot_updater_plugin_core_internal.rowKey)(table, other), key))) return "unique";
-		}
-	};
-	return { async transaction(fn) {
-		assertOutsideTransaction();
-		let run;
-		let negative;
-		for (let round = 0; round < attempts; round += 1) {
-			const delay = round && Math.min(maxDelayMs, baseDelayMs * 2 ** (round - 1));
-			if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay / 2 + Math.random() * (delay / 2)));
-			run ??= await attempt(fn).catch((error) => {
-				if (error instanceof StaleReadError) return void 0;
-				throw error;
-			});
-			if (run === void 0) {
-				onRetry?.("rerun", round + 1);
-				continue;
-			}
-			let aggregates;
-			try {
-				aggregates = await require_engineAggregates.compileAggregates(adapter, run.aggregates);
-			} catch (error) {
-				if (!(error instanceof require_engineAggregates.NegativeGaugeError)) throw error;
-				negative = error;
-				onRetry?.("rerun", round + 1);
-				run = void 0;
-				continue;
-			}
-			const ops = [...run.ops, ...aggregates];
-			if (ops.length <= 1 && ops.every(({ type }) => type === "check")) return run.result;
-			if (!adapter.fits(ops)) throw new require_errors.DatabaseConstraintError("too_large", ops[0].table.name);
-			let outcome;
-			try {
-				outcome = await adapter.write(ops);
-			} catch (cause) {
-				throw new require_errors.DatabaseAmbiguousCommitError("The commit outcome is unknown.", { cause });
-			}
-			if (outcome.ok) return run.result;
-			const failed = "failedOp" in outcome ? outcome.failedOp : void 0;
-			if (failed === void 0 || failed >= run.ops.length) {
-				onRetry?.("resend", round + 1);
-				continue;
-			}
-			const reason = await classify(ops[failed], run.read);
-			if (reason) throw new require_errors.DatabaseConstraintError(reason, ops[failed].table.name);
-			onRetry?.("rerun", round + 1);
-			run = void 0;
-		}
-		throw negative ?? new require_errors.DatabaseConflictError(`The transaction conflicted ${attempts} times.`);
-	} };
-};
-//#endregion
-exports.assertOutsideTransaction = assertOutsideTransaction;
-exports.createTransactions = createTransactions;

package/dist/database/engineTransaction.d.cts

@@ -1,26 +0,0 @@
-import "./resolveSchema.cjs";
-import { Page, ReadInput } from "./engineReads.cjs";
-import { DatabaseAdapter, DatabaseKeyValue, StoredRow } from "@hot-updater/plugin-core/internal";
-//#region src/database/engineTransaction.d.ts
-interface RetryOptions {
-  readonly attempts?: number;
-  readonly baseDelayMs?: number;
-  readonly maxDelayMs?: number;
-  /** Called before each rerun of `fn` and each resend of the same write, with the attempt that failed (from 1). */
-  readonly onRetry?: (kind: "rerun" | "resend", attempt: number) => void;
-}
-type Row = Record<string, unknown>;
-type Lookup = Readonly<Record<string, DatabaseKeyValue>>;
-/** The handle `fn` receives, by physical table name; `database()` types it per module. */
-interface TransactionEngine {
-  findOne(table: string, lookup: Lookup): Promise<StoredRow | null>;
-  findMany(table: string, input: ReadInput): Promise<Page<StoredRow>>;
-  create(table: string, row: Readonly<Row>): void;
-  update(table: string, row: StoredRow, set: Readonly<Row>): void;
-  delete(table: string, row: StoredRow): Promise<void>;
-  aggregate(table: string, identity: Readonly<Row>, values: Readonly<Row>, options?: {
-    readonly shardBy?: string;
-  }): void;
-}
-//#endregion
-export { RetryOptions, TransactionEngine };