@orkestrel/table 0.0.1

package/dist/src/core/index.cjs

@@ -0,0 +1,1350 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _orkestrel_contract = require("@orkestrel/contract");
+let _orkestrel_emitter = require("@orkestrel/emitter");
+//#region src/core/constants.ts
+/** Every column cell, in the order declared by the public contract. */
+var COLUMN_CELLS = Object.freeze([
+	"text",
+	"number",
+	"flag",
+	"choice"
+]);
+/** The maximum number of columns one schema may declare. */
+var COLUMN_LIMIT = 256;
+/** The maximum number of choices one `choice` column may offer. */
+var CHOICE_LIMIT = 1024;
+/** The maximum length, in UTF-16 code units, of a schema name or column key. */
+var NAME_LIMIT = 128;
+/** The maximum length, in UTF-16 code units, of any single retained string. */
+var STRING_LIMIT = 65536;
+/** The maximum total length, in UTF-16 code units, of every string one schema retains. */
+var TEXT_LIMIT = 1048576;
+/** The maximum total number of records, arrays, and leaves one schema retains. */
+var NODE_LIMIT = 16384;
+//#endregion
+//#region src/core/errors.ts
+/** An error raised by the table domain. */
+var TableError = class extends Error {
+	/** The machine-readable reason for this failure. */
+	code;
+	/** Structured values that locate or explain this failure. */
+	context;
+	/**
+	* Create a table error.
+	*
+	* @param code - The machine-readable reason.
+	* @param message - The human-readable failure text.
+	* @param context - Optional structured failure details.
+	*/
+	constructor(code, message, context) {
+		super(message);
+		this.name = "TableError";
+		this.code = code;
+		if (context !== void 0) this.context = context;
+	}
+};
+/**
+* Determine whether an unknown value is a table error.
+*
+* @param input - The value to inspect.
+* @returns Whether the value is a {@link TableError} instance.
+*/
+function isTableError(input) {
+	return input instanceof TableError;
+}
+//#endregion
+//#region src/core/helpers.ts
+/**
+* Find one column by key.
+*
+* @param schema - The schema whose columns to search.
+* @param key - The column key to find.
+* @returns The declared column, or `undefined` when no column has that key.
+*/
+function extractColumn(schema, key) {
+	return schema.columns.find((column) => column.key === key);
+}
+/**
+* Read one row's declared identity.
+*
+* @param schema - The schema that names the identity column.
+* @param row - The row whose identity to read.
+* @returns The non-empty string identity, or `undefined` when it is unusable.
+*/
+function extractKey(schema, row) {
+	if (!Object.hasOwn(row, schema.key)) return void 0;
+	const key = row[schema.key];
+	return (0, _orkestrel_contract.isString)(key) && key.length > 0 ? key : void 0;
+}
+/**
+* Compute one atomic 0/1/N membership change over known keys.
+*
+* @param known - Every key the caller may change.
+* @param current - The current key set.
+* @param input - Every known key, one key, or a key list.
+* @param include - Decide the next membership from each key's membership at that step.
+* @returns `undefined` when any requested key is unknown, the current set for a no-op, or the next
+*   set when membership changes.
+*/
+function computeKeys(known, current, input, include) {
+	const requested = input === void 0 ? known : Array.isArray(input) ? input : [input];
+	const population = new Set(known);
+	if (requested.some((key) => !population.has(key))) return void 0;
+	const next = new Set(current);
+	for (const key of requested) if (include(next.has(key))) next.add(key);
+	else next.delete(key);
+	return next.size !== current.size || [...next].some((key) => !current.has(key)) ? next : current;
+}
+/**
+* Check whether a value has the shape required by one column cell.
+*
+* @param column - The column that owns the cell.
+* @param value - The unknown value to inspect.
+* @returns Whether the column can hold the value.
+*/
+function matchesCell(column, value) {
+	if ((0, _orkestrel_contract.isString)(value) && value.length > 65536) return false;
+	switch (column.cell) {
+		case "text": return (0, _orkestrel_contract.isString)(value);
+		case "number": return (0, _orkestrel_contract.isFiniteNumber)(value);
+		case "flag": return (0, _orkestrel_contract.isBoolean)(value);
+		case "choice": return (0, _orkestrel_contract.isString)(value) && column.choices.some((choice) => choice.value === value);
+	}
+}
+/**
+* Compare two cells in ascending order according to one column.
+*
+* @param column - The column that fixes the comparison.
+* @param left - The first cell, or absence.
+* @param right - The second cell, or absence.
+* @returns A negative number, positive number, or zero in sort-comparator form.
+*/
+function compareCells(column, left, right) {
+	if (left === void 0) return right === void 0 ? 0 : -1;
+	if (right === void 0) return 1;
+	switch (column.cell) {
+		case "text":
+			if (!(0, _orkestrel_contract.isString)(left) || !(0, _orkestrel_contract.isString)(right)) return 0;
+			return left < right ? -1 : left > right ? 1 : 0;
+		case "number":
+			if (!(0, _orkestrel_contract.isFiniteNumber)(left) || !(0, _orkestrel_contract.isFiniteNumber)(right)) return 0;
+			return left - right;
+		case "flag":
+			if (!(0, _orkestrel_contract.isBoolean)(left) || !(0, _orkestrel_contract.isBoolean)(right)) return 0;
+			return left === right ? 0 : left ? 1 : -1;
+		case "choice":
+			if (!(0, _orkestrel_contract.isString)(left) || !(0, _orkestrel_contract.isString)(right)) return 0;
+			return column.choices.findIndex((choice) => choice.value === left) - column.choices.findIndex((choice) => choice.value === right);
+	}
+}
+/**
+* Check whether one column admits a filter and all its operands.
+*
+* @param column - The column that fixes the accepted operators and cell shapes.
+* @param filter - The filter to inspect.
+* @returns Whether the filter belongs to the column and the column can apply it.
+*/
+function admitsFilter(column, filter) {
+	if (filter.column !== column.key) return false;
+	switch (filter.operator) {
+		case "contains": return (column.cell === "text" || column.cell === "choice") && filter.text.length <= 65536;
+		case "between": return (column.cell === "text" || column.cell === "number") && matchesCell(column, filter.minimum) && matchesCell(column, filter.maximum);
+		case "equals": return matchesCell(column, filter.value);
+	}
+}
+/**
+* Test one cell against a filter according to its column.
+*
+* @param column - The column that fixes the accepted operators.
+* @param cell - The cell to test, or absence.
+* @param filter - The filter to apply.
+* @returns Whether the filter accepts the cell.
+*/
+function matchesFilter(column, cell, filter) {
+	if (cell === void 0 || !admitsFilter(column, filter) || !matchesCell(column, cell)) return false;
+	switch (filter.operator) {
+		case "contains": return (0, _orkestrel_contract.isString)(cell) && cell.includes(filter.text);
+		case "between": return compareCells(column, cell, filter.minimum) >= 0 && compareCells(column, cell, filter.maximum) <= 0;
+		case "equals": return cell === filter.value;
+	}
+}
+/**
+* Keep the rows accepted by every filter.
+*
+* @param schema - The schema that declares the filtered columns.
+* @param rows - The rows to filter.
+* @param filters - The filters to apply with and-only composition.
+* @param matchers - Optional per-column replacements for the default matcher.
+* @returns A frozen copy of the accepted rows in their original order.
+*/
+function filterRows(schema, rows, filters, matchers) {
+	return Object.freeze(rows.filter((row) => filters.every((filter) => {
+		const column = extractColumn(schema, filter.column);
+		if (column === void 0) return false;
+		const matcher = matchers !== void 0 && Object.hasOwn(matchers, column.key) ? matchers[column.key] : void 0;
+		const cell = Object.hasOwn(row, column.key) ? row[column.key] : void 0;
+		return matcher === void 0 ? matchesFilter(column, cell, filter) : matcher(cell, filter);
+	})));
+}
+/**
+* Order rows stably by a sequence of terms.
+*
+* @param schema - The schema that declares the sorted columns.
+* @param rows - The rows to order.
+* @param orders - The ordered sort terms.
+* @param comparators - Optional per-column replacements for the default comparator.
+* @returns A frozen sorted copy that leaves the input untouched.
+*/
+function sortRows(schema, rows, orders, comparators) {
+	const indexed = rows.map((row, index) => ({
+		row,
+		index
+	}));
+	indexed.sort((left, right) => {
+		for (const order of orders) {
+			const column = extractColumn(schema, order.column);
+			if (column === void 0) continue;
+			const comparator = comparators !== void 0 && Object.hasOwn(comparators, column.key) ? comparators[column.key] : void 0;
+			const leftCell = Object.hasOwn(left.row, column.key) ? left.row[column.key] : void 0;
+			const rightCell = Object.hasOwn(right.row, column.key) ? right.row[column.key] : void 0;
+			const compared = comparator === void 0 ? compareCells(column, leftCell, rightCell) : comparator(leftCell, rightCell);
+			if (compared !== 0 && !Number.isNaN(compared)) return order.direction === "ascending" ? compared : -compared;
+		}
+		return left.index - right.index;
+	});
+	return Object.freeze(indexed.map((entry) => entry.row));
+}
+/**
+* Audit a structurally valid schema for domain and budget faults.
+*
+* @param schema - The table schema to audit.
+* @returns Frozen human-readable diagnostics, or an empty list when the schema is sound.
+*/
+function auditTable(schema) {
+	const faults = [];
+	const columns = /* @__PURE__ */ new Set();
+	let choiceExceeded;
+	let nameExceeded = schema.name !== void 0 && schema.name.length > 128;
+	if (schema.columns.length > 256) faults.push(`schema declares more than 256 columns`);
+	const columnCount = Math.min(schema.columns.length, 257);
+	for (let index = 0; index < columnCount; index += 1) {
+		const column = schema.columns[index];
+		if (column === void 0) continue;
+		if (column.key.length > 128) nameExceeded = true;
+		if (choiceExceeded === void 0 && column.cell === "choice" && column.choices.length > 1024) choiceExceeded = column.key;
+	}
+	if (choiceExceeded !== void 0) faults.push(`column "${choiceExceeded}" offers more than ${CHOICE_LIMIT} choices`);
+	if (nameExceeded) faults.push(`schema contains a name longer than 128`);
+	const pending = [schema];
+	const metadata = [false];
+	let position = 0;
+	let stringExceeded = false;
+	let textExceeded = false;
+	let nodeExceeded = false;
+	let text = 0;
+	while (position < pending.length) {
+		const node = pending[position];
+		const inMeta = metadata[position] === true;
+		position += 1;
+		if ((0, _orkestrel_contract.isString)(node)) {
+			if (node.length > 65536) stringExceeded = true;
+			text = Math.min(TEXT_LIMIT + 1, text + node.length);
+			if (text > 1048576) textExceeded = true;
+			continue;
+		}
+		if ((0, _orkestrel_contract.isArray)(node)) {
+			const read = (0, _orkestrel_contract.readArrayEntries)(node);
+			if (!read.success || !read.value.dense) continue;
+			for (const entry of read.value.entries) {
+				if (pending.length >= 16384) {
+					nodeExceeded = true;
+					continue;
+				}
+				pending.push(entry);
+				metadata.push(inMeta);
+			}
+			continue;
+		}
+		if (!(0, _orkestrel_contract.isRecord)(node)) continue;
+		const keys = (0, _orkestrel_contract.attempt)(() => Object.keys(node));
+		if (!keys.success) continue;
+		for (const key of keys.value) {
+			if (inMeta) {
+				if (key.length > 65536) stringExceeded = true;
+				text = Math.min(TEXT_LIMIT + 1, text + key.length);
+				if (text > 1048576) textExceeded = true;
+			}
+			const value = (0, _orkestrel_contract.attempt)(() => node[key]);
+			if (!value.success || value.value === void 0) continue;
+			if (pending.length >= 16384) {
+				nodeExceeded = true;
+				continue;
+			}
+			pending.push(value.value);
+			metadata.push(inMeta || key === "meta");
+		}
+	}
+	if (stringExceeded) faults.push(`schema contains a string longer than ${STRING_LIMIT}`);
+	if (textExceeded) faults.push(`schema retains more than ${TEXT_LIMIT} string code units`);
+	if (nodeExceeded) faults.push(`schema retains more than ${NODE_LIMIT} nodes`);
+	for (let index = 0; index < columnCount; index += 1) {
+		const column = schema.columns[index];
+		if (column === void 0) continue;
+		if (!nodeExceeded && column.meta !== void 0) {
+			if (!(0, _orkestrel_contract.attempt)(() => (0, _orkestrel_contract.cloneJSONRecord)(column.meta)).success) faults.push(`column "${column.key}" has metadata that cannot be owned`);
+		}
+		if (column.key.length === 0) faults.push("column \"\" has an empty key");
+		if (columns.has(column.key)) faults.push(`column "${column.key}" is declared more than once`);
+		columns.add(column.key);
+		if (column.cell === "choice") {
+			const choices = /* @__PURE__ */ new Set();
+			const choiceCount = Math.min(column.choices.length, CHOICE_LIMIT + 1);
+			for (let choiceIndex = 0; choiceIndex < choiceCount; choiceIndex += 1) {
+				const choice = column.choices[choiceIndex];
+				if (choice === void 0) continue;
+				if (choices.has(choice.value)) faults.push(`column "${column.key}" offers choice "${choice.value}" more than once`);
+				choices.add(choice.value);
+			}
+			if (column.choices.length === 0) faults.push(`column "${column.key}" offers no choices`);
+		}
+	}
+	const key = extractColumn(schema, schema.key);
+	if (key === void 0) faults.push(`schema key "${schema.key}" names no declared column`);
+	else if (key.cell === "number" || key.cell === "flag") faults.push(`schema key "${schema.key}" names a ${key.cell} column, which holds no identity`);
+	return Object.freeze(faults);
+}
+/**
+* Project a schema into declaration-ordered JSON.
+*
+* @param schema - The schema to project.
+* @returns A deeply owned JSON record with absent members omitted.
+* @throws A {@link TableError} coded `SCHEMA` when metadata cannot be owned.
+*/
+function serializeTable(schema) {
+	const output = {};
+	if (schema.name !== void 0) output.name = schema.name;
+	if (schema.label !== void 0) output.label = schema.label;
+	if (schema.help !== void 0) output.help = schema.help;
+	output.key = schema.key;
+	output.columns = schema.columns.map((column) => {
+		const entry = {
+			cell: column.cell,
+			key: column.key
+		};
+		if (column.label !== void 0) entry.label = column.label;
+		if (column.help !== void 0) entry.help = column.help;
+		if (column.hidden !== void 0) entry.hidden = column.hidden;
+		if (column.meta !== void 0) entry.meta = column.meta;
+		if (column.cell === "choice") entry.choices = column.choices.map((choice) => {
+			const option = {
+				value: choice.value,
+				label: choice.label
+			};
+			if (choice.help !== void 0) option.help = choice.help;
+			return option;
+		});
+		return entry;
+	});
+	try {
+		return (0, _orkestrel_contract.cloneJSONRecord)(output);
+	} catch (error) {
+		if (!(0, _orkestrel_contract.isContractError)(error)) throw error;
+		throw new TableError("SCHEMA", "schema contains metadata that cannot be owned");
+	}
+}
+/**
+* Project rows into schema-column-ordered JSON.
+*
+* @param schema - The schema that fixes cell order.
+* @param rows - The rows to project.
+* @returns A frozen list of owned JSON records with absent cells omitted.
+*/
+function serializeRows(schema, rows) {
+	const output = [];
+	for (const row of rows) {
+		const entry = {};
+		for (const column of schema.columns) {
+			if (!Object.hasOwn(row, column.key)) continue;
+			const value = row[column.key];
+			if (value === void 0) continue;
+			Object.defineProperty(entry, column.key, {
+				value,
+				enumerable: true,
+				configurable: true,
+				writable: true
+			});
+		}
+		output.push((0, _orkestrel_contract.cloneJSONRecord)(entry));
+	}
+	return Object.freeze(output);
+}
+//#endregion
+//#region src/core/validators.ts
+/**
+* Determine whether an unknown value has a table cell shape.
+*
+* @param input - The value to inspect.
+* @returns Whether the value is a string, finite number, or boolean.
+*/
+function isTableCell(input) {
+	return (0, _orkestrel_contract.unionOf)(_orkestrel_contract.isString, _orkestrel_contract.isFiniteNumber, _orkestrel_contract.isBoolean)(input);
+}
+/**
+* Determine whether an unknown value is a record of table cells.
+*
+* @param input - The value to inspect.
+* @returns Whether every own key is a string and every value is a table cell.
+*/
+function isTableRow(input) {
+	const outcome = (0, _orkestrel_contract.attempt)(() => {
+		if (!(0, _orkestrel_contract.isRecord)(input)) return false;
+		return Reflect.ownKeys(input).every((key) => (0, _orkestrel_contract.isString)(key) && Object.hasOwn(input, key) && isTableCell(input[key]));
+	});
+	return outcome.success && outcome.value;
+}
+/**
+* Determine whether an unknown value is a declared column cell.
+*
+* @param input - The value to inspect.
+* @returns Whether the value is one of the four column cells.
+*/
+function isColumnCell(input) {
+	return COLUMN_CELLS.some((cell) => cell === input);
+}
+/**
+* Determine whether an unknown value is one exact column choice record.
+*
+* @param input - The value to inspect.
+* @returns Whether the value is a column choice.
+*/
+function isColumnChoice(input) {
+	const outcome = (0, _orkestrel_contract.attempt)(() => {
+		if (!(0, _orkestrel_contract.isRecord)(input) || !Reflect.ownKeys(input).every((key) => (0, _orkestrel_contract.isString)(key))) return false;
+		return (0, _orkestrel_contract.recordOf)({
+			value: _orkestrel_contract.isString,
+			label: _orkestrel_contract.isString,
+			help: _orkestrel_contract.isString
+		}, ["help"])(input);
+	});
+	return outcome.success && outcome.value;
+}
+/**
+* Determine whether an unknown value is one exact discriminated table column.
+*
+* @param input - The value to inspect.
+* @returns Whether the value is a structurally valid table column.
+*/
+function isTableColumn(input) {
+	const outcome = (0, _orkestrel_contract.attempt)(() => {
+		if (!(0, _orkestrel_contract.isRecord)(input) || !Object.hasOwn(input, "cell") || !Object.hasOwn(input, "key")) return false;
+		const cell = input.cell;
+		if (!isColumnCell(cell)) return false;
+		if (!Reflect.ownKeys(input).every((key) => {
+			if (!(0, _orkestrel_contract.isString)(key)) return false;
+			if ([
+				"cell",
+				"key",
+				"label",
+				"help",
+				"hidden",
+				"meta"
+			].includes(key)) return true;
+			return cell === "choice" && key === "choices";
+		})) return false;
+		const key = input.key;
+		const hasLabel = Object.hasOwn(input, "label");
+		const label = hasLabel ? input.label : void 0;
+		const hasHelp = Object.hasOwn(input, "help");
+		const help = hasHelp ? input.help : void 0;
+		const hasHidden = Object.hasOwn(input, "hidden");
+		const hidden = hasHidden ? input.hidden : void 0;
+		const hasMeta = Object.hasOwn(input, "meta");
+		const meta = hasMeta ? input.meta : void 0;
+		if (hasMeta) {
+			if (!(0, _orkestrel_contract.isBoundedJSONRecord)(meta)) return false;
+			if (!(0, _orkestrel_contract.attempt)(() => (0, _orkestrel_contract.cloneJSONRecord)(meta)).success) return false;
+		}
+		if (!(0, _orkestrel_contract.isString)(key) || hasLabel && !(0, _orkestrel_contract.isString)(label) || hasHelp && !(0, _orkestrel_contract.isString)(help) || hasHidden && !(0, _orkestrel_contract.isBoolean)(hidden)) return false;
+		if (cell !== "choice") return !Object.hasOwn(input, "choices");
+		return Object.hasOwn(input, "choices") && (0, _orkestrel_contract.arrayOf)(isColumnChoice)(input.choices);
+	});
+	return outcome.success && outcome.value;
+}
+/**
+* Determine whether an unknown value has one exact structural table-schema shape.
+*
+* @param input - The value to inspect.
+* @returns Whether the value has the exact structure of a table schema.
+*/
+function isStructuralTableSchema(input) {
+	const outcome = (0, _orkestrel_contract.attempt)(() => {
+		if (!(0, _orkestrel_contract.isRecord)(input) || !Reflect.ownKeys(input).every((key) => (0, _orkestrel_contract.isString)(key))) return false;
+		return (0, _orkestrel_contract.recordOf)({
+			name: _orkestrel_contract.isString,
+			label: _orkestrel_contract.isString,
+			help: _orkestrel_contract.isString,
+			key: _orkestrel_contract.isString,
+			columns: (0, _orkestrel_contract.arrayOf)(isTableColumn)
+		}, [
+			"name",
+			"label",
+			"help"
+		])(input);
+	});
+	return outcome.success && outcome.value;
+}
+/**
+* Determine whether an unknown value is one semantically sound table schema.
+*
+* @param input - The value to inspect.
+* @returns Whether the value has valid structure, domain relationships, and budgets.
+*/
+function isTableSchema(input) {
+	const outcome = (0, _orkestrel_contract.attempt)(() => isStructuralTableSchema(input) && auditTable(input).length === 0);
+	return outcome.success && outcome.value;
+}
+//#endregion
+//#region src/core/cloners.ts
+/**
+* Clone one row into an owned frozen snapshot.
+*
+* @param row - The row to own.
+* @returns A frozen copy of the row's cells.
+*/
+function cloneRow(row) {
+	return Object.freeze({ ...row });
+}
+/**
+* Clone a table schema into an owned frozen snapshot.
+*
+* @param schema - The schema to own.
+* @returns A frozen schema with every nested column, choice, list, and metadata record owned.
+*/
+function cloneSchema(schema) {
+	return Object.freeze({
+		...schema,
+		columns: Object.freeze(schema.columns.map((column) => {
+			let meta = {};
+			if (column.meta !== void 0) try {
+				meta = { meta: (0, _orkestrel_contract.cloneJSONRecord)(column.meta) };
+			} catch (error) {
+				if (!(0, _orkestrel_contract.isContractError)(error)) throw error;
+				throw new TableError("SCHEMA", `column "${column.key}" has metadata that cannot be owned`, { column: column.key });
+			}
+			if (column.cell === "choice") return Object.freeze({
+				...column,
+				...meta,
+				choices: Object.freeze(column.choices.map((choice) => Object.freeze({ ...choice })))
+			});
+			return Object.freeze({
+				...column,
+				...meta
+			});
+		}))
+	});
+}
+//#endregion
+//#region src/core/parsers.ts
+/**
+* Parse unknown wire data into an owned, semantically sound table schema.
+*
+* @param input - The unknown schema value to parse.
+* @returns An owned table schema, or `undefined` on refusal.
+*/
+function parseTable(input) {
+	const outcome = (0, _orkestrel_contract.attempt)(() => {
+		if (!isTableSchema(input)) return void 0;
+		const projected = serializeTable(input);
+		return isTableSchema(projected) ? projected : void 0;
+	});
+	return outcome.success ? outcome.value : void 0;
+}
+/**
+* Parse unknown wire rows against one table schema.
+*
+* @param schema - The schema that declares the accepted keys and cell shapes.
+* @param input - The unknown row-list value to parse.
+* @returns Frozen owned rows, or `undefined` when any row is refused.
+*/
+function parseRows(schema, input) {
+	const outcome = (0, _orkestrel_contract.attempt)(() => {
+		if (!isTableSchema(schema) || !(0, _orkestrel_contract.isArray)(input)) return;
+		const read = (0, _orkestrel_contract.readArrayEntries)(input);
+		if (!read.success || !read.value.dense) return void 0;
+		const keys = /* @__PURE__ */ new Set();
+		const rows = [];
+		for (const candidate of read.value.entries) {
+			if (!(0, _orkestrel_contract.isRecord)(candidate)) return void 0;
+			const row = {};
+			for (const key of Reflect.ownKeys(candidate)) {
+				if (!(0, _orkestrel_contract.isString)(key) || !Object.hasOwn(candidate, key)) return void 0;
+				const column = extractColumn(schema, key);
+				if (column === void 0) return void 0;
+				const inputCell = candidate[key];
+				let cell = inputCell;
+				if (column.cell === "number" && (0, _orkestrel_contract.isString)(inputCell)) {
+					if (inputCell.length > 65536) return void 0;
+					cell = (0, _orkestrel_contract.parseNumber)(inputCell);
+				} else if (column.cell === "flag" && inputCell === "true") cell = true;
+				else if (column.cell === "flag" && inputCell === "false") cell = false;
+				if (!matchesCell(column, cell)) return void 0;
+				Object.defineProperty(row, key, {
+					value: cell,
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			}
+			const owned = cloneRow(row);
+			const key = extractKey(schema, owned);
+			if (key === void 0 || keys.has(key)) return void 0;
+			keys.add(key);
+			rows.push(owned);
+		}
+		return Object.freeze(rows);
+	});
+	return outcome.success ? outcome.value : void 0;
+}
+//#endregion
+//#region src/core/tables/ExpansionManager.ts
+/** The keys of the rows somebody has opened. */
+var ExpansionManager = class {
+	#emitter;
+	#gate;
+	#rows;
+	#read;
+	#write;
+	/**
+	* Create an expansion manager over one table's private stores.
+	*
+	* @param emitter - The table's event emitter.
+	* @param gate - The table lifecycle gate.
+	* @param rows - A read of every row key.
+	* @param read - A read of the expanded keys.
+	* @param write - The expanded-key commit boundary.
+	*/
+	constructor(emitter, gate, rows, read, write) {
+		this.#emitter = emitter;
+		this.#gate = gate;
+		this.#rows = rows;
+		this.#read = read;
+		this.#write = write;
+	}
+	/** The keys of the rows opened right now. */
+	get keys() {
+		return new Set(this.#read());
+	}
+	/** Open one or more rows. */
+	expand(input) {
+		this.#gate();
+		return this.#change(input, () => true);
+	}
+	/** Close one or more rows. */
+	clear(input) {
+		this.#gate();
+		return this.#change(input, () => false);
+	}
+	/** Turn one or more rows around independently. */
+	toggle(input) {
+		this.#gate();
+		return this.#change(input, (included) => !included) === true;
+	}
+	#change(input, include) {
+		const previous = this.#read();
+		const next = computeKeys(this.#rows(), previous, input, include);
+		if (next === void 0) return false;
+		if (next !== previous) {
+			this.#write(next);
+			this.#emitter.emit("expand", new Set(next));
+		}
+		return input === void 0 ? void 0 : true;
+	}
+};
+//#endregion
+//#region src/core/tables/FilterManager.ts
+/** The filters one table applies with and-only composition. */
+var FilterManager = class {
+	#schema;
+	#emitter;
+	#gate;
+	#read;
+	#write;
+	#clamp;
+	/**
+	* Create a filter manager over one table's private filter store.
+	*
+	* @param schema - The table schema.
+	* @param emitter - The table's event emitter.
+	* @param gate - The table lifecycle gate.
+	* @param read - A read of the current filters.
+	* @param write - The filter commit boundary.
+	* @param clamp - The pagination clamp commit after a filter commit.
+	*/
+	constructor(schema, emitter, gate, read, write, clamp) {
+		this.#schema = schema;
+		this.#emitter = emitter;
+		this.#gate = gate;
+		this.#read = read;
+		this.#write = write;
+		this.#clamp = clamp;
+	}
+	/** Find one column's filter. */
+	filter(column) {
+		const filter = this.#read().find((candidate) => candidate.column === column);
+		return filter === void 0 ? void 0 : Object.freeze({ ...filter });
+	}
+	/** Read every filter as an owned frozen snapshot. */
+	filters() {
+		return Object.freeze(this.#read().map((filter) => Object.freeze({ ...filter })));
+	}
+	/** Filter one column or several. */
+	set(input) {
+		this.#gate();
+		const requested = Array.isArray(input) ? input : [input];
+		for (const filter of requested) this.#validate(filter);
+		const next = [...this.#read()];
+		for (const filter of requested) {
+			const owned = Object.freeze({ ...filter });
+			const index = next.findIndex((candidate) => candidate.column === filter.column);
+			if (index === -1) next.push(owned);
+			else next[index] = owned;
+		}
+		if (this.#same(next, this.#read())) return;
+		this.#write(Object.freeze(next));
+		const page = this.#clamp();
+		this.#emitter.emit("filter", this.filters());
+		if (page !== void 0) this.#emitter.emit("paginate", page);
+	}
+	/** Stop filtering by one or more columns. */
+	remove(input) {
+		this.#gate();
+		const columns = input === void 0 ? this.#schema.columns.map((column) => column.key) : Array.isArray(input) ? input : [input];
+		for (const column of columns) if (extractColumn(this.#schema, column) === void 0) return false;
+		const removed = new Set(columns);
+		const next = this.#read().filter((filter) => !removed.has(filter.column));
+		if (next.length !== this.#read().length) {
+			this.#write(Object.freeze(next));
+			const page = this.#clamp();
+			this.#emitter.emit("filter", this.filters());
+			if (page !== void 0) this.#emitter.emit("paginate", page);
+		}
+		return input === void 0 ? void 0 : true;
+	}
+	#validate(filter) {
+		const column = extractColumn(this.#schema, filter.column);
+		if (column === void 0) throw new TableError("COLUMN", `The schema declares no column named "${filter.column}"`, { column: filter.column });
+		if (!admitsFilter(column, filter)) throw new TableError("CELL", `Column "${filter.column}" cannot apply that filter`, { column: filter.column });
+	}
+	#same(left, right) {
+		return left.length === right.length && left.every((filter, index) => {
+			const other = right[index];
+			if (other === void 0 || filter.column !== other.column || filter.operator !== other.operator) return false;
+			if (filter.operator === "contains" && other.operator === "contains") return filter.text === other.text;
+			if (filter.operator === "between" && other.operator === "between") return filter.minimum === other.minimum && filter.maximum === other.maximum;
+			return filter.operator === "equals" && other.operator === "equals" && filter.value === other.value;
+		});
+	}
+};
+//#endregion
+//#region src/core/tables/PaginationManager.ts
+/** The page arithmetic over one table's filtered rows. */
+var PaginationManager = class {
+	#emitter;
+	#gate;
+	#rows;
+	#readPage;
+	#writePage;
+	#readLimit;
+	#writeLimit;
+	/**
+	* Create a pagination manager over one table's private stores.
+	*
+	* @param emitter - The table's event emitter.
+	* @param gate - The table lifecycle gate.
+	* @param rows - A read of the filtered row count.
+	* @param readPage - A read of the current page.
+	* @param writePage - The page commit boundary.
+	* @param readLimit - A read of the current page size.
+	* @param writeLimit - The page-size commit boundary.
+	*/
+	constructor(emitter, gate, rows, readPage, writePage, readLimit, writeLimit) {
+		this.#emitter = emitter;
+		this.#gate = gate;
+		this.#rows = rows;
+		this.#readPage = readPage;
+		this.#writePage = writePage;
+		this.#readLimit = readLimit;
+		this.#writeLimit = writeLimit;
+		const limit = this.#readLimit();
+		if (limit !== void 0) this.#writeLimit(this.#normalize(limit));
+	}
+	/** The page shown, counted from one. */
+	get page() {
+		return this.#readLimit() === void 0 ? 1 : this.#readPage();
+	}
+	/** The number of rows one page holds. */
+	get limit() {
+		return this.#readLimit();
+	}
+	/** The number of filtered rows skipped before this page. */
+	get offset() {
+		const limit = this.#readLimit();
+		return limit === void 0 ? 0 : (this.#readPage() - 1) * limit;
+	}
+	/** The number of pages filled by the filtered rows. */
+	get count() {
+		const limit = this.#readLimit();
+		return limit === void 0 ? 1 : Math.max(1, Math.ceil(this.#rows() / limit));
+	}
+	/** Show another page, clamped to the pages that exist. */
+	move(page) {
+		this.#gate();
+		const next = this.#readLimit() === void 0 ? 1 : Math.min(this.count, this.#normalize(page));
+		if (next === this.#readPage()) return;
+		this.#writePage(next);
+		this.#emitter.emit("paginate", next);
+	}
+	/** Change the page size while keeping the first row previously shown. */
+	resize(limit) {
+		this.#gate();
+		const previous = this.#readLimit();
+		const nextLimit = limit === void 0 ? void 0 : this.#normalize(limit);
+		if (previous === nextLimit) return;
+		const anchor = previous === void 0 ? 0 : (this.#readPage() - 1) * previous;
+		this.#writeLimit(nextLimit);
+		const nextPage = nextLimit === void 0 ? 1 : Math.min(Math.max(1, Math.floor(anchor / nextLimit) + 1), this.count);
+		this.#writePage(nextPage);
+		this.#emitter.emit("paginate", nextPage);
+	}
+	#normalize(value) {
+		return Number.isFinite(value) ? Math.max(1, Math.trunc(value)) : 1;
+	}
+};
+//#endregion
+//#region src/core/tables/RowManager.ts
+/** The rows one table holds in its own order. */
+var RowManager = class {
+	#schema;
+	#emitter;
+	#gate;
+	#read;
+	#write;
+	#settle;
+	/**
+	* Create a row manager over one table's private row store.
+	*
+	* @param schema - The table schema.
+	* @param emitter - The table's event emitter.
+	* @param gate - The table lifecycle gate.
+	* @param read - A read of the current rows.
+	* @param write - The row commit boundary.
+	* @param settle - Commit dependent state, then order row and dependent announcements.
+	* @param rows - Rows to seed without announcements.
+	*/
+	constructor(schema, emitter, gate, read, write, settle, rows = []) {
+		this.#schema = schema;
+		this.#emitter = emitter;
+		this.#gate = gate;
+		this.#read = read;
+		this.#write = write;
+		this.#settle = settle;
+		const seeded = this.#prepare(rows, /* @__PURE__ */ new Set());
+		if (seeded.length > 0) this.#write(Object.freeze(seeded));
+	}
+	/** Find one row by key as an owned frozen snapshot. */
+	row(key) {
+		const row = this.#read().find((candidate) => extractKey(this.#schema, candidate) === key);
+		return row === void 0 ? void 0 : cloneRow(row);
+	}
+	/** Read every row as owned frozen snapshots in table order. */
+	rows() {
+		return Object.freeze(this.#read().map((row) => cloneRow(row)));
+	}
+	/** Append one row or several. */
+	add(input) {
+		this.#gate();
+		const rows = Array.isArray(input) ? input : [input];
+		const keys = /* @__PURE__ */ new Set();
+		for (const row of this.#read()) {
+			const key = extractKey(this.#schema, row);
+			if (key !== void 0) keys.add(key);
+		}
+		const added = this.#prepare(rows, keys);
+		if (added.length === 0) return;
+		this.#write(Object.freeze([...this.#read(), ...added]));
+		this.#settle([], () => {
+			for (const row of added) {
+				const key = extractKey(this.#schema, row);
+				if (key !== void 0) this.#emitter.emit("write", key);
+			}
+		});
+	}
+	/** Merge one row or several into the rows their keys name. */
+	update(input) {
+		this.#gate();
+		const updates = (Array.isArray(input) ? input : [input]).map((row) => cloneRow(row));
+		const current = this.#read();
+		const locations = [];
+		for (const update of updates) {
+			this.#validate(update);
+			const key = extractKey(this.#schema, update);
+			if (key === void 0) this.#failKey("A row has no usable identity");
+			const index = current.findIndex((row) => extractKey(this.#schema, row) === key);
+			if (index === -1) return false;
+			locations.push(index);
+		}
+		const next = [...current];
+		const moved = [];
+		for (let index = 0; index < updates.length; index += 1) {
+			const update = updates[index];
+			const location = locations[index];
+			if (update === void 0 || location === void 0) continue;
+			const previous = next[location];
+			if (previous === void 0) continue;
+			const merged = cloneRow({
+				...previous,
+				...update
+			});
+			if (!this.#same(previous, merged)) {
+				next[location] = merged;
+				const key = extractKey(this.#schema, merged);
+				if (key !== void 0) moved.push(key);
+			}
+		}
+		if (moved.length === 0) return true;
+		this.#write(Object.freeze(next));
+		this.#settle([], () => {
+			for (const key of moved) this.#emitter.emit("write", key);
+		});
+		return true;
+	}
+	/** Move one row to a clamped index in table order. */
+	move(key, index) {
+		this.#gate();
+		const current = this.#read();
+		const origin = current.findIndex((row) => extractKey(this.#schema, row) === key);
+		if (origin === -1) return false;
+		const target = Math.min(current.length - 1, Number.isFinite(index) ? Math.max(0, Math.trunc(index)) : 0);
+		if (origin === target) return true;
+		const row = current[origin];
+		if (row === void 0) return false;
+		const next = [...current];
+		next.splice(origin, 1);
+		next.splice(target, 0, row);
+		this.#write(Object.freeze(next));
+		this.#settle([], () => this.#emitter.emit("write", key));
+		return true;
+	}
+	/** Remove one or more rows. */
+	remove(input) {
+		this.#gate();
+		const current = this.#read();
+		const requested = input === void 0 ? current.flatMap((row) => {
+			const key = extractKey(this.#schema, row);
+			return key === void 0 ? [] : [key];
+		}) : Array.isArray(input) ? input : [input];
+		const keys = new Set(requested);
+		const known = new Set(current.flatMap((row) => {
+			const key = extractKey(this.#schema, row);
+			return key === void 0 ? [] : [key];
+		}));
+		if ([...keys].some((key) => !known.has(key))) return false;
+		if (keys.size === 0) return input === void 0 ? void 0 : true;
+		const removed = current.flatMap((row) => {
+			const key = extractKey(this.#schema, row);
+			return key !== void 0 && keys.has(key) ? [key] : [];
+		});
+		this.#write(Object.freeze(current.filter((row) => {
+			const key = extractKey(this.#schema, row);
+			return key === void 0 || !keys.has(key);
+		})));
+		this.#settle(removed, () => {
+			for (const key of removed) this.#emitter.emit("remove", key);
+		});
+		return input === void 0 ? void 0 : true;
+	}
+	#prepare(rows, existing) {
+		const owned = [];
+		for (const row of rows) {
+			const snapshot = cloneRow(row);
+			this.#validate(snapshot);
+			const key = extractKey(this.#schema, snapshot);
+			if (key === void 0) this.#failKey("A row has no usable identity");
+			if (existing.has(key)) this.#failKey(`Row key "${key}" is already taken`, key);
+			existing.add(key);
+			owned.push(snapshot);
+		}
+		return owned;
+	}
+	#validate(row) {
+		if (extractKey(this.#schema, row) === void 0) this.#failKey("A row has no usable identity");
+		if (!isTableRow(row)) throw new TableError("CELL", "A row contains a value no table cell can hold");
+		for (const key of Object.keys(row)) {
+			const column = extractColumn(this.#schema, key);
+			if (column === void 0 || !matchesCell(column, row[key])) throw new TableError("CELL", `Column "${key}" cannot hold that cell`, { column: key });
+		}
+	}
+	#failKey(message, key) {
+		if (key === void 0) throw new TableError("KEY", message);
+		throw new TableError("KEY", message, { key });
+	}
+	#same(left, right) {
+		const leftKeys = Object.keys(left);
+		const rightKeys = Object.keys(right);
+		return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.hasOwn(right, key) && left[key] === right[key]);
+	}
+};
+//#endregion
+//#region src/core/tables/SelectionManager.ts
+/** The keys of the rows somebody has picked. */
+var SelectionManager = class {
+	#emitter;
+	#gate;
+	#rows;
+	#read;
+	#write;
+	/**
+	* Create a selection manager over one table's private stores.
+	*
+	* @param emitter - The table's event emitter.
+	* @param gate - The table lifecycle gate.
+	* @param rows - A read of every row key.
+	* @param read - A read of the selected keys.
+	* @param write - The selected-key commit boundary.
+	*/
+	constructor(emitter, gate, rows, read, write) {
+		this.#emitter = emitter;
+		this.#gate = gate;
+		this.#rows = rows;
+		this.#read = read;
+		this.#write = write;
+	}
+	/** The keys of the rows picked right now. */
+	get keys() {
+		return new Set(this.#read());
+	}
+	/** Pick one or more rows. */
+	select(input) {
+		this.#gate();
+		return this.#change(input, () => true);
+	}
+	/** Drop one or more picks. */
+	clear(input) {
+		this.#gate();
+		return this.#change(input, () => false);
+	}
+	/** Turn one or more rows around independently. */
+	toggle(input) {
+		this.#gate();
+		return this.#change(input, (included) => !included) === true;
+	}
+	#change(input, include) {
+		const previous = this.#read();
+		const next = computeKeys(this.#rows(), previous, input, include);
+		if (next === void 0) return false;
+		if (next !== previous) {
+			this.#write(next);
+			this.#emitter.emit("select", new Set(next));
+		}
+		return input === void 0 ? void 0 : true;
+	}
+};
+//#endregion
+//#region src/core/tables/SortManager.ts
+/** The ordered sort terms of one table. */
+var SortManager = class {
+	#schema;
+	#emitter;
+	#gate;
+	#read;
+	#write;
+	/**
+	* Create a sort manager over one table's private term store.
+	*
+	* @param schema - The table schema.
+	* @param emitter - The table's event emitter.
+	* @param gate - The table lifecycle gate.
+	* @param read - A read of the current terms.
+	* @param write - The term commit boundary.
+	*/
+	constructor(schema, emitter, gate, read, write) {
+		this.#schema = schema;
+		this.#emitter = emitter;
+		this.#gate = gate;
+		this.#read = read;
+		this.#write = write;
+	}
+	/** Find one column's sort term. */
+	order(column) {
+		const order = this.#read().find((candidate) => candidate.column === column);
+		return order === void 0 ? void 0 : Object.freeze({ ...order });
+	}
+	/** Read every sort term as an owned frozen snapshot. */
+	orders() {
+		return Object.freeze(this.#read().map((order) => Object.freeze({ ...order })));
+	}
+	/** Sort by one column or several. */
+	set(input) {
+		this.#gate();
+		const requested = Array.isArray(input) ? input : [input];
+		for (const order of requested) this.#require(order.column);
+		const next = [...this.#read()];
+		for (const order of requested) {
+			const owned = Object.freeze({ ...order });
+			const index = next.findIndex((candidate) => candidate.column === order.column);
+			if (index === -1) next.push(owned);
+			else next[index] = owned;
+		}
+		if (this.#same(next, this.#read())) return;
+		const committed = Object.freeze(next);
+		this.#write(committed);
+		this.#emitter.emit("sort", this.orders());
+	}
+	/** Stop sorting by one or more columns. */
+	remove(input) {
+		this.#gate();
+		const columns = input === void 0 ? this.#schema.columns.map((column) => column.key) : Array.isArray(input) ? input : [input];
+		for (const column of columns) if (extractColumn(this.#schema, column) === void 0) return false;
+		const removed = new Set(columns);
+		const next = this.#read().filter((order) => !removed.has(order.column));
+		if (next.length !== this.#read().length) {
+			this.#write(Object.freeze(next));
+			this.#emitter.emit("sort", this.orders());
+		}
+		return input === void 0 ? void 0 : true;
+	}
+	#require(column) {
+		if (extractColumn(this.#schema, column) === void 0) throw new TableError("COLUMN", `The schema declares no column named "${column}"`, { column });
+	}
+	#same(left, right) {
+		return left.length === right.length && left.every((order, index) => {
+			const other = right[index];
+			return other !== void 0 && order.column === other.column && order.direction === other.direction;
+		});
+	}
+};
+//#endregion
+//#region src/core/Table.ts
+/** A schema, its rows, and the lens through which they are read. */
+var Table = class {
+	#emitter;
+	#schema;
+	#comparators;
+	#matchers;
+	#initialLimit;
+	#rowStore = Object.freeze([]);
+	#orderStore = Object.freeze([]);
+	#filterStore = Object.freeze([]);
+	#selected = /* @__PURE__ */ new Set();
+	#expanded = /* @__PURE__ */ new Set();
+	#page = 1;
+	#limit;
+	#destroyed = false;
+	#rows;
+	#sort;
+	#filter;
+	#selection;
+	#expansion;
+	#pagination;
+	/**
+	* Open a table against a schema.
+	*
+	* @param schema - The table declaration to own.
+	* @param options - Initial rows, lens overrides, pagination, and emitter wiring.
+	* @throws A {@link TableError} coded `SCHEMA` when the schema is unusable, `KEY` when a seeded
+	*   identity is unusable or repeated, and `CELL` when a seeded cell is invalid.
+	*/
+	constructor(schema, options) {
+		const problems = isStructuralTableSchema(schema) ? auditTable(schema) : ["The schema is not a table schema"];
+		if (problems.length > 0) throw new TableError("SCHEMA", `The table schema is unusable: ${problems.join("; ")}`, { problems: [...problems] });
+		this.#schema = cloneSchema(schema);
+		this.#comparators = options?.comparators === void 0 ? void 0 : Object.freeze({ ...options.comparators });
+		this.#matchers = options?.matchers === void 0 ? void 0 : Object.freeze({ ...options.matchers });
+		this.#limit = options?.limit;
+		this.#emitter = new _orkestrel_emitter.Emitter({
+			...options?.on === void 0 ? {} : { on: options.on },
+			...options?.error === void 0 ? {} : { error: options.error }
+		});
+		this.#selection = new SelectionManager(this.#emitter, () => this.#gate(), () => this.#keys(), () => this.#selected, (keys) => {
+			this.#selected = keys;
+		});
+		this.#expansion = new ExpansionManager(this.#emitter, () => this.#gate(), () => this.#keys(), () => this.#expanded, (keys) => {
+			this.#expanded = keys;
+		});
+		this.#pagination = new PaginationManager(this.#emitter, () => this.#gate(), () => this.count, () => this.#page, (page) => {
+			this.#page = page;
+		}, () => this.#limit, (limit) => {
+			this.#limit = limit;
+		});
+		this.#initialLimit = this.#limit;
+		this.#sort = new SortManager(this.#schema, this.#emitter, () => this.#gate(), () => this.#orderStore, (orders) => {
+			this.#orderStore = orders;
+		});
+		this.#filter = new FilterManager(this.#schema, this.#emitter, () => this.#gate(), () => this.#filterStore, (filters) => {
+			this.#filterStore = filters;
+		}, () => this.#clamp());
+		this.#rows = new RowManager(this.#schema, this.#emitter, () => this.#gate(), () => this.#rowStore, (rows) => {
+			this.#rowStore = rows;
+		}, (removed, announce) => this.#settle(removed, announce), options?.rows);
+	}
+	/** The table's event emitter. */
+	get emitter() {
+		return this.#emitter;
+	}
+	/** The owned frozen schema. */
+	get schema() {
+		return this.#schema;
+	}
+	/** The rows the table holds. */
+	get rows() {
+		return this.#rows;
+	}
+	/** The ordered sort terms. */
+	get sort() {
+		return this.#sort;
+	}
+	/** The filters applied with and-only composition. */
+	get filter() {
+		return this.#filter;
+	}
+	/** The selected row keys. */
+	get selection() {
+		return this.#selection;
+	}
+	/** The expanded row keys. */
+	get expansion() {
+		return this.#expansion;
+	}
+	/** The page arithmetic. */
+	get pagination() {
+		return this.#pagination;
+	}
+	/** The filtered, sorted, and paged rows as owned frozen snapshots. */
+	get view() {
+		const ordered = sortRows(this.#schema, this.#filtered(), this.#orderStore, this.#comparators);
+		const limit = this.#limit;
+		const page = limit === void 0 ? ordered : ordered.slice(this.#pagination.offset, this.#pagination.offset + limit);
+		return Object.freeze(page.map((row) => cloneRow(row)));
+	}
+	/** The number of rows admitted by the filters. */
+	get count() {
+		return this.#filtered().length;
+	}
+	/** Whether the table has been torn down. */
+	get destroyed() {
+		return this.#destroyed;
+	}
+	/** Reset every moving axis to its opening state. */
+	clear() {
+		this.#gate();
+		if (!(this.#rowStore.length > 0 || this.#orderStore.length > 0 || this.#filterStore.length > 0 || this.#selected.size > 0 || this.#expanded.size > 0 || this.#page !== 1 || this.#limit !== this.#initialLimit)) return;
+		this.#rowStore = Object.freeze([]);
+		this.#orderStore = Object.freeze([]);
+		this.#filterStore = Object.freeze([]);
+		this.#selected = /* @__PURE__ */ new Set();
+		this.#expanded = /* @__PURE__ */ new Set();
+		this.#page = 1;
+		this.#limit = this.#initialLimit;
+		this.#emitter.emit("clear");
+	}
+	/** Tear the table down while leaving every getter readable. */
+	destroy() {
+		if (this.#destroyed) return;
+		this.#destroyed = true;
+		this.#emitter.destroy();
+	}
+	#filtered() {
+		return filterRows(this.#schema, this.#rowStore, this.#filterStore, this.#matchers);
+	}
+	#keys() {
+		return this.#rowStore.flatMap((row) => {
+			const key = extractKey(this.#schema, row);
+			return key === void 0 ? [] : [key];
+		});
+	}
+	#settle(removed, announce) {
+		const keys = new Set(removed);
+		const selected = new Set([...this.#selected].filter((key) => !keys.has(key)));
+		const expanded = new Set([...this.#expanded].filter((key) => !keys.has(key)));
+		const selectedChanged = selected.size !== this.#selected.size;
+		const expandedChanged = expanded.size !== this.#expanded.size;
+		if (selectedChanged) this.#selected = selected;
+		if (expandedChanged) this.#expanded = expanded;
+		const page = this.#clamp();
+		announce();
+		if (selectedChanged) this.#emitter.emit("select", new Set(selected));
+		if (expandedChanged) this.#emitter.emit("expand", new Set(expanded));
+		if (page !== void 0) this.#emitter.emit("paginate", page);
+	}
+	#clamp() {
+		const page = Math.min(this.#page, this.#pagination.count);
+		if (page === this.#page) return void 0;
+		this.#page = page;
+		return page;
+	}
+	#gate() {
+		if (this.#destroyed) throw new TableError("DESTROYED", "The table was destroyed and cannot change");
+	}
+};
+//#endregion
+//#region src/core/factories.ts
+/**
+* Open a table against a schema.
+*
+* @param schema - The table declaration to own.
+* @param options - Initial rows, lens overrides, pagination, and emitter wiring.
+* @returns A live table interface.
+* @throws A {@link TableError} coded `SCHEMA` when the schema is unusable, `KEY` when a seeded
+*   identity is unusable or repeated, and `CELL` when a seeded cell is invalid.
+* @example
+* ```ts
+* const table = createTable({ key: 'id', columns: [{ cell: 'text', key: 'id' }] })
+* table.rows.add({ id: '1' })
+* ```
+*/
+function createTable(schema, options) {
+	return new Table(schema, options);
+}
+//#endregion
+exports.CHOICE_LIMIT = CHOICE_LIMIT;
+exports.COLUMN_CELLS = COLUMN_CELLS;
+exports.COLUMN_LIMIT = COLUMN_LIMIT;
+exports.ExpansionManager = ExpansionManager;
+exports.FilterManager = FilterManager;
+exports.NAME_LIMIT = NAME_LIMIT;
+exports.NODE_LIMIT = NODE_LIMIT;
+exports.PaginationManager = PaginationManager;
+exports.RowManager = RowManager;
+exports.STRING_LIMIT = STRING_LIMIT;
+exports.SelectionManager = SelectionManager;
+exports.SortManager = SortManager;
+exports.TEXT_LIMIT = TEXT_LIMIT;
+exports.Table = Table;
+exports.TableError = TableError;
+exports.admitsFilter = admitsFilter;
+exports.auditTable = auditTable;
+exports.cloneRow = cloneRow;
+exports.cloneSchema = cloneSchema;
+exports.compareCells = compareCells;
+exports.computeKeys = computeKeys;
+exports.createTable = createTable;
+exports.extractColumn = extractColumn;
+exports.extractKey = extractKey;
+exports.filterRows = filterRows;
+exports.isColumnCell = isColumnCell;
+exports.isColumnChoice = isColumnChoice;
+exports.isStructuralTableSchema = isStructuralTableSchema;
+exports.isTableCell = isTableCell;
+exports.isTableColumn = isTableColumn;
+exports.isTableError = isTableError;
+exports.isTableRow = isTableRow;
+exports.isTableSchema = isTableSchema;
+exports.matchesCell = matchesCell;
+exports.matchesFilter = matchesFilter;
+exports.parseRows = parseRows;
+exports.parseTable = parseTable;
+exports.serializeRows = serializeRows;
+exports.serializeTable = serializeTable;
+exports.sortRows = sortRows;
+
+//# sourceMappingURL=index.cjs.map