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

package/dist/database/engineTransaction.d.mts

@@ -1,26 +0,0 @@
-import "./resolveSchema.mjs";
-import { Page, ReadInput } from "./engineReads.mjs";
-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 };

package/dist/database/engineTransaction.mjs

@@ -1,398 +0,0 @@
-import { DatabaseAmbiguousCommitError, DatabaseConflictError, DatabaseConstraintError, DatabaseTransactionError } from "./errors.mjs";
-import { NegativeGaugeError, compileAggregates, recordAggregate } from "./engineAggregates.mjs";
-import { DatabaseQueryError } from "./engineReads.mjs";
-import { DATABASE_VERSION_COLUMN, canonicalJson, compareTuples, indexEntries, rowKey } from "@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[DATABASE_VERSION_COLUMN]);
-const isKeyed = (value) => value !== null && value !== void 0;
-const misuse = (table, message) => new 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 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) => !(DATABASE_VERSION_COLUMN in row));
-		if (copies.length === 0) return [...rows];
-		const current = await adapter.get(table, copies.map((copy) => 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) => canonicalJson(row[column]) !== 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 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, 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 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 = 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 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 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, 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 ? 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 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, 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 = 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 = 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 !== 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");
-				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: 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" ? 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?.[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 indexEntries(table, index, row)) if ((await adapter.query(table, {
-				index: index.name,
-				eq,
-				order: "asc",
-				limit: 2
-			})).some((other) => compareTuples(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 compileAggregates(adapter, run.aggregates);
-			} catch (error) {
-				if (!(error instanceof 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 DatabaseConstraintError("too_large", ops[0].table.name);
-			let outcome;
-			try {
-				outcome = await adapter.write(ops);
-			} catch (cause) {
-				throw new 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 DatabaseConstraintError(reason, ops[failed].table.name);
-			onRetry?.("rerun", round + 1);
-			run = void 0;
-		}
-		throw negative ?? new DatabaseConflictError(`The transaction conflicted ${attempts} times.`);
-	} };
-};
-//#endregion
-export { assertOutsideTransaction, createTransactions };

package/dist/database/errors.cjs

@@ -1,27 +0,0 @@
-//#region src/database/errors.ts
-var DatabaseConstraintError = class extends Error {
-	reason;
-	model;
-	name = "DatabaseConstraintError";
-	constructor(reason, model) {
-		super(`${model}: ${reason}`);
-		this.reason = reason;
-		this.model = model;
-	}
-};
-/** The retry budget ran out; ingestion answers 503 with Retry-After. */
-var DatabaseConflictError = class extends Error {
-	name = "DatabaseConflictError";
-};
-/** The write may or may not have committed; it is reported, never rerun. */
-var DatabaseAmbiguousCommitError = class extends Error {
-	name = "DatabaseAmbiguousCommitError";
-};
-var DatabaseTransactionError = class extends Error {
-	name = "DatabaseTransactionError";
-};
-//#endregion
-exports.DatabaseAmbiguousCommitError = DatabaseAmbiguousCommitError;
-exports.DatabaseConflictError = DatabaseConflictError;
-exports.DatabaseConstraintError = DatabaseConstraintError;
-exports.DatabaseTransactionError = DatabaseTransactionError;

package/dist/database/errors.d.cts

@@ -1,21 +0,0 @@
-//#region src/database/errors.d.ts
-type ConstraintReason = "exists" | "unique" | "not_found" | "referenced" | "too_large";
-declare class DatabaseConstraintError extends Error {
-  readonly reason: ConstraintReason;
-  readonly model: string;
-  readonly name = "DatabaseConstraintError";
-  constructor(reason: ConstraintReason, model: string);
-}
-/** The retry budget ran out; ingestion answers 503 with Retry-After. */
-declare class DatabaseConflictError extends Error {
-  readonly name = "DatabaseConflictError";
-}
-/** The write may or may not have committed; it is reported, never rerun. */
-declare class DatabaseAmbiguousCommitError extends Error {
-  readonly name = "DatabaseAmbiguousCommitError";
-}
-declare class DatabaseTransactionError extends Error {
-  readonly name = "DatabaseTransactionError";
-}
-//#endregion
-export { ConstraintReason, DatabaseAmbiguousCommitError, DatabaseConflictError, DatabaseConstraintError, DatabaseTransactionError };

package/dist/database/errors.d.mts

@@ -1,21 +0,0 @@
-//#region src/database/errors.d.ts
-type ConstraintReason = "exists" | "unique" | "not_found" | "referenced" | "too_large";
-declare class DatabaseConstraintError extends Error {
-  readonly reason: ConstraintReason;
-  readonly model: string;
-  readonly name = "DatabaseConstraintError";
-  constructor(reason: ConstraintReason, model: string);
-}
-/** The retry budget ran out; ingestion answers 503 with Retry-After. */
-declare class DatabaseConflictError extends Error {
-  readonly name = "DatabaseConflictError";
-}
-/** The write may or may not have committed; it is reported, never rerun. */
-declare class DatabaseAmbiguousCommitError extends Error {
-  readonly name = "DatabaseAmbiguousCommitError";
-}
-declare class DatabaseTransactionError extends Error {
-  readonly name = "DatabaseTransactionError";
-}
-//#endregion
-export { ConstraintReason, DatabaseAmbiguousCommitError, DatabaseConflictError, DatabaseConstraintError, DatabaseTransactionError };

package/dist/database/errors.mjs

@@ -1,24 +0,0 @@
-//#region src/database/errors.ts
-var DatabaseConstraintError = class extends Error {
-	reason;
-	model;
-	name = "DatabaseConstraintError";
-	constructor(reason, model) {
-		super(`${model}: ${reason}`);
-		this.reason = reason;
-		this.model = model;
-	}
-};
-/** The retry budget ran out; ingestion answers 503 with Retry-After. */
-var DatabaseConflictError = class extends Error {
-	name = "DatabaseConflictError";
-};
-/** The write may or may not have committed; it is reported, never rerun. */
-var DatabaseAmbiguousCommitError = class extends Error {
-	name = "DatabaseAmbiguousCommitError";
-};
-var DatabaseTransactionError = class extends Error {
-	name = "DatabaseTransactionError";
-};
-//#endregion
-export { DatabaseAmbiguousCommitError, DatabaseConflictError, DatabaseConstraintError, DatabaseTransactionError };

package/dist/database/fence.cjs

@@ -1,125 +0,0 @@
-//#region src/database/fence.ts
-/** The settings rows migrations write, last, and the fence reads. */
-const SETTINGS_TABLE = {
-	name: "private_hot_updater_settings",
-	columns: [
-		{
-			name: "key",
-			type: "string",
-			nullable: false,
-			maxLength: 255
-		},
-		{
-			name: "value",
-			type: "string",
-			nullable: false,
-			maxLength: 255
-		},
-		{
-			name: "_v",
-			type: "integer",
-			nullable: false,
-			default: 0
-		}
-	],
-	key: ["key"],
-	indexes: []
-};
-/** The engine's storage-layout generation; it changes only with a migration. */
-const ENGINE_SCHEMA_KEY = "schema.engine";
-const ENGINE_SCHEMA_VERSION = "1";
-const settingMessage = (adapterName, { key, expected, found }) => `Hot Updater schema setting "${key}" for ${adapterName} is ${found === null ? "missing" : `"${found}"`}; expected "${expected}". ${key === "schema.engine" ? "Create a new empty database and run `hot-updater db migrate`; databases from before the storage engine are not converted." : "Run `hot-updater db migrate`."}`;
-/** The database needs `hot-updater db migrate`, or a new database; the handler answers 503. */
-var HotUpdaterSchemaMigrationRequiredError = class extends Error {
-	adapterName;
-	currentVersion;
-	setting;
-	constructor(adapterName, currentVersion, setting, options) {
-		super(setting !== void 0 ? settingMessage(adapterName, setting) : currentVersion === void 0 ? `Hot Updater database schema is not initialized for ${adapterName}. Run \`hot-updater db migrate\` before using this adapter.` : `Hot Updater v1 cannot migrate schema ${currentVersion} in place. Create a new empty database and run \`hot-updater db migrate\`.`, options);
-		this.adapterName = adapterName;
-		this.currentVersion = currentVersion;
-		this.setting = setting;
-		this.name = "HotUpdaterSchemaMigrationRequiredError";
-	}
-};
-/** Driver codes for a table or column the database lacks. */
-const MISSING_SCHEMA_CODES = /* @__PURE__ */ new Set([
-	"42P01",
-	"42703",
-	"ER_NO_SUCH_TABLE",
-	"ER_BAD_FIELD_ERROR"
-]);
-const MISSING_SCHEMA_MESSAGE = /no such (?:table|column)|(?:relation|column) .+ does not exist|table .+ doesn't exist|unknown column/iu;
-/**
-* Whether a read failed because a table or column is missing, so the
-* database needs migrations. ORMs may wrap the driver's error in `cause`.
-*/
-const isMissingSchemaError = (error) => {
-	for (let depth = 0; error instanceof Object && depth < 8; depth += 1) {
-		const { code, message, cause } = error;
-		if (MISSING_SCHEMA_CODES.has(String(code)) || typeof message === "string" && MISSING_SCHEMA_MESSAGE.test(message)) return true;
-		error = cause;
-	}
-	return false;
-};
-const readSettings = (adapter, keys) => adapter.get(SETTINGS_TABLE, keys.map((key) => [key]));
-/** Throws unless every expected setting is stored with its value: one batch read. */
-const checkSchemaFence = async (adapter, adapterName, expected) => {
-	const keys = Object.keys(expected);
-	let rows;
-	try {
-		rows = await readSettings(adapter, keys);
-	} catch (cause) {
-		if (!isMissingSchemaError(cause)) throw cause;
-		throw new HotUpdaterSchemaMigrationRequiredError(adapterName, void 0, {
-			key: ENGINE_SCHEMA_KEY,
-			expected: "1",
-			found: null
-		}, { cause });
-	}
-	keys.forEach((key, position) => {
-		const found = rows[position]?.value;
-		if (found !== expected[key]) throw new HotUpdaterSchemaMigrationRequiredError(adapterName, void 0, {
-			key,
-			expected: expected[key],
-			found: typeof found === "string" ? found : null
-		});
-	});
-};
-/** The database name a fenced adapter carries, so a server can fence its plugins' rows too. */
-const FENCED = Symbol.for("@hot-updater/server/schema-fence");
-/** The database name an adapter behind the schema fence reports under. */
-const fencedName = (adapter) => adapter[FENCED];
-/**
-* The adapter behind the schema fence: a process's first read or write
-* checks the settings first. Success is kept; a failure is checked again on
-* the next call.
-*/
-const withSchemaFence = (adapter, adapterName, expected) => {
-	let ready;
-	const fence = () => {
-		ready ??= checkSchemaFence(adapter, adapterName, expected).catch((error) => {
-			ready = void 0;
-			throw error;
-		});
-		return ready;
-	};
-	return {
-		...adapter,
-		[FENCED]: adapterName,
-		get: (table, keys) => fence().then(() => adapter.get(table, keys)),
-		query: (table, request) => fence().then(() => adapter.query(table, request)),
-		write: (ops) => fence().then(() => adapter.write(ops)),
-		...adapter.prune && { prune: (table, before, limit) => fence().then(() => adapter.prune(table, before, limit)) }
-	};
-};
-//#endregion
-exports.ENGINE_SCHEMA_KEY = ENGINE_SCHEMA_KEY;
-exports.ENGINE_SCHEMA_VERSION = ENGINE_SCHEMA_VERSION;
-exports.HotUpdaterSchemaMigrationRequiredError = HotUpdaterSchemaMigrationRequiredError;
-exports.SETTINGS_TABLE = SETTINGS_TABLE;
-exports.checkSchemaFence = checkSchemaFence;
-exports.fencedName = fencedName;
-exports.isMissingSchemaError = isMissingSchemaError;
-exports.readSettings = readSettings;
-exports.withSchemaFence = withSchemaFence;