@atscript/ui-table 0.1.58

package/dist/index.cjs

@@ -0,0 +1,1689 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _atscript_db_client = require("@atscript/db-client");
+let _atscript_ui = require("@atscript/ui");
+let _uniqu_url_builder = require("@uniqu/url/builder");
+let _uniqu_url = require("@uniqu/url");
+//#region src/filters/filter-conditions.ts
+/** Conditions that operate purely on nullability — value is ignored. */
+const NULL_OPS = new Set(["null", "notNull"]);
+/** Check if a condition has a filled/meaningful value. */
+function isFilled(condition) {
+	const { type, value } = condition;
+	if (NULL_OPS.has(type)) return true;
+	if (type === "bw") return value.length >= 2 && value[0] != null && value[1] != null && value[0] !== "" && value[1] !== "";
+	return value.length > 0 && value[0] != null && value[0] !== "";
+}
+/** Check if a condition type requires a second value (between). */
+function hasSecondValue(type) {
+	return type === "bw";
+}
+function isSimpleEq(condition) {
+	return condition.type === "eq" && isFilled(condition);
+}
+const CONDITION_LABELS = {
+	eq: "equals",
+	ne: "not equals",
+	gt: "greater than",
+	gte: "greater or equal",
+	lt: "less than",
+	lte: "less or equal",
+	contains: "contains",
+	starts: "starts with",
+	ends: "ends with",
+	bw: "between",
+	null: "is empty",
+	notNull: "is not empty",
+	regex: "matches pattern"
+};
+/** Human-readable label for a condition type. */
+function conditionLabel(type) {
+	return CONDITION_LABELS[type] ?? type;
+}
+/** Count of fields that have at least one filled condition. */
+function filledFilterCount(filters) {
+	let count = 0;
+	for (const path in filters) if (filters[path].some(isFilled)) count++;
+	return count;
+}
+/** Summarize a field's conditions into a human-readable token label. */
+function filterTokenLabel(path, conditions, columnLabel) {
+	const filled = conditions.filter(isFilled);
+	if (filled.length === 0) return "";
+	const label = columnLabel ?? path;
+	if (filled.length === 1) {
+		const c = filled[0];
+		if (c.type === "null") return `${label}: empty`;
+		if (c.type === "notNull") return `${label}: not empty`;
+		if (c.type === "bw") return `${label}: ${c.value[0]} – ${c.value[1]}`;
+		return `${label} ${conditionLabel(c.type)} ${c.value[0]}`;
+	}
+	return `${label}: ${filled.length} conditions`;
+}
+//#endregion
+//#region src/filters/filter-conditions-map.ts
+const TEXT_CONDITIONS = [
+	"eq",
+	"ne",
+	"contains",
+	"starts",
+	"ends",
+	"bw",
+	"null",
+	"notNull",
+	"regex"
+];
+const NUMBER_CONDITIONS = [
+	"eq",
+	"ne",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"bw",
+	"null",
+	"notNull"
+];
+const BOOLEAN_CONDITIONS = [
+	"eq",
+	"ne",
+	"null",
+	"notNull"
+];
+const DATE_CONDITIONS = [
+	"eq",
+	"ne",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"bw",
+	"null",
+	"notNull"
+];
+const CONDITIONS_MAP = {
+	text: TEXT_CONDITIONS,
+	number: NUMBER_CONDITIONS,
+	boolean: BOOLEAN_CONDITIONS,
+	date: DATE_CONDITIONS,
+	enum: TEXT_CONDITIONS,
+	ref: TEXT_CONDITIONS
+};
+const NON_NULLABLE_CONDITIONS_MAP = {
+	text: TEXT_CONDITIONS.filter((c) => !NULL_OPS.has(c)),
+	number: NUMBER_CONDITIONS.filter((c) => !NULL_OPS.has(c)),
+	boolean: BOOLEAN_CONDITIONS.filter((c) => !NULL_OPS.has(c)),
+	date: DATE_CONDITIONS.filter((c) => !NULL_OPS.has(c)),
+	enum: TEXT_CONDITIONS.filter((c) => !NULL_OPS.has(c)),
+	ref: TEXT_CONDITIONS.filter((c) => !NULL_OPS.has(c))
+};
+/**
+* Available filter conditions for a given column filter type.
+* Non-nullable columns drop `null` / `notNull` since they can never match.
+*/
+function conditionsForType(type, nullable = true) {
+	const map = nullable ? CONDITIONS_MAP : NON_NULLABLE_CONDITIONS_MAP;
+	return map[type] ?? map.text;
+}
+/** Map a ColumnDef display type string to a ColumnFilterType. */
+function columnFilterType(columnType) {
+	switch (columnType) {
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "date": return "date";
+		case "enum": return "enum";
+		case "ref": return "ref";
+		default: return "text";
+	}
+}
+//#endregion
+//#region src/filters/escape-regex.ts
+/** Escape special regex characters in user input for safe embedding in $regex. */
+function escapeRegex(input) {
+	return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Reverse of {@link escapeRegex}. */
+function unescapeRegex(input) {
+	return input.replace(/\\([.*+?^${}()|[\]\\])/g, "$1");
+}
+//#endregion
+//#region src/filters/filter-input-format.ts
+/**
+* Coerce a raw string value to the appropriate JS type for the column.
+* Number columns get numeric values; everything else stays as string.
+*/
+function coerceValue(raw, columnType) {
+	if (columnType === "number") {
+		const n = Number(raw);
+		return Number.isNaN(n) ? raw : n;
+	}
+	return raw;
+}
+/** Default condition type when no symbol matches the input. */
+function defaultCondition(columnType) {
+	switch (columnType) {
+		case "text":
+		case "enum":
+		case "ref": return "contains";
+		default: return "eq";
+	}
+}
+/** Prefix operators in match order (longest first). */
+const PREFIX_OPS = [
+	["!=", "ne"],
+	[">=", "gte"],
+	["<=", "lte"],
+	[">", "gt"],
+	["<", "lt"],
+	["=", "eq"]
+];
+/**
+* Parse a user-typed filter input string into a FilterCondition.
+*
+* Supports operator symbols:
+*   *text*    → contains
+*   text*     → starts with
+*   *text     → ends with
+*   =value    → eq (explicit)
+*   !=value   → ne
+*   >=value   → gte
+*   >value    → gt
+*   <=value   → lte
+*   <value    → lt
+*   lo...hi   → bw (between)
+*   <empty>   → null
+*   !<empty>  → notNull
+*   /pattern/ → regex
+*
+* When no symbol matches, the default depends on columnType:
+*   text/enum/ref → contains
+*   number/date/boolean → eq
+*
+* Returns undefined for empty/invalid input or if the parsed operator
+* is not available for the column type.
+*/
+function parseFilterInput(text, columnType, nullable = true) {
+	const trimmed = text.trim();
+	if (trimmed === "") return void 0;
+	const available = conditionsForType(columnType, nullable);
+	const isNumber = columnType === "number";
+	const build = (type, value) => {
+		if (!available.includes(type)) return void 0;
+		if (isNumber) for (const v of value) {
+			if (typeof v === "string" && v !== "") return void 0;
+			if (typeof v === "number" && Number.isNaN(v)) return void 0;
+		}
+		return {
+			type,
+			value
+		};
+	};
+	const coerce = (raw) => coerceValue(raw, columnType);
+	const lower = trimmed.toLowerCase();
+	if (lower === "!<empty>") return build("notNull", []);
+	if (lower === "<empty>") return build("null", []);
+	if (trimmed.length >= 3 && trimmed[0] === "/" && trimmed[trimmed.length - 1] === "/") {
+		const pattern = trimmed.slice(1, -1);
+		if (pattern === "") return void 0;
+		return build("regex", [pattern]);
+	}
+	const bwIdx = trimmed.indexOf("...");
+	if (bwIdx > 0 && bwIdx + 3 < trimmed.length) {
+		const lo = trimmed.slice(0, bwIdx).trim();
+		const hi = trimmed.slice(bwIdx + 3).trim();
+		if (lo !== "" && hi !== "") return build("bw", [coerce(lo), coerce(hi)]);
+	}
+	for (const [sym, op] of PREFIX_OPS) if (trimmed.startsWith(sym) && trimmed.length > sym.length) {
+		const val = trimmed.slice(sym.length).trim();
+		if (val !== "") return build(op, [coerce(val)]);
+	}
+	if (trimmed.length >= 3 && trimmed[0] === "*" && trimmed[trimmed.length - 1] === "*") {
+		const inner = trimmed.slice(1, -1);
+		if (inner !== "") return build("contains", [inner]);
+	}
+	if (trimmed.length >= 2 && trimmed[trimmed.length - 1] === "*" && trimmed[0] !== "*") {
+		const inner = trimmed.slice(0, -1);
+		if (inner !== "") return build("starts", [inner]);
+	}
+	if (trimmed.length >= 2 && trimmed[0] === "*" && trimmed[trimmed.length - 1] !== "*") {
+		const inner = trimmed.slice(1);
+		if (inner !== "") return build("ends", [inner]);
+	}
+	return build(defaultCondition(columnType), [coerce(trimmed)]);
+}
+/**
+* Format a FilterCondition for chip/token display using operator symbols.
+*
+* Round-trips with parseFilterInput:
+*   formatFilterCondition(parseFilterInput(text, type)) ≈ text
+*/
+function formatFilterCondition(condition) {
+	const { type, value } = condition;
+	const v0 = value[0] != null ? String(value[0]) : "";
+	switch (type) {
+		case "eq": return v0;
+		case "ne": return `!=${v0}`;
+		case "gt": return `>${v0}`;
+		case "gte": return `>=${v0}`;
+		case "lt": return `<${v0}`;
+		case "lte": return `<=${v0}`;
+		case "contains": return `*${v0}*`;
+		case "starts": return `${v0}*`;
+		case "ends": return `*${v0}`;
+		case "bw": return `${v0}...${value[1] != null ? String(value[1]) : ""}`;
+		case "null": return "<empty>";
+		case "notNull": return "!<empty>";
+		case "regex": return `/${v0}/`;
+		default: return v0;
+	}
+}
+//#endregion
+//#region src/filters/filters-to-uniquery.ts
+/** Exclusion condition types — AND'd together per field. */
+const EXCLUSION_TYPES = new Set(["ne", "notNull"]);
+/**
+* Convert a single condition to a Uniquery filter expression.
+* Returns a ComparisonNode with the field as key.
+*/
+function conditionToExpr(field, condition) {
+	const v = condition.value;
+	switch (condition.type) {
+		case "eq": return { [field]: v[0] };
+		case "ne": return { [field]: { $ne: v[0] } };
+		case "gt": return { [field]: { $gt: v[0] } };
+		case "gte": return { [field]: { $gte: v[0] } };
+		case "lt": return { [field]: { $lt: v[0] } };
+		case "lte": return { [field]: { $lte: v[0] } };
+		case "contains": return { [field]: { $regex: `/${escapeRegex(String(v[0]))}/i` } };
+		case "starts": return { [field]: { $regex: `/^${escapeRegex(String(v[0]))}/i` } };
+		case "ends": return { [field]: { $regex: `/${escapeRegex(String(v[0]))}$/i` } };
+		case "bw": return { [field]: {
+			$gte: v[0],
+			$lte: v[1]
+		} };
+		case "null": return { [field]: { $exists: false } };
+		case "notNull": return { [field]: { $exists: true } };
+		case "regex": return { [field]: { $regex: String(v[0]) } };
+	}
+}
+/** Push a group of expressions: unwrap single, wrap multiple with the given operator. */
+function pushGroup(target, items, op) {
+	if (items.length === 1) target.push(items[0]);
+	else if (items.length > 1) target.push({ [op]: items });
+}
+/**
+* Convert UI filter model to a Uniquery FilterExpr.
+*
+* Combination logic:
+* - Per field: inclusion (positive) conditions are OR'd, exclusion (negative) conditions are AND'd.
+* - Across fields: all groups are AND'd at the top level.
+*
+* Returns `undefined` when no filled conditions exist.
+*/
+function filtersToUniqueryFilter(fieldFilters) {
+	const topGroups = [];
+	for (const field in fieldFilters) {
+		const conditions = fieldFilters[field];
+		let inclusions;
+		let exclusions;
+		for (const condition of conditions) {
+			if (!isFilled(condition)) continue;
+			const expr = conditionToExpr(field, condition);
+			if (EXCLUSION_TYPES.has(condition.type)) (exclusions ??= []).push(expr);
+			else (inclusions ??= []).push(expr);
+		}
+		if (inclusions) pushGroup(topGroups, inclusions, "$or");
+		if (exclusions) pushGroup(topGroups, exclusions, "$and");
+	}
+	if (topGroups.length === 0) return void 0;
+	if (topGroups.length === 1) return topGroups[0];
+	return { $and: topGroups };
+}
+//#endregion
+//#region src/filters/uniquery-to-filters.ts
+const SUPPORTED_TYPES = new Set([
+	"eq",
+	"ne",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"contains",
+	"starts",
+	"ends",
+	"bw",
+	"null",
+	"notNull",
+	"regex"
+]);
+function isPrimitive(v) {
+	return typeof v === "string" || typeof v === "number" || typeof v === "boolean";
+}
+const REGEX_LITERAL = /^\/(.*)\/([a-z]*)$/s;
+const STARTS_ANCHOR = /^\^(.+)$/s;
+const ENDS_ANCHOR = /^(.+)\$$/s;
+/**
+* Decode a `$regex` value into a contains/starts/ends/regex `FilterCondition`.
+* The encoder emits case-insensitive `/…/i` wrappers for contains/starts/ends
+* shortcuts; round-trip those back. Anything else falls through as a literal
+* `regex` condition.
+*/
+function regexToCondition(raw) {
+	if (typeof raw !== "string") return null;
+	const m = REGEX_LITERAL.exec(raw);
+	if (!m) return {
+		type: "regex",
+		value: [raw]
+	};
+	const body = m[1];
+	if (m[2] === "i") {
+		const startsM = STARTS_ANCHOR.exec(body);
+		if (startsM) return {
+			type: "starts",
+			value: [unescapeRegex(startsM[1])]
+		};
+		const endsM = ENDS_ANCHOR.exec(body);
+		if (endsM) return {
+			type: "ends",
+			value: [unescapeRegex(endsM[1])]
+		};
+		return {
+			type: "contains",
+			value: [unescapeRegex(body)]
+		};
+	}
+	return {
+		type: "regex",
+		value: [raw]
+	};
+}
+function pushIfPrimitive(out, type, v) {
+	if (!isPrimitive(v)) return;
+	out.push({
+		type,
+		value: [v]
+	});
+}
+/**
+* Decode a per-field operator object (e.g. `{ $gt: 5, $lte: 10 }`) into one or
+* more `FilterCondition`s. Unknown operators are silently dropped.
+*
+* `$gte` + `$lte` on the same field collapse into a single `bw` condition,
+* matching the encoder's behaviour.
+*/
+function decodeFieldOps(ops) {
+	const out = [];
+	const hasGte = "$gte" in ops && isPrimitive(ops.$gte);
+	const hasLte = "$lte" in ops && isPrimitive(ops.$lte);
+	if (hasGte && hasLte) out.push({
+		type: "bw",
+		value: [ops.$gte, ops.$lte]
+	});
+	else {
+		if (hasGte) pushIfPrimitive(out, "gte", ops.$gte);
+		if (hasLte) pushIfPrimitive(out, "lte", ops.$lte);
+	}
+	if ("$eq" in ops) pushIfPrimitive(out, "eq", ops.$eq);
+	if ("$ne" in ops) pushIfPrimitive(out, "ne", ops.$ne);
+	if ("$gt" in ops) pushIfPrimitive(out, "gt", ops.$gt);
+	if ("$lt" in ops) pushIfPrimitive(out, "lt", ops.$lt);
+	if ("$exists" in ops) {
+		if (ops.$exists === false) out.push({
+			type: "null",
+			value: []
+		});
+		else if (ops.$exists === true) out.push({
+			type: "notNull",
+			value: []
+		});
+	}
+	if ("$regex" in ops) {
+		const cond = regexToCondition(ops.$regex);
+		if (cond) out.push(cond);
+	}
+	return out;
+}
+/**
+* Walk a leaf `ComparisonNode` (one or more field=value entries) into the
+* shared `FieldFilters` accumulator. Drops unknown fields and operators.
+*/
+function walkLeaf(node, acc, knownFields) {
+	for (const field in node) {
+		if (field.startsWith("$")) continue;
+		if (knownFields && !knownFields.has(field)) continue;
+		const value = node[field];
+		let conditions;
+		if (value === null || value === void 0) conditions = [{
+			type: "null",
+			value: []
+		}];
+		else if (isPrimitive(value)) conditions = [{
+			type: "eq",
+			value: [value]
+		}];
+		else if (typeof value === "object" && !Array.isArray(value)) conditions = decodeFieldOps(value);
+		else continue;
+		if (conditions.length === 0) continue;
+		const filtered = conditions.filter((c) => SUPPORTED_TYPES.has(c.type));
+		if (filtered.length === 0) continue;
+		if (acc[field]) acc[field] = [...acc[field], ...filtered];
+		else acc[field] = filtered;
+	}
+}
+function walkExpr(expr, acc, knownFields) {
+	if ("$and" in expr && expr.$and) {
+		for (const child of expr.$and) walkExpr(child, acc, knownFields);
+		return;
+	}
+	if ("$or" in expr && expr.$or) {
+		for (const child of expr.$or) walkExpr(child, acc, knownFields);
+		return;
+	}
+	if ("$not" in expr && expr.$not) return;
+	walkLeaf(expr, acc, knownFields);
+}
+/**
+* Convert a Uniquery `FilterExpr` back into the UI's `FieldFilters` shape.
+*
+* Inverse of `filtersToUniqueryFilter`. Drops:
+* - conditions on fields not in `knownFields` (when provided)
+* - operators not in the supported `FilterConditionType` union
+* - `$not` branches (no native UI representation; lossy on hand-crafted URLs)
+*
+* Returns `{}` for an empty/missing expression. Never throws.
+*/
+function uniqueryFilterToFieldFilters(expr, knownFields) {
+	const acc = {};
+	if (!expr) return acc;
+	const known = knownFields == null ? null : knownFields instanceof Set ? knownFields : new Set(knownFields);
+	try {
+		walkExpr(expr, acc, known);
+	} catch {}
+	return acc;
+}
+//#endregion
+//#region src/filters/date-shortcuts.ts
+/**
+* Generate date filter shortcuts relative to the given date (defaults to now).
+* Each shortcut produces a `bw` (between) condition range using ISO date strings (YYYY-MM-DD).
+*/
+function dateShortcuts(now) {
+	const today = now ?? /* @__PURE__ */ new Date();
+	const todayISO = toISO(today);
+	return [
+		{
+			label: "Last 7 Days",
+			dates: [toISO(daysAgo(today, 7)), todayISO]
+		},
+		{
+			label: "Last 30 Days",
+			dates: [toISO(daysAgo(today, 30)), todayISO]
+		},
+		{
+			label: "Month to Date",
+			dates: [toISO(monthStart(today)), todayISO]
+		},
+		{
+			label: "Last 90 Days",
+			dates: [toISO(daysAgo(today, 90)), todayISO]
+		},
+		{
+			label: "Last 6 Months",
+			dates: [toISO(monthsAgo(today, 6)), todayISO]
+		},
+		{
+			label: "Last 12 Months",
+			dates: [toISO(monthsAgo(today, 12)), todayISO]
+		},
+		{
+			label: "Year to Date",
+			dates: [toISO(yearStart(today)), todayISO]
+		}
+	];
+}
+function toISO(date) {
+	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+function daysAgo(from, days) {
+	const d = new Date(from);
+	d.setDate(d.getDate() - days);
+	return d;
+}
+function monthsAgo(from, months) {
+	const d = new Date(from);
+	d.setMonth(d.getMonth() - months);
+	return d;
+}
+function monthStart(date) {
+	return new Date(date.getFullYear(), date.getMonth(), 1);
+}
+function yearStart(date) {
+	return new Date(date.getFullYear(), 0, 1);
+}
+//#endregion
+//#region src/presets/preset-aspects.ts
+const PRESET_ASPECTS = [
+	"columns",
+	"filters",
+	"filterOps",
+	"sorters",
+	"itemsPerPage"
+];
+function derivePresetAspects(content) {
+	if (!content || typeof content !== "object") return [];
+	const out = [];
+	for (const aspect of PRESET_ASPECTS) if (Object.hasOwn(content, aspect)) out.push(aspect);
+	return out;
+}
+//#endregion
+//#region src/presets/preset-wire.ts
+/**
+* Convert in-memory dict-form snapshot to the wire form persisted on the
+* server. Entries-arrays are sorted by `field` so consumers (server-side
+* aspect derivation, dirty detection, equality checks) see a stable order.
+*/
+function toWireSnapshot(snapshot) {
+	const wire = {};
+	if (snapshot.columns) {
+		const { columnNames, columnWidths } = snapshot.columns;
+		const columns = { columnNames };
+		if (columnWidths) {
+			const entries = [];
+			for (const field of Object.keys(columnWidths).toSorted()) entries.push({
+				field,
+				width: columnWidths[field]
+			});
+			if (entries.length > 0) columns.columnWidths = entries;
+		}
+		wire.columns = columns;
+	}
+	if (snapshot.filters) wire.filters = snapshot.filters;
+	if (snapshot.filterOps) {
+		const entries = [];
+		for (const field of Object.keys(snapshot.filterOps).toSorted()) entries.push({
+			field,
+			conditions: snapshot.filterOps[field]
+		});
+		if (entries.length > 0) wire.filterOps = entries;
+	}
+	if (snapshot.sorters) wire.sorters = snapshot.sorters;
+	if (snapshot.itemsPerPage !== void 0) wire.itemsPerPage = snapshot.itemsPerPage;
+	return wire;
+}
+function fromWireSnapshot(wire) {
+	const snapshot = {};
+	if (wire.columns) {
+		const { columnNames, columnWidths } = wire.columns;
+		const columns = { columnNames };
+		if (columnWidths && columnWidths.length > 0) {
+			const dict = {};
+			for (const entry of columnWidths) dict[entry.field] = entry.width;
+			columns.columnWidths = dict;
+		}
+		snapshot.columns = columns;
+	}
+	if (wire.filters) snapshot.filters = wire.filters;
+	if (wire.filterOps && wire.filterOps.length > 0) {
+		const dict = {};
+		for (const entry of wire.filterOps) dict[entry.field] = entry.conditions;
+		snapshot.filterOps = dict;
+	}
+	if (wire.sorters) snapshot.sorters = wire.sorters;
+	if (wire.itemsPerPage !== void 0) snapshot.itemsPerPage = wire.itemsPerPage;
+	return snapshot;
+}
+//#endregion
+//#region src/presets/preset-id.ts
+/** Reserved id namespace for synthetic system presets; rejected on write. */
+const SYSTEM_PRESET_PREFIX = "sys:";
+/** Deterministic id prefix for `type='userConf'` rows: `uc:${user}:${app}:${tableKey}`. */
+const USER_CONF_PREFIX = "uc:";
+/** Deterministic id prefix for `type='appConf'` rows: `ac:${user}:${app}`. */
+const APP_CONF_PREFIX = "ac:";
+/** All prefixes the server owns; client-supplied ids starting with any of these are rejected. */
+const RESERVED_ID_PREFIXES = [
+	SYSTEM_PRESET_PREFIX,
+	"uc:",
+	"ac:"
+];
+/** Always-materialised system preset id; consumer may override label/content. */
+const STANDARD_PRESET_ID = `${SYSTEM_PRESET_PREFIX}standard`;
+function userConfId(user, app, tableKey) {
+	return `uc:${user}:${app}:${tableKey}`;
+}
+function appConfId(user, app) {
+	return `ac:${user}:${app}`;
+}
+function isSystemPresetId(id) {
+	return typeof id === "string" && id.startsWith("sys:");
+}
+/**
+* Auto-prefix a bare system-preset id (`'monitoring'` → `'sys:monitoring'`).
+* Returns the input unchanged if it already carries the prefix.
+*/
+function normaliseSystemPresetId(id) {
+	if (id.startsWith("sys:")) return id;
+	return `${SYSTEM_PRESET_PREFIX}${id}`;
+}
+//#endregion
+//#region src/presets/system-presets.ts
+const DEFAULT_STANDARD_LABEL = "Standard";
+/**
+* Resolve the consumer's `:system-presets` prop into the canonical render
+* order: Standard at index 0 (consumer override or default empty fallback),
+* named system presets in array order. Duplicate ids are dropped with a
+* console.warn (first wins).
+*/
+function resolveSystemPresets(input) {
+	const seen = /* @__PURE__ */ new Set();
+	let standardOverride = null;
+	const named = [];
+	if (input) for (const item of input) {
+		const id = normaliseSystemPresetId(item.id);
+		if (seen.has(id)) {
+			console.warn(`[ui-table] Duplicate system-preset id "${id}"; keeping first.`);
+			continue;
+		}
+		seen.add(id);
+		const preset = {
+			id,
+			label: item.label,
+			content: item.content ?? {}
+		};
+		if (id === STANDARD_PRESET_ID) standardOverride = preset;
+		else named.push(preset);
+	}
+	return [standardOverride ?? {
+		id: STANDARD_PRESET_ID,
+		label: DEFAULT_STANDARD_LABEL,
+		content: {}
+	}, ...named];
+}
+//#endregion
+//#region src/presets/preset-dirty.ts
+/**
+* JSON-stringify with object keys sorted alphabetically at every depth so
+* dict-shaped values (`columnWidths`, `filterOps` after deserialisation)
+* compare structurally regardless of insertion order. Arrays preserve order.
+*
+* Used by the localStorage draft serializer (where a stable string is
+* needed for storage); dirty detection prefers `isDirtyAgainst` (no
+* stringify, short-circuits on first mismatch).
+*/
+function stableStringify(value) {
+	return JSON.stringify(value, (_key, val) => {
+		if (val && typeof val === "object" && !Array.isArray(val)) {
+			const sorted = {};
+			for (const k of Object.keys(val).toSorted()) sorted[k] = val[k];
+			return sorted;
+		}
+		return val;
+	});
+}
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null) return false;
+	if (typeof a !== "object" || typeof b !== "object") return false;
+	const aIsArr = Array.isArray(a);
+	if (aIsArr !== Array.isArray(b)) return false;
+	if (aIsArr) {
+		const aArr = a;
+		const bArr = b;
+		if (aArr.length !== bArr.length) return false;
+		for (let i = 0; i < aArr.length; i++) if (!deepEqual(aArr[i], bArr[i])) return false;
+		return true;
+	}
+	const aObj = a;
+	const bObj = b;
+	const aKeys = Object.keys(aObj);
+	if (aKeys.length !== Object.keys(bObj).length) return false;
+	for (const k of aKeys) {
+		if (!Object.hasOwn(bObj, k)) return false;
+		if (!deepEqual(aObj[k], bObj[k])) return false;
+	}
+	return true;
+}
+/**
+* Per-aspect dirty check: only aspects the active preset claims (key
+* present) are compared. A column-only preset stays clean while filters
+* change; a filter-ops-only preset doesn't dirty when columns reorder.
+*
+* `current` should be the full snapshot of all available aspects (i.e.
+* `captureSnapshot()` output) so each claimed aspect on the active preset
+* has something to compare against.
+*/
+function isDirtyAgainst(active, current) {
+	for (const aspect of PRESET_ASPECTS) {
+		const a = active[aspect];
+		if (a === void 0) continue;
+		const c = current[aspect];
+		if (!deepEqual(a, c)) return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/presets/preset-draft.ts
+/** Aspects eligible for local-draft persistence. `filterOps` is excluded by design. */
+const DRAFT_PERSISTED_ASPECTS = [
+	"columns",
+	"filters",
+	"sorters",
+	"itemsPerPage"
+];
+function aspectAllowed(aspect, availableAspects) {
+	return availableAspects.includes(aspect);
+}
+/**
+* Capture the persisted-aspect subset of a full snapshot. Aspects not in
+* `availableAspects` are skipped (forward-compat: a deploy that toggles an
+* aspect off doesn't error on previously-saved drafts).
+*/
+function serializeDraft(snapshot, availableAspects) {
+	return copyPersistedAspects(snapshot, availableAspects);
+}
+/**
+* Convert a localStorage draft back to a partial snapshot suitable for
+* `applyPreset`. Aspects no longer in `availableAspects` are silently
+* skipped.
+*/
+function deserializeDraft(draft, availableAspects) {
+	return copyPersistedAspects(draft, availableAspects);
+}
+/** True when the draft has zero persisted aspects to apply. */
+function isEmptyDraft(draft) {
+	for (const aspect of DRAFT_PERSISTED_ASPECTS) if (draft[aspect] !== void 0) return false;
+	return true;
+}
+function copyPersistedAspects(source, availableAspects) {
+	const out = {};
+	for (const aspect of DRAFT_PERSISTED_ASPECTS) {
+		if (!aspectAllowed(aspect, availableAspects)) continue;
+		const value = source[aspect];
+		if (value === void 0) continue;
+		out[aspect] = value;
+	}
+	return out;
+}
+/**
+* True when the draft's persisted aspects exactly match the active
+* preset's persisted aspects. Used by the watcher to decide whether to
+* `localStorage.removeItem` instead of writing — keeps storage tidy and
+* avoids `localStorage.length` noise after the user reverts edits.
+*/
+function draftMatchesPreset(draft, presetSnapshot, availableAspects) {
+	const draftSnapshot = deserializeDraft(draft, availableAspects);
+	const presetSubset = serializeDraft(presetSnapshot, availableAspects);
+	return stableStringify(draftSnapshot) === stableStringify(presetSubset);
+}
+//#endregion
+//#region src/presets/presets-client.ts
+/**
+* Framework-agnostic wrapper over `@atscript/db-client`'s `Client` for the
+* `AsPresetEntry` table. Handles wire serialisation, list-splitting by
+* `type`, capabilities side-channel, and 401/403 → `denied` semantics.
+*
+* Stateless: every method is a fresh request. The Vue composable layer
+* holds reactive state; this class only translates intent → HTTP.
+*/
+var PresetsClient = class {
+	url;
+	app;
+	tableKey;
+	client;
+	fetchImpl;
+	constructor(cfg) {
+		if (!cfg.url) throw new Error("PresetsClient: `url` is required");
+		if (!cfg.app) throw new Error("PresetsClient: `app` is required");
+		if (!cfg.tableKey) throw new Error("PresetsClient: `tableKey` is required");
+		this.url = cfg.url;
+		this.app = cfg.app;
+		this.tableKey = cfg.tableKey;
+		this.client = cfg.client ?? (cfg.clientFactory ?? (0, _atscript_ui.getDefaultClientFactory)())(cfg.url);
+		this.fetchImpl = cfg.fetch ?? globalThis.fetch.bind(globalThis);
+	}
+	/**
+	* Lists owned + public preset rows AND the user's userConf row for this
+	* `(app, tableKey)`. By default also fetches `capabilities` in parallel —
+	* pass `{ capabilities: false }` for refresh-after-mutation calls (fav
+	* toggle, default change, save/save-as, public toggle, rename, delete)
+	* where role-derived capabilities can't have changed. Auth errors
+	* (401/403) collapse to `denied: true` with empty data so the UI hides
+	* itself silently.
+	*/
+	async list(opts = {}) {
+		const fetchCapabilities = opts.capabilities !== false;
+		const filter = {
+			app: this.app,
+			tableKey: this.tableKey,
+			type: { $in: ["preset", "userConf"] }
+		};
+		try {
+			const [rows, capabilities] = await Promise.all([this.client.query({ filter }), fetchCapabilities ? this.loadCapabilities().catch((err) => {
+				if (isAuthError(err)) throw err;
+				return null;
+			}) : Promise.resolve(void 0)]);
+			const presets = [];
+			let userConf = null;
+			for (const row of rows) if (row.type === "preset") presets.push(row);
+			else if (row.type === "userConf") userConf = row;
+			return {
+				presets,
+				userConf,
+				capabilities: fetchCapabilities ? capabilities : void 0,
+				denied: false
+			};
+		} catch (err) {
+			if (isAuthError(err)) return {
+				presets: [],
+				userConf: null,
+				capabilities: null,
+				denied: true
+			};
+			throw err;
+		}
+	}
+	/** GET `${url}/capabilities?app=…&tableKey=…`. Out-of-band of CRUD plumbing. */
+	async loadCapabilities() {
+		const params = new URLSearchParams({
+			app: this.app,
+			tableKey: this.tableKey
+		});
+		const target = `${this.url.replace(/\/+$/, "")}/capabilities?${params.toString()}`;
+		const res = await this.fetchImpl(target, {
+			method: "GET",
+			credentials: "same-origin",
+			headers: { Accept: "application/json" }
+		});
+		if (!res.ok) throw new PresetsHttpError(res.status, `Capabilities fetch failed (${res.status})`);
+		return await res.json();
+	}
+	/**
+	* Overwrite the active preset's content. Server shallow-merges `data` so
+	* `label` is preserved on the row regardless — the caller sends it
+	* anyway because the client-side validator can't pick the preset
+	* variant of the `data` union without `label` present (it's required
+	* on that variant).
+	*/
+	async savePreset(id, label, snapshot) {
+		const payload = {
+			id,
+			data: {
+				label,
+				content: toWireSnapshot(snapshot)
+			}
+		};
+		await this.client.update(payload);
+	}
+	/**
+	* Create a new preset row. Server stamps `user`, generates a UUID `id`,
+	* and derives `aspects` from the snapshot keys.
+	*/
+	async savePresetAs(label, snapshot, opts = {}) {
+		const payload = {
+			type: "preset",
+			app: this.app,
+			tableKey: this.tableKey,
+			public: opts.public === true,
+			data: {
+				label,
+				content: toWireSnapshot(snapshot)
+			}
+		};
+		const id = (await this.client.insert(payload))?.insertedId;
+		if (typeof id !== "string" || id.length === 0) throw new Error("PresetsClient.savePresetAs: server did not return an id");
+		return { id };
+	}
+	/** Update only the label. Server re-stamps top-level `label` + `publicLabel`. */
+	async renamePreset(id, label) {
+		const payload = {
+			id,
+			data: { label }
+		};
+		await this.client.update(payload);
+	}
+	/** Toggle `public`. Server re-stamps `publicLabel` accordingly. */
+	async setPublic(id, value) {
+		const payload = {
+			id,
+			public: value
+		};
+		await this.client.update(payload);
+	}
+	async deletePreset(id) {
+		await this.client.remove(id);
+	}
+	/**
+	* Upsert the userConf row keyed on `${USER_CONF_PREFIX}${user}:${app}:${tableKey}`.
+	* Caller must know whether the row exists from a prior `list()` so we
+	* pick the right verb. Server forces `user` and `id` on insert.
+	*/
+	async upsertUserConf(existing, patch, user) {
+		if (existing) {
+			const payload = {
+				id: existing.id,
+				data: patch
+			};
+			await this.client.update(payload);
+			return;
+		}
+		const id = user ? userConfId(user, this.app, this.tableKey) : void 0;
+		const payload = {
+			...id ? { id } : {},
+			type: "userConf",
+			app: this.app,
+			tableKey: this.tableKey,
+			data: patch
+		};
+		await this.client.insert(payload);
+	}
+};
+/**
+* Error raised for non-2xx responses on the capabilities side-channel.
+* Standard CRUD errors flow through `Client`'s `ClientError`.
+*/
+var PresetsHttpError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+		this.name = "PresetsHttpError";
+	}
+};
+/** True for HTTP 401/403 across both `ClientError` and `PresetsHttpError`. */
+function isAuthError(err) {
+	if (err instanceof _atscript_db_client.ClientError && (err.status === 401 || err.status === 403)) return true;
+	if (err instanceof PresetsHttpError && (err.status === 401 || err.status === 403)) return true;
+	return false;
+}
+//#endregion
+//#region src/presets/app-prefs-client.ts
+/**
+* Framework-agnostic wrapper for app-wide user preferences (`type='appConf'`).
+* Independent of the preset/userConf surface — devs use this directly to
+* read/write `appearance`, `language`, `density`, etc., without involving
+* any table.
+*/
+var AppPrefsClient = class {
+	app;
+	client;
+	constructor(cfg) {
+		if (!cfg.url) throw new Error("AppPrefsClient: `url` is required");
+		if (!cfg.app) throw new Error("AppPrefsClient: `app` is required");
+		this.app = cfg.app;
+		this.client = cfg.client ?? (cfg.clientFactory ?? (0, _atscript_ui.getDefaultClientFactory)())(cfg.url);
+	}
+	/** Fetch the single `appConf` row for `(user, app)`. */
+	async load() {
+		const filter = {
+			app: this.app,
+			type: "appConf"
+		};
+		try {
+			const rows = await this.client.query({ filter });
+			const row = rows.length > 0 ? rows[0] : null;
+			return {
+				row,
+				prefs: row ? row.data ?? null : null,
+				denied: false
+			};
+		} catch (err) {
+			if (isAuthError(err)) return {
+				row: null,
+				prefs: null,
+				denied: true
+			};
+			throw err;
+		}
+	}
+	/**
+	* Upsert the `appConf` row. Server forces `id` from session and shallow-
+	* merges `data` so partial patches don't wipe unrelated fields. Caller
+	* passes the prior `existing` row from `load()` so we pick the right verb.
+	*
+	* Returns the row id that owns the value after the write — useful for
+	* state tracking after the first insert (subsequent saves take the
+	* update path).
+	*/
+	async save(existing, patch, user) {
+		if (existing) {
+			const payload = {
+				id: existing.id,
+				data: patch
+			};
+			await this.client.update(payload);
+			return existing.id;
+		}
+		const id = user ? appConfId(user, this.app) : void 0;
+		const payload = {
+			...id ? { id } : {},
+			type: "appConf",
+			app: this.app,
+			data: patch
+		};
+		const result = await this.client.insert(payload);
+		return typeof result?.insertedId === "string" ? result.insertedId : null;
+	}
+};
+//#endregion
+//#region src/query/merge-sorters.ts
+/**
+* Merge force sorters with user sorters.
+*
+* Force sorters come first and take priority — if a field appears
+* in both lists, the force entry wins and the user entry is dropped.
+*/
+function mergeSorters(forceSorters, userSorters) {
+	if (forceSorters.length === 0) return userSorters;
+	if (userSorters.length === 0) return forceSorters;
+	const forceFields = new Set(forceSorters.map((s) => s.field));
+	const deduped = userSorters.filter((s) => !forceFields.has(s.field));
+	return [...forceSorters, ...deduped];
+}
+//#endregion
+//#region src/query/merge-filters.ts
+/**
+* AND-merge two filter expressions, producing a wire shape that survives
+* `@uniqu/url`'s `mergeConjunction` parser collapse.
+*
+* The collapse problem: when two `$and` siblings target the same field
+* with the same op (e.g. `{status: 'cancelled'}` AND `{status: 'shipped'}`),
+* the parser silently merges them on the receiving end and one clause is
+* dropped. This would let a colliding user-side filter erase a
+* `forceFilters` clause, breaking that contract.
+*
+* Fix: detect same-field same-op collisions and wrap each repeat in
+* `$not({$not: ...})`. `$not` nodes are preserved verbatim by the parser,
+* and `!!p ≡ p` is a semantic identity, so the server evaluator sees the
+* same AND. Non-colliding merges produce the canonical `$and` shape.
+*/
+function mergeFilters(a, b) {
+	if (!a) return b;
+	if (!b) return a;
+	return makeParserSafeAnd([a, b]);
+}
+/** Op-set for a field value: primitives are `$eq`, op-bags expose their keys. */
+function getOpsForFieldValue(value) {
+	if (value === null || typeof value !== "object") return new Set(["$eq"]);
+	return new Set(Object.keys(value));
+}
+/** True if `expr` has only field keys (no `$`-prefixed logical operators). */
+function isComparisonNode(expr) {
+	for (const k in expr) if (k.startsWith("$")) return false;
+	return true;
+}
+/** Flatten nested `$and` so collision detection sees all sibling comparison nodes. */
+function flattenAnd(children) {
+	const out = [];
+	for (const child of children) if (child && typeof child === "object" && "$and" in child && Array.isArray(child.$and)) out.push(...flattenAnd(child.$and));
+	else out.push(child);
+	return out;
+}
+function makeParserSafeAnd(children) {
+	const flat = flattenAnd(children);
+	const fieldOps = /* @__PURE__ */ new Map();
+	const collidingFields = /* @__PURE__ */ new Set();
+	for (const node of flat) {
+		if (!isComparisonNode(node)) continue;
+		for (const f in node) {
+			const ops = getOpsForFieldValue(node[f]);
+			const seen = fieldOps.get(f);
+			if (!seen) {
+				fieldOps.set(f, ops);
+				continue;
+			}
+			for (const op of ops) if (seen.has(op)) {
+				collidingFields.add(f);
+				break;
+			}
+			for (const op of ops) seen.add(op);
+		}
+	}
+	if (collidingFields.size === 0) return { $and: flat };
+	const seenColliding = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const node of flat) {
+		if (!isComparisonNode(node)) {
+			out.push(node);
+			continue;
+		}
+		const safe = {};
+		let safeHasKeys = false;
+		for (const f in node) {
+			const v = node[f];
+			if (collidingFields.has(f) && seenColliding.has(f)) out.push({ $not: { $not: { [f]: v } } });
+			else {
+				safe[f] = v;
+				safeHasKeys = true;
+				if (collidingFields.has(f)) seenColliding.add(f);
+			}
+		}
+		if (safeHasKeys) out.push(safe);
+	}
+	return { $and: out };
+}
+//#endregion
+//#region src/query/build-table-query.ts
+/**
+* Build a Uniquery object from table UI state.
+*
+* Pure function — no framework dependencies.
+* Combines user filters with force filters, merges sorters,
+* projects visible columns, and applies pagination.
+*/
+function buildTableQuery(opts) {
+	const userFilter = filtersToUniqueryFilter(opts.filters);
+	const filter = mergeFilters(opts.forceFilters, userFilter);
+	const sorters = opts.forceSorters?.length ? mergeSorters(opts.forceSorters, opts.sorters) : opts.sorters;
+	const $sort = {};
+	for (const s of sorters) $sort[s.field] = s.direction === "asc" ? 1 : -1;
+	const controls = {};
+	if (opts.visibleColumnPaths.length > 0) controls.$select = opts.visibleColumnPaths;
+	if (sorters.length > 0) controls.$sort = $sort;
+	if (opts.search) {
+		const searchKey = opts.searchIndex ? `$search:${opts.searchIndex}` : "$search";
+		controls[searchKey] = opts.search;
+	}
+	if (opts.includeActions) controls.$actions = true;
+	const query = { controls };
+	if (filter) query.filter = filter;
+	return query;
+}
+//#endregion
+//#region src/query/url-query.ts
+function resolveAspectGate(value) {
+	if (value === void 0 || value === true) return "all";
+	if (value === false) return "none";
+	if (value.length === 0) return "none";
+	return new Set(value);
+}
+function pickFilterPaths(filters, allow) {
+	const out = {};
+	for (const path in filters) if (allow.has(path)) out[path] = filters[path];
+	return out;
+}
+/**
+* Serialize the table state subset into a URL query string.
+*
+* Reuses `buildTableQuery` for the filter/sort/search shape (no `$select`,
+* `$actions`, `forceFilters`, `forceSorters` — those are not user state) and
+* appends `$skip` / `$limit` for pagination.
+*
+* Returns `""` (no leading `?`) for the default view.
+*/
+function stateToUrlQueryString(state, defaults) {
+	const filtersGate = resolveAspectGate(defaults.sync?.filters);
+	const sortersGate = resolveAspectGate(defaults.sync?.sorters);
+	const searchOff = defaults.sync?.search === false;
+	const paginationOff = defaults.sync?.pagination === false;
+	const filters = filtersGate === "none" ? {} : filtersGate === "all" ? state.filters : pickFilterPaths(state.filters, filtersGate);
+	const query = buildTableQuery({
+		visibleColumnPaths: [],
+		sorters: sortersGate === "none" ? [] : sortersGate === "all" ? state.sorters : state.sorters.filter((s) => sortersGate.has(s.field)),
+		filters,
+		search: searchOff ? void 0 : state.searchTerm || void 0
+	});
+	if (!paginationOff) {
+		const itemsPerPage = state.itemsPerPage ?? defaults.defaultItemsPerPage;
+		const page = state.page ?? 1;
+		if (page > 1) query.controls.$skip = (page - 1) * itemsPerPage;
+	}
+	return (0, _uniqu_url_builder.buildUrl)(query);
+}
+/**
+* Parse a URL query string back into the table state subset.
+*
+* Robust by design — schema drift and copy-paste errors must not break the
+* recipient's view:
+* - unknown fields (not in `knownFields`) → silently dropped
+* - unsupported operators → silently dropped
+* - unknown controls (e.g. `$weird=42`) → silently ignored
+* - malformed query → `{ filters: {}, sorters: [], searchTerm: "" }`
+*
+* `page` and `itemsPerPage` are returned only when the URL specified them
+* (`$skip` / `$limit`); callers compose them onto state without overwriting
+* defaults when the URL was silent.
+*/
+function urlQueryStringToState(urlString, opts = {}) {
+	if (!urlString) return {
+		filters: {},
+		sorters: [],
+		searchTerm: ""
+	};
+	let parsed;
+	try {
+		parsed = (0, _uniqu_url.parseUrl)(urlString);
+	} catch {
+		return {
+			filters: {},
+			sorters: [],
+			searchTerm: ""
+		};
+	}
+	const filtersGate = resolveAspectGate(opts.sync?.filters);
+	const sortersGate = resolveAspectGate(opts.sync?.sorters);
+	const searchOff = opts.sync?.search === false;
+	const paginationOff = opts.sync?.pagination === false;
+	const knownSet = opts.knownFields ? new Set(opts.knownFields) : null;
+	let filterKnown;
+	if (filtersGate === "all") filterKnown = knownSet ?? void 0;
+	else if (filtersGate !== "none") if (knownSet) {
+		filterKnown = /* @__PURE__ */ new Set();
+		for (const path of filtersGate) if (knownSet.has(path)) filterKnown.add(path);
+	} else filterKnown = filtersGate;
+	const filters = filtersGate === "none" ? {} : uniqueryFilterToFieldFilters(parsed.filter, filterKnown);
+	const sorters = [];
+	if (sortersGate !== "none") {
+		const $sort = parsed.controls?.$sort;
+		if ($sort && typeof $sort === "object") for (const field in $sort) {
+			if (knownSet && !knownSet.has(field)) continue;
+			if (sortersGate !== "all" && !sortersGate.has(field)) continue;
+			const dir = $sort[field];
+			if (dir === 1) sorters.push({
+				field,
+				direction: "asc"
+			});
+			else if (dir === -1) sorters.push({
+				field,
+				direction: "desc"
+			});
+		}
+	}
+	const $search = parsed.controls?.$search;
+	const out = {
+		filters,
+		sorters,
+		searchTerm: !searchOff && typeof $search === "string" ? $search : ""
+	};
+	if (!paginationOff) {
+		const $skip = parsed.controls?.$skip;
+		if (typeof $skip === "number" && $skip > 0 && Number.isFinite($skip)) out.skip = $skip;
+	}
+	return out;
+}
+//#endregion
+//#region src/selection/selection-fns.ts
+/**
+* Toggle a single PK in the selection.
+*
+* - `"none"`: no-op (returns the same array reference).
+* - `"single"`: replaces the selection. Toggling the already-selected PK clears it.
+* - `"multi"`: adds when absent, removes when present. Order preserved on add (append).
+*
+* Always returns a new array on actual mutation; returns the same reference for `"none"`.
+*/
+function togglePk(selection, pk, mode) {
+	if (mode === "none") return selection;
+	if (mode === "single") {
+		if (selection.length === 1 && selection[0] === pk) return [];
+		return [pk];
+	}
+	const idx = selection.indexOf(pk);
+	if (idx === -1) return [...selection, pk];
+	const next = selection.slice();
+	next.splice(idx, 1);
+	return next;
+}
+/**
+* Drop every PK in `selection` that's not in `presentPks`.
+*
+* Returns the same `selection` reference when nothing was dropped, so callers
+* can rely on identity comparison to detect a no-op without an explicit
+* length check.
+*/
+function trimSelection(selection, presentPks) {
+	if (selection.length === 0) return selection;
+	let removedAny = false;
+	const kept = [];
+	for (const v of selection) if (presentPks.has(v)) kept.push(v);
+	else removedAny = true;
+	return removedAny ? kept : selection;
+}
+/** Map rows to their PKs via `rowValueFn`. */
+function rowsToPks(rows, rowValueFn) {
+	const out = [];
+	for (let i = 0; i < rows.length; i++) out.push(rowValueFn(rows[i]));
+	return out;
+}
+//#endregion
+//#region src/state/tokens.ts
+const DEFAULT_ROW_HEIGHT_PX = 32;
+//#endregion
+//#region src/state/window/page-aligned-blocks.ts
+/**
+* Clamp a window's `topIndex` to the valid `[0, totalCount - viewport]` range.
+* `viewport` past `totalCount` (or zero/negative totals) collapses to `0`.
+*/
+function clampTopIndex(topIndex, totalCount, viewport) {
+	const max = Math.max(0, totalCount - viewport);
+	return Math.max(0, Math.min(max, topIndex));
+}
+/** Index of the first row in the block that contains `absIdx`. */
+function blockStartFor(absIdx, blockSize) {
+	return Math.floor(absIdx / blockSize) * blockSize;
+}
+function pageAlignedBlocksFor(skip, limit, blockSize) {
+	if (limit <= 0 || blockSize <= 0) return [];
+	const start = Math.max(0, skip);
+	const end = start + limit;
+	const firstBlock = Math.floor(start / blockSize);
+	const lastBlock = Math.floor((end - 1) / blockSize);
+	const blocks = [];
+	for (let b = firstBlock; b <= lastBlock; b++) blocks.push({
+		page: b + 1,
+		firstIndex: b * blockSize
+	});
+	return blocks;
+}
+//#endregion
+//#region src/state/window/results-merge.ts
+function walkForwardAbsorb(results, resultsStart, cache) {
+	let idx = resultsStart + results.length;
+	const tail = [];
+	while (cache.has(idx)) {
+		const row = cache.get(idx);
+		if (row === void 0) break;
+		tail.push(row);
+		idx++;
+	}
+	if (tail.length === 0) return {
+		newResults: results,
+		newResultsStart: resultsStart
+	};
+	return {
+		newResults: [...results, ...tail],
+		newResultsStart: resultsStart
+	};
+}
+function walkBackwardAbsorb(results, resultsStart, cache) {
+	let idx = resultsStart - 1;
+	const headReversed = [];
+	while (cache.has(idx)) {
+		const row = cache.get(idx);
+		if (row === void 0) break;
+		headReversed.push(row);
+		idx--;
+	}
+	if (headReversed.length === 0) return {
+		newResults: results,
+		newResultsStart: resultsStart
+	};
+	headReversed.reverse();
+	return {
+		newResults: [...headReversed, ...results],
+		newResultsStart: resultsStart - headReversed.length
+	};
+}
+//#endregion
+//#region src/state/window/plan-fetch.ts
+function planFetch(args) {
+	const { top, viewport, totalCount, cache, blockSize, buffer } = args;
+	if (viewport <= 0) return null;
+	if (top >= totalCount) return null;
+	const start = top;
+	const effectiveViewport = Math.min(viewport, totalCount - start);
+	if (effectiveViewport <= 0) return null;
+	const end = start + effectiveViewport - 1;
+	if (!cache.has(start) && !cache.has(start - 1)) {
+		const half = Math.floor(blockSize / 2);
+		const lookBack = Math.min(half, start);
+		const lookAhead = half;
+		const skip = Math.max(0, start - lookBack);
+		const wantedLimit = effectiveViewport + lookBack + lookAhead;
+		const limit = Math.min(totalCount - skip, wantedLimit);
+		if (limit <= 0) return null;
+		return {
+			skip,
+			limit,
+			mode: "jump"
+		};
+	}
+	let fwdCachedInView = 0;
+	while (fwdCachedInView < effectiveViewport && cache.has(start + fwdCachedInView)) fwdCachedInView++;
+	if (fwdCachedInView < effectiveViewport) {
+		const skip = start + fwdCachedInView;
+		if (skip >= totalCount) return null;
+		return {
+			skip,
+			limit: blockSize,
+			mode: "steady"
+		};
+	}
+	let fwdBuffer = 0;
+	while (cache.has(end + 1 + fwdBuffer)) fwdBuffer++;
+	const forwardEdge = end + 1 + fwdBuffer;
+	if (fwdBuffer < buffer && forwardEdge < totalCount) return {
+		skip: forwardEdge,
+		limit: blockSize,
+		mode: "steady"
+	};
+	let bwdBuffer = 0;
+	while (start - 1 - bwdBuffer >= 0 && cache.has(start - 1 - bwdBuffer)) bwdBuffer++;
+	if (bwdBuffer < buffer && start > 0) {
+		const backwardEdge = start - bwdBuffer;
+		const skip = Math.max(0, backwardEdge - blockSize);
+		const limit = backwardEdge - skip;
+		if (limit <= 0) return null;
+		return {
+			skip,
+			limit,
+			mode: "steady"
+		};
+	}
+	return null;
+}
+//#endregion
+//#region src/columns/column-widths.ts
+/** Upper bound applied only to default-width computation. Annotation widths and manual resize are not capped. */
+const MAX_DEFAULT_COLUMN_WIDTH_PX = 320;
+/**
+* Computes a sane default width for a column from its type + length annotation.
+*
+* Resolution order:
+*   1. col.width (`@ui.table.width` annotation) wins outright.
+*   2. Otherwise pick from a type-based table; for `text` columns with `maxLen`,
+*      derive from char-count using an 8px-per-char heuristic.
+*   3. Cap the result at MAX_DEFAULT_COLUMN_WIDTH_PX (does not apply to step 1).
+*/
+function computeDefaultColumnWidth(col) {
+	if (col.width) return col.width;
+	return `${capDefault(rawDefaultPx(col))}px`;
+}
+function rawDefaultPx(col) {
+	switch (col.type) {
+		case "boolean": return 64;
+		case "number": return 96;
+		case "ref": return 200;
+		case "array":
+		case "object": return 240;
+		case "enum":
+			if (col.options?.length) {
+				let longest = 0;
+				for (const opt of col.options) if (opt.label.length > longest) longest = opt.label.length;
+				return Math.max(96, longest * 8 + 48);
+			}
+			return 160;
+		case "text":
+			if (col.maxLen && col.maxLen > 0) return Math.max(96, col.maxLen * 8 + 32);
+			return 200;
+		default: return 160;
+	}
+}
+function capDefault(px) {
+	if (px < 64) return 64;
+	if (px > 320) return 320;
+	return px;
+}
+/**
+* Reconciles a current ColumnWidthsMap against the latest column list:
+*   - new columns get a fresh `{ w: d, d }` entry where `d = computeDefaultColumnWidth(col)`
+*   - existing columns keep `w` (preserves manual resize) but refresh `d`
+*   - paths no longer present are kept (preserves user widths if columns reappear)
+*
+* Returns a NEW map only when something actually changed; otherwise returns `current`
+* so a shallowRef writer can short-circuit.
+*/
+function reconcileColumnWidthDefaults(allColumns, current) {
+	let next = current;
+	for (const col of allColumns) {
+		const d = computeDefaultColumnWidth(col);
+		const existing = current[col.path];
+		if (!existing) {
+			if (next === current) next = { ...current };
+			next[col.path] = {
+				w: d,
+				d
+			};
+		} else if (existing.d !== d) {
+			if (next === current) next = { ...current };
+			next[col.path] = {
+				w: existing.w,
+				d
+			};
+		}
+	}
+	return next;
+}
+//#endregion
+//#region src/utils/debounce.ts
+/**
+* Creates a debounced version of a function that delays invocation
+* until `ms` milliseconds have elapsed since the last call.
+*/
+function debounce(fn, ms) {
+	let timer;
+	const debounced = ((...args) => {
+		if (timer !== void 0) clearTimeout(timer);
+		timer = setTimeout(() => {
+			timer = void 0;
+			fn(...args);
+		}, ms);
+	});
+	debounced.cancel = () => {
+		if (timer !== void 0) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+	};
+	return debounced;
+}
+//#endregion
+//#region src/utils/equality.ts
+function arraysEqual(a, b) {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+function sameColumnSet(a, b) {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	const set = new Set(a);
+	for (const c of b) if (!set.has(c)) return false;
+	return true;
+}
+function setsEqual(a, b) {
+	if (a === b) return true;
+	if (a.size !== b.size) return false;
+	for (const v of a) if (!b.has(v)) return false;
+	return true;
+}
+function sortersEqual(a, b) {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i].field !== b[i].field || a[i].direction !== b[i].direction) return false;
+	return true;
+}
+//#endregion
+//#region src/utils/reorder-column-names.ts
+/**
+* Permute a column-names array: move `fromPath` next to `toPath` at the
+* resolved insertion side. Pure: returns a new array, never mutates input.
+*
+* Returns the input array unchanged when:
+*   - `fromPath === toPath`
+*   - either path is missing from `names`
+*   - the resolved insertion index leaves the array identical
+*     (e.g. `[a,b,c]` from=`b` to=`a` "after" — `b` is already after `a`).
+*
+* The insertion index is resolved against post-removal positions to keep
+* the math symmetric across left-to-right and right-to-left moves.
+*/
+function reorderColumnNames(names, fromPath, toPath, position) {
+	if (fromPath === toPath) return names;
+	const fromIndex = names.indexOf(fromPath);
+	if (fromIndex === -1) return names;
+	const toIndex = names.indexOf(toPath);
+	if (toIndex === -1) return names;
+	const without = names.slice(0, fromIndex).concat(names.slice(fromIndex + 1));
+	const toIndexAfterRemoval = toIndex > fromIndex ? toIndex - 1 : toIndex;
+	const insertAt = position === "before" ? toIndexAfterRemoval : toIndexAfterRemoval + 1;
+	if (insertAt === fromIndex) return names;
+	return without.slice(0, insertAt).concat(fromPath, without.slice(insertAt));
+}
+//#endregion
+exports.APP_CONF_PREFIX = APP_CONF_PREFIX;
+exports.AppPrefsClient = AppPrefsClient;
+exports.DEFAULT_ROW_HEIGHT_PX = DEFAULT_ROW_HEIGHT_PX;
+exports.DRAFT_PERSISTED_ASPECTS = DRAFT_PERSISTED_ASPECTS;
+exports.MAX_DEFAULT_COLUMN_WIDTH_PX = MAX_DEFAULT_COLUMN_WIDTH_PX;
+exports.NULL_OPS = NULL_OPS;
+exports.PRESET_ASPECTS = PRESET_ASPECTS;
+exports.PresetsClient = PresetsClient;
+exports.PresetsHttpError = PresetsHttpError;
+exports.RESERVED_ID_PREFIXES = RESERVED_ID_PREFIXES;
+exports.STANDARD_PRESET_ID = STANDARD_PRESET_ID;
+exports.SYSTEM_PRESET_PREFIX = SYSTEM_PRESET_PREFIX;
+exports.USER_CONF_PREFIX = USER_CONF_PREFIX;
+exports.appConfId = appConfId;
+exports.arraysEqual = arraysEqual;
+exports.blockStartFor = blockStartFor;
+exports.buildTableQuery = buildTableQuery;
+exports.clampTopIndex = clampTopIndex;
+exports.columnFilterType = columnFilterType;
+exports.computeDefaultColumnWidth = computeDefaultColumnWidth;
+exports.conditionLabel = conditionLabel;
+exports.conditionsForType = conditionsForType;
+exports.dateShortcuts = dateShortcuts;
+exports.debounce = debounce;
+exports.defaultCondition = defaultCondition;
+exports.derivePresetAspects = derivePresetAspects;
+exports.deserializeDraft = deserializeDraft;
+exports.draftMatchesPreset = draftMatchesPreset;
+exports.escapeRegex = escapeRegex;
+exports.filledFilterCount = filledFilterCount;
+exports.filterTokenLabel = filterTokenLabel;
+exports.filtersToUniqueryFilter = filtersToUniqueryFilter;
+exports.formatFilterCondition = formatFilterCondition;
+exports.fromWireSnapshot = fromWireSnapshot;
+exports.hasSecondValue = hasSecondValue;
+exports.isAuthError = isAuthError;
+exports.isDirtyAgainst = isDirtyAgainst;
+exports.isEmptyDraft = isEmptyDraft;
+exports.isFilled = isFilled;
+exports.isSimpleEq = isSimpleEq;
+exports.isSystemPresetId = isSystemPresetId;
+exports.mergeFilters = mergeFilters;
+exports.mergeSorters = mergeSorters;
+exports.normaliseSystemPresetId = normaliseSystemPresetId;
+exports.pageAlignedBlocksFor = pageAlignedBlocksFor;
+exports.parseFilterInput = parseFilterInput;
+exports.planFetch = planFetch;
+exports.reconcileColumnWidthDefaults = reconcileColumnWidthDefaults;
+exports.reorderColumnNames = reorderColumnNames;
+exports.resolveAspectGate = resolveAspectGate;
+exports.resolveSystemPresets = resolveSystemPresets;
+exports.rowsToPks = rowsToPks;
+exports.sameColumnSet = sameColumnSet;
+exports.serializeDraft = serializeDraft;
+exports.setsEqual = setsEqual;
+exports.sortersEqual = sortersEqual;
+exports.stableStringify = stableStringify;
+exports.stateToUrlQueryString = stateToUrlQueryString;
+exports.toWireSnapshot = toWireSnapshot;
+exports.togglePk = togglePk;
+exports.trimSelection = trimSelection;
+exports.unescapeRegex = unescapeRegex;
+exports.uniqueryFilterToFieldFilters = uniqueryFilterToFieldFilters;
+exports.urlQueryStringToState = urlQueryStringToState;
+exports.userConfId = userConfId;
+exports.walkBackwardAbsorb = walkBackwardAbsorb;
+exports.walkForwardAbsorb = walkForwardAbsorb;