@atscript/vue-table 0.1.58

package/dist/use-table-state-C4JbonEZ.mjs

@@ -0,0 +1,1822 @@
+import { getVisibleColumns } from "@atscript/ui";
+import { computed, inject, nextTick, onBeforeUnmount, onScopeDispose, provide, ref, shallowRef, toValue, watch } from "vue";
+import { STANDARD_PRESET_ID, blockStartFor, buildTableQuery, debounce, fromWireSnapshot, isDirtyAgainst, isFilled, isSystemPresetId, pageAlignedBlocksFor, planFetch, reconcileColumnWidthDefaults, resolveAspectGate, resolveSystemPresets, sameColumnSet, sortersEqual, stateToUrlQueryString, togglePk, urlQueryStringToState, walkBackwardAbsorb, walkForwardAbsorb } from "@atscript/ui-table";
+import { formatIdentifier } from "@atscript/db-client";
+//#region src/types.ts
+/** UI-side sentinel for the synthesised row-delete processor. */
+const REMOVE_PROCESSOR = "__remove";
+/** Column `path` and cell-type for the synthesised row-actions pseudo-column. */
+const ROW_ACTIONS_PATH = "__actions";
+const ROW_ACTIONS_TYPE = "__actions";
+//#endregion
+//#region src/composables/state/intent-scope.ts
+/**
+* Processors exempt from the per-row `$actions` gate: `navigate`/`custom`
+* have no backend to ask, and `__remove` is synthesised client-side.
+*/
+const EXEMPT_PROCESSORS = new Set([
+	"navigate",
+	"custom",
+	REMOVE_PROCESSOR
+]);
+/**
+* Build a per-row availability predicate from `row.$actions: string[]`
+* (server-evaluated names of NOT-disabled row/rows-level actions for that
+* row). Returns `null` when the row carries no `$actions` (legacy server,
+* `?$actions` opt-out, or table-level surfaces) so callers can skip the
+* filter pass and keep the source-array reference stable.
+*/
+function rowActionGate(row) {
+	const raw = row?.$actions;
+	if (!Array.isArray(raw)) return null;
+	const allowed = new Set(raw);
+	return (a) => EXEMPT_PROCESSORS.has(a.processor) || allowed.has(a.name);
+}
+/**
+* Apply the per-row `$actions` gate to a `{default, others, rows}` triple.
+* When the row carries no `$actions`, returns the input unchanged so
+* source-array references stay stable downstream (no spurious recomputes
+* in consumers that compare array identity).
+*/
+function applyRowGate(buckets, row) {
+	const gate = rowActionGate(row);
+	if (!gate) return buckets;
+	return {
+		default: buckets.default && gate(buckets.default) ? buckets.default : void 0,
+		others: buckets.others.filter(gate),
+		rows: buckets.rows.filter(gate)
+	};
+}
+/**
+* Map `TDbActionInfo['intent']` (positive/negative/warning/primary/secondary)
+* onto a vunor scope name accepted by `state.prompt()`. Used by row-actions
+* and table-actions cells when surfacing an action's confirmation dialog —
+* `negative → error`, `positive → good`, `warning → warn`, the rest pass
+* through verbatim. Undefined intent → undefined scope (button stays default
+* primary via the dialog's `c8-filled` chrome).
+*/
+function intentToScope(intent) {
+	switch (intent) {
+		case "positive": return "good";
+		case "negative": return "error";
+		case "warning": return "warn";
+		case "primary": return "primary";
+		case "secondary": return "secondary";
+		default: return;
+	}
+}
+/**
+* Build the identifier object to forward to `client.action` / `client.remove`.
+*
+* Per `@atscript/db-client` invariant #11, identifier bodies are object-only
+* — never bare scalars, even for single-field PK tables. This helper accepts:
+* - a row-shaped object (default `rowValueFn`) → picks `preferredId` fields;
+* - a scalar value when `preferredId` has exactly one field (consumers that
+*   override `rowValueFn` to return the PK scalar) → wraps it.
+*
+* Returns `undefined` when no `preferredId` is declared, the source is
+* `null`/`undefined`, or a scalar can't be paired with a single-field
+* identifier.
+*/
+function extractIdentifier(source, preferredId) {
+	if (source === void 0 || source === null) return void 0;
+	if (preferredId.length === 0) return void 0;
+	if (typeof source === "object" && !Array.isArray(source)) {
+		const row = source;
+		const out = {};
+		for (const k of preferredId) out[k] = row[k];
+		return out;
+	}
+	if (preferredId.length === 1) return { [preferredId[0]]: source };
+}
+/**
+* Map a list of sources (full row objects or scalar `rowValueFn` values)
+* through `extractIdentifier`. Scalar sources rehydrate from
+* `state.windowCache` via `state.rowValueFn` so consumers that override
+* `rowValueFn` to return a scalar can still reconstruct multi-field
+* identifiers; the lookup `Map` is built lazily so all-object source
+* lists pay nothing.
+*/
+function collectIdentifiers(state, sources, preferredId) {
+	if (preferredId.length === 0 || sources.length === 0) return [];
+	const out = [];
+	let lookup = null;
+	for (const s of sources) {
+		if (s === void 0 || s === null) continue;
+		let row;
+		if (typeof s === "object") row = s;
+		else {
+			if (lookup === null) {
+				const fn = state.rowValueFn;
+				lookup = /* @__PURE__ */ new Map();
+				for (const r of state.windowCache.value.values()) lookup.set(fn(r), r);
+			}
+			row = lookup.get(s);
+		}
+		const id = extractIdentifier(row ?? s, preferredId);
+		if (id) out.push(id);
+	}
+	return out;
+}
+function ariaLabelFor(action) {
+	return action.label || action.name;
+}
+/**
+* Compose the runtime intent class — `as-{prefix}-intent-{intent}` — applied
+* by both `<AsRowActions>` and `<AsTableActions>` on buttons + menu items.
+* Returns `undefined` when the action declares no intent so callers can
+* spread the result into a class array without conditional plumbing.
+*/
+function intentClass(prefix, action) {
+	return action.intent ? `${prefix}-intent-${action.intent}` : void 0;
+}
+/**
+* Run `state.prompt()` if the action declares a `promptText`. Resolves
+* `true` on accept, or `true` immediately when no prompt is needed.
+*
+* `promptText` may be a string or `[singular, plural]` tuple. Tuple form
+* picks `singular` when there is at most one identifier, `plural` otherwise.
+* Substitutions:
+* - `$1` → `formatIdentifier(ctx.identifiers[0], ctx.preferredId)`
+* - `$N` → `String(ctx.identifiers.length)`
+*/
+async function confirmAction(state, action, ctx) {
+	const raw = action.promptText;
+	if (!raw) return true;
+	const count = ctx.identifiers.length;
+	const message = substitute(Array.isArray(raw) ? count <= 1 ? raw[0] : raw[1] : raw, ctx);
+	return state.prompt(message, { scope: intentToScope(action.intent) });
+}
+/** Substitute `$1` and `$N` into a prompt-text template. */
+function substitute(template, ctx) {
+	return template.replace(/\$1/g, () => formatIdentifier(ctx.identifiers[0], ctx.preferredId)).replace(/\$N/g, () => String(ctx.identifiers.length));
+}
+/**
+* Dispatch user-initiated invocation: actions with `inputForm` open the form
+* dialog (the form IS the confirm surface, so `promptText` is ignored);
+* others run `confirmAction()`. Cancelling either dialog short-circuits.
+*/
+async function triggerAction(state, action, ctx, event) {
+	const pk = pkForLevel(action.level, ctx.identifiers);
+	if (action.inputForm) {
+		const input = await state.requestActionInput(action, ctx);
+		if (input === null) return;
+		state.actions.invoke(action, pk, {
+			event,
+			input
+		});
+		return;
+	}
+	if (!await confirmAction(state, action, ctx)) return;
+	state.actions.invoke(action, pk, { event });
+}
+/**
+* Pick the `pk` argument to forward to `state.actions.invoke` based on the
+* action's level. `'table'` → `undefined`; `'row'` → first identifier;
+* `'rows'` → full array.
+*/
+function pkForLevel(level, ids) {
+	if (level === "table") return void 0;
+	if (level === "row") return ids[0];
+	return ids;
+}
+/**
+* Inverse of `pkForLevel`: shape the `ids[]` surfaced by the `@action` emit
+* from the `pk` value passed to `invoke`.
+*/
+function idsForAction(level, pk) {
+	if (level === "table") return [];
+	if (level === "rows") return Array.isArray(pk) ? pk : pk === void 0 ? [] : [pk];
+	return pk === void 0 ? [] : [pk];
+}
+//#endregion
+//#region src/composables/state/create-actions.ts
+const REMOVE_NAME = REMOVE_PROCESSOR;
+const REMOVE_DEFAULTS = {
+	label: "Delete",
+	icon: "i-as-trash",
+	intent: "negative",
+	promptText: ["Delete item $1?", "Delete $N items?"]
+};
+function createActions(opts) {
+	const invoking = shallowRef(/* @__PURE__ */ new Set());
+	const lastResult = shallowRef(/* @__PURE__ */ new Map());
+	const groups = computed(() => buildGroups(opts.tableDef.value, opts.rowDelete()));
+	watch(opts.tableDef, () => {
+		if (lastResult.value.size > 0) lastResult.value = /* @__PURE__ */ new Map();
+	});
+	function setInvoking(name, on) {
+		const next = new Set(invoking.value);
+		if (on) next.add(name);
+		else next.delete(name);
+		invoking.value = next;
+	}
+	function setLastResult(name, result) {
+		const next = new Map(lastResult.value);
+		next.set(name, result);
+		lastResult.value = next;
+	}
+	async function invoke(action, pk, callOpts) {
+		const name = action.name;
+		setInvoking(name, true);
+		let result;
+		try {
+			switch (action.processor) {
+				case "custom":
+					result = {
+						ok: true,
+						kind: "custom",
+						dispatched: true
+					};
+					break;
+				case "navigate":
+					await opts.client.action(action.name, pk);
+					result = {
+						ok: true,
+						kind: "navigate"
+					};
+					break;
+				case REMOVE_PROCESSOR:
+					result = {
+						ok: true,
+						kind: "remove",
+						data: await opts.client.remove(pk)
+					};
+					break;
+				default: {
+					const data = await opts.client.action(action.name, pk, callOpts?.input);
+					result = {
+						ok: true,
+						kind: "backend",
+						data,
+						message: typeof data === "object" && data !== null && "message" in data ? data.message : void 0
+					};
+					break;
+				}
+			}
+		} catch (err) {
+			result = {
+				ok: false,
+				kind: "error",
+				error: err instanceof Error ? err : new Error(String(err))
+			};
+		}
+		setLastResult(name, result);
+		setInvoking(name, false);
+		if (callOpts?.suppressRefresh !== true && opts.refreshOnAction() !== false && result.ok && (result.kind === "backend" || result.kind === "remove")) opts.scheduleQuery("query");
+		if (opts.onResolved) opts.onResolved(action, idsForAction(action.level, pk), result, callOpts?.event);
+		return result;
+	}
+	return {
+		actions: {
+			get table() {
+				return groups.value.table;
+			},
+			get row() {
+				return groups.value.row;
+			},
+			get rows() {
+				return groups.value.rows;
+			},
+			get default() {
+				return groups.value.default;
+			},
+			get others() {
+				return groups.value.others;
+			},
+			get cellRow() {
+				return groups.value.cellRow;
+			},
+			invoke,
+			invoking,
+			lastResult
+		},
+		groups
+	};
+}
+const EMPTY_GROUPS = Object.freeze({
+	table: [],
+	row: [],
+	rows: [],
+	default: {},
+	others: {
+		table: [],
+		row: [],
+		rows: []
+	},
+	cellRow: []
+});
+function buildGroups(def, rowDelete) {
+	if (def === null) return EMPTY_GROUPS;
+	const srcActions = def.actions ?? {
+		table: [],
+		row: [],
+		rows: [],
+		default: {}
+	};
+	const table = srcActions.table;
+	const row = srcActions.row.slice();
+	const rows = srcActions.rows;
+	if (rowDelete && def.canRemove) row.push(buildRemoveAction(rowDelete === true ? {} : rowDelete));
+	const defTable = srcActions.default.table;
+	const defRow = srcActions.default.row;
+	const defRows = srcActions.default.rows;
+	const othersTable = defTable ? table.filter((a) => a !== defTable) : table;
+	const othersRow = defRow ? row.filter((a) => a !== defRow) : row;
+	const othersRows = defRows ? rows.filter((a) => a !== defRows) : rows;
+	const cellRow = defRow ? [
+		defRow,
+		...othersRow,
+		...rows
+	] : othersRow.length > 0 || rows.length > 0 ? [...othersRow, ...rows] : [];
+	return {
+		table,
+		row,
+		rows,
+		default: {
+			table: defTable,
+			row: defRow,
+			rows: defRows
+		},
+		others: {
+			table: othersTable,
+			row: othersRow,
+			rows: othersRows
+		},
+		cellRow
+	};
+}
+function buildRemoveAction(opts) {
+	return {
+		name: REMOVE_NAME,
+		label: opts.label ?? REMOVE_DEFAULTS.label,
+		level: "row",
+		processor: REMOVE_PROCESSOR,
+		value: "",
+		icon: opts.icon ?? REMOVE_DEFAULTS.icon,
+		intent: opts.intent ?? REMOVE_DEFAULTS.intent,
+		promptText: opts.confirm ?? REMOVE_DEFAULTS.promptText
+	};
+}
+//#endregion
+//#region src/composables/state/create-selection.ts
+function createSelectionApi(opts, getActiveRow) {
+	const selectedRows = opts?.selectedRows ?? shallowRef([]);
+	const selectedCount = computed(() => selectedRows.value.length);
+	const rowValueFn = opts?.rowValueFn ?? ((row) => row);
+	const selectedSet = computed(() => new Set(selectedRows.value));
+	function isPkSelected(pk) {
+		return selectedSet.value.has(pk);
+	}
+	function toggleActiveSelection(mode) {
+		if (mode === "none") return;
+		const row = getActiveRow();
+		if (row === void 0) return;
+		selectedRows.value = togglePk(selectedRows.value, rowValueFn(row), mode);
+	}
+	return {
+		selectedRows,
+		selectedCount,
+		selectedSet,
+		rowValueFn,
+		isPkSelected,
+		toggleActiveSelection
+	};
+}
+//#endregion
+//#region src/composables/state/create-main-action-registry.ts
+/**
+* Listener registry for the `main-action` event. When listeners are present,
+* `requestMainAction` builds a `MainActionRequest` and dispatches it. When no
+* listener is registered, falls back to invoking `actions.default.row` against
+* the active row's PK (if both are defined). The fallback path SHALL NOT
+* construct a `MainActionRequest` payload — there is nothing to receive it.
+*/
+function createMainActionRegistry(opts) {
+	const listeners = /* @__PURE__ */ new Set();
+	const hasMainActionListener = ref(false);
+	const hasMainActionAvailable = computed(() => hasMainActionListener.value || opts.getDefaultRowAction?.() !== void 0);
+	function registerMainActionListener(cb) {
+		listeners.add(cb);
+		hasMainActionListener.value = listeners.size > 0;
+		let disposed = false;
+		return () => {
+			if (disposed) return;
+			disposed = true;
+			listeners.delete(cb);
+			hasMainActionListener.value = listeners.size > 0;
+		};
+	}
+	function requestMainAction(event) {
+		const abs = opts.getActiveIndex();
+		if (abs < 0) return;
+		const row = opts.getActiveRow();
+		if (row === void 0) return;
+		if (listeners.size > 0) {
+			const req = {
+				row,
+				absIndex: abs,
+				event
+			};
+			for (const cb of listeners) cb(req);
+			return;
+		}
+		const fallback = opts.getDefaultRowAction?.();
+		if (fallback && opts.invokeFallback) opts.invokeFallback(fallback, row, event);
+	}
+	return {
+		hasMainActionListener,
+		hasMainActionAvailable,
+		registerMainActionListener,
+		requestMainAction
+	};
+}
+//#endregion
+//#region src/composables/state/create-nav-controller.ts
+function createNavController(inputs) {
+	const { activeIndex, totalCount, results, viewportRowCount, topIndex, hasMainActionAvailable, requestMainAction, toggleActiveSelection } = inputs;
+	const navMode = ref("pagination");
+	const navViewportRowCount = ref(0);
+	function clampActive(idx) {
+		let upper;
+		if (navMode.value === "window") upper = totalCount.value;
+		else {
+			const r = results.value.length;
+			const t = totalCount.value;
+			if (r === 0) upper = t;
+			else if (t === 0) upper = 0;
+			else upper = Math.min(r, t);
+		}
+		if (upper === 0) return -1;
+		if (idx === -1) return -1;
+		if (idx < 0) return 0;
+		if (idx > upper - 1) return upper - 1;
+		return idx;
+	}
+	function setActive(absIndex) {
+		const next = clampActive(absIndex);
+		if (next !== activeIndex.value) activeIndex.value = next;
+	}
+	function clearActive() {
+		if (activeIndex.value !== -1) activeIndex.value = -1;
+	}
+	watch([
+		() => totalCount.value,
+		() => results.value.length,
+		() => navMode.value
+	], () => setActive(activeIndex.value));
+	function pageStep() {
+		return Math.max(viewportRowCount.value, navViewportRowCount.value, 10) - 1;
+	}
+	function activeBase() {
+		return activeIndex.value < 0 ? topIndex.value : activeIndex.value;
+	}
+	function navStep(delta) {
+		if (activeIndex.value < 0) setActive(topIndex.value);
+		else setActive(activeIndex.value + delta);
+	}
+	function navPage(delta) {
+		setActive(activeBase() + delta);
+	}
+	function handleNavKey(event, opts) {
+		if (totalCount.value === 0) return;
+		const enterAction = opts?.enterAction ?? "main-action";
+		const mode = opts?.mode ?? "none";
+		const key = event.key;
+		const meta = event.metaKey;
+		const ctrl = event.ctrlKey;
+		const alt = event.altKey;
+		if (key === "ArrowDown" && (meta || ctrl)) {
+			event.preventDefault();
+			setActive(totalCount.value - 1);
+			return;
+		}
+		if (key === "ArrowUp" && (meta || ctrl)) {
+			event.preventDefault();
+			setActive(0);
+			return;
+		}
+		if (key === "ArrowDown" && alt) {
+			event.preventDefault();
+			navPage(pageStep());
+			return;
+		}
+		if (key === "ArrowUp" && alt) {
+			event.preventDefault();
+			navPage(-pageStep());
+			return;
+		}
+		switch (key) {
+			case "ArrowDown":
+				event.preventDefault();
+				navStep(1);
+				return;
+			case "ArrowUp":
+				event.preventDefault();
+				navStep(-1);
+				return;
+			case "PageDown":
+				event.preventDefault();
+				navPage(pageStep());
+				return;
+			case "PageUp":
+				event.preventDefault();
+				navPage(-pageStep());
+				return;
+			case "Home":
+				event.preventDefault();
+				setActive(0);
+				return;
+			case "End":
+				event.preventDefault();
+				setActive(totalCount.value - 1);
+				return;
+			case " ":
+				if (mode === "none") return;
+				event.preventDefault();
+				toggleActiveSelection(mode);
+				return;
+			case "Enter":
+				if (enterAction === "passthrough") return;
+				event.preventDefault();
+				if (enterAction === "toggle-select") {
+					toggleActiveSelection(mode);
+					return;
+				}
+				if (mode !== "none") {
+					toggleActiveSelection(mode);
+					return;
+				}
+				if (hasMainActionAvailable.value) requestMainAction(event);
+				return;
+			case "Escape":
+			case "Esc":
+				clearActive();
+				return;
+		}
+	}
+	return {
+		navMode,
+		navViewportRowCount,
+		setActive,
+		clearActive,
+		handleNavKey
+	};
+}
+//#endregion
+//#region src/composables/state/create-preset-state.ts
+const DEFAULT_AVAILABLE_ASPECTS = [
+	"columns",
+	"filters",
+	"filterOps",
+	"sorters"
+];
+/**
+* Default `columnNames` for a system preset that doesn't specify them — every
+* column whose schema declares it visible (i.e. lacking `@ui.table.hidden`).
+* Used by both `apply` (no-explicit-columnNames fallback) and `expandDefault`,
+* so the two paths can never drift apart.
+*/
+function defaultVisibleColumnPaths(o) {
+	const out = [];
+	for (const col of o.allColumns.value) if (col.visible) out.push(col.path);
+	return out;
+}
+/**
+* Slice that turns `usePresets` + `useLocalDraft` into the table-state
+* surface declared on `ReactiveTableState`. Pure mutation: writes to the
+* model arrays but never calls `query()` — the root watcher reacts.
+*/
+function createPresetState(opts) {
+	const availableAspects = opts.availableAspects ?? DEFAULT_AVAILABLE_ASPECTS;
+	const availableSet = new Set(availableAspects);
+	const dialogOpen = ref(false);
+	const gate = ref(false);
+	const ready = computed(() => opts.presetsHandle ? gate.value : true);
+	const handle = opts.presetsHandle ?? createInertHandle(opts.fallbackSystemPresets);
+	const { presets, presetsById, userConf, capabilities, systemPresets, systemPresetsById, available, currentUser, activePresetId: activeId } = handle;
+	const canSaveActive = computed(() => {
+		const id = activeId.value;
+		if (!id || isSystemPresetId(id)) return false;
+		return opts.presetsHandle ? opts.presetsHandle.isOwned(id) : false;
+	});
+	const ASPECT_HANDLERS = {
+		columns: {
+			capture(o) {
+				const overrides = {};
+				for (const col of o.allColumns.value) {
+					const entry = o.columnWidths.value[col.path];
+					if (entry && entry.w !== entry.d) overrides[col.path] = entry.w;
+				}
+				const columns = { columnNames: [...o.columnNames.value] };
+				if (Object.keys(overrides).length > 0) columns.columnWidths = overrides;
+				return columns;
+			},
+			apply(o, value, isSystem) {
+				if (!value && !isSystem) return;
+				const cols = value;
+				const columnNames = cols?.columnNames ?? defaultVisibleColumnPaths(o);
+				const columnWidths = cols?.columnWidths;
+				o.columnNames.value = [...columnNames];
+				const next = {};
+				for (const [path, entry] of Object.entries(o.columnWidths.value)) next[path] = {
+					w: entry.d,
+					d: entry.d
+				};
+				if (columnWidths) for (const [path, w] of Object.entries(columnWidths)) {
+					const existing = next[path];
+					if (existing) next[path] = {
+						w,
+						d: existing.d
+					};
+				}
+				o.columnWidths.value = next;
+			},
+			expandDefault(o) {
+				return { columnNames: defaultVisibleColumnPaths(o) };
+			}
+		},
+		filters: {
+			capture: (o) => [...o.filterFields.value],
+			apply(o, value, isSystem) {
+				if (!value && !isSystem) return;
+				o.filterFields.value = value ? [...value] : [];
+			},
+			expandDefault: () => []
+		},
+		filterOps: {
+			capture(o) {
+				const dict = {};
+				for (const [field, conditions] of Object.entries(o.filters.value)) dict[field] = conditions;
+				return dict;
+			},
+			apply(o, value, isSystem) {
+				if (!value && !isSystem) return;
+				o.filters.value = value ? { ...value } : {};
+			},
+			expandDefault: () => ({})
+		},
+		sorters: {
+			capture: (o) => [...o.sorters.value],
+			apply(o, value, isSystem) {
+				if (!value && !isSystem) return;
+				o.sorters.value = value ? [...value] : [];
+			},
+			expandDefault: () => []
+		},
+		itemsPerPage: {
+			capture: (o) => o.pagination.value.itemsPerPage,
+			apply(o, value) {
+				if (value === void 0) return;
+				o.pagination.value = {
+					page: 1,
+					itemsPerPage: value
+				};
+			}
+		}
+	};
+	function maskAllows(aspect, mask) {
+		if (!availableSet.has(aspect)) return false;
+		if (!mask) return true;
+		return mask[aspect] === true;
+	}
+	function captureSnapshot(mask) {
+		const out = {};
+		for (const aspect of availableAspects) {
+			if (!maskAllows(aspect, mask)) continue;
+			out[aspect] = ASPECT_HANDLERS[aspect].capture(opts);
+		}
+		return out;
+	}
+	function resolveSnapshot(idOrSnapshot) {
+		if (typeof idOrSnapshot !== "string") return {
+			snapshot: idOrSnapshot,
+			nextActiveId: activeId.value
+		};
+		const id = idOrSnapshot;
+		if (isSystemPresetId(id)) {
+			const sp = systemPresetsById.value.get(id);
+			if (sp) return {
+				snapshot: sp.content,
+				nextActiveId: id
+			};
+			return {
+				snapshot: systemPresetsById.value.get(STANDARD_PRESET_ID)?.content ?? {},
+				nextActiveId: STANDARD_PRESET_ID
+			};
+		}
+		const row = presetsById.value.get(id);
+		if (!row) return {
+			snapshot: {},
+			nextActiveId: null
+		};
+		const wire = row.data?.content;
+		return {
+			snapshot: wire ? fromWireSnapshot(wire) : {},
+			nextActiveId: id
+		};
+	}
+	function apply(idOrSnapshot) {
+		const { snapshot, nextActiveId } = resolveSnapshot(idOrSnapshot);
+		const isSystem = typeof idOrSnapshot === "string" && nextActiveId !== null && isSystemPresetId(nextActiveId);
+		for (const aspect of availableAspects) {
+			const value = snapshot[aspect];
+			ASPECT_HANDLERS[aspect].apply(opts, value, isSystem);
+		}
+		if (snapshot.itemsPerPage === void 0) {
+			const current = opts.pagination.value;
+			if (current.page !== 1) opts.pagination.value = {
+				...current,
+				page: 1
+			};
+		}
+		if (typeof idOrSnapshot === "string") activeId.value = nextActiveId;
+	}
+	function resetActive() {
+		const id = activeId.value;
+		if (!id) return;
+		apply(id);
+	}
+	function clearLocalDraft() {
+		opts.draftHandle?.clear();
+	}
+	/**
+	* Fill missing aspects with factory defaults so a system preset's snapshot
+	* "claims all aspects in `availableAspects`" per spec §3.7. Stored presets
+	* keep dict-form opt-in (untouched).
+	*/
+	function expandSystemSnapshot(snapshot) {
+		const out = { ...snapshot };
+		for (const aspect of availableAspects) {
+			const handler = ASPECT_HANDLERS[aspect];
+			if (!handler.expandDefault) continue;
+			if (out[aspect] !== void 0) continue;
+			out[aspect] = handler.expandDefault(opts);
+		}
+		return out;
+	}
+	const activeSnapshot = computed(() => {
+		const id = activeId.value;
+		if (!id) return {};
+		if (isSystemPresetId(id)) return expandSystemSnapshot(systemPresetsById.value.get(id)?.content ?? {});
+		const row = presetsById.value.get(id);
+		if (!row) return {};
+		const wire = row.data?.content;
+		return wire ? fromWireSnapshot(wire) : {};
+	});
+	const isDirty = computed(() => isDirtyAgainst(activeSnapshot.value, captureSnapshot()));
+	function requirePresets() {
+		if (!opts.presetsHandle) throw new Error("[vue-table] presets feature not configured (preset.url missing)");
+		return opts.presetsHandle;
+	}
+	async function saveActive() {
+		const handle = requirePresets();
+		const id = activeId.value;
+		if (!id) throw new Error("[vue-table] saveActive: no active preset");
+		if (isSystemPresetId(id)) throw new Error("[vue-table] saveActive: system presets cannot be overwritten");
+		const existing = activeSnapshot.value;
+		const mask = {};
+		for (const aspect of availableAspects) if (existing[aspect] !== void 0) mask[aspect] = true;
+		await handle.savePreset(captureSnapshot(mask));
+		clearLocalDraft();
+	}
+	async function saveAs(label, saveOpts = {}) {
+		const id = await requirePresets().savePresetAs(label, captureSnapshot(saveOpts.aspects), { public: saveOpts.public });
+		clearLocalDraft();
+		return id;
+	}
+	async function rename(id, label) {
+		await requirePresets().renamePreset(id, label);
+	}
+	async function remove(id) {
+		const handle = requirePresets();
+		const wasActive = activeId.value === id;
+		await handle.deletePreset(id);
+		if (wasActive) {
+			apply(STANDARD_PRESET_ID);
+			clearLocalDraft();
+		}
+	}
+	async function togglePublic(id) {
+		await requirePresets().togglePublic(id);
+	}
+	async function setDefault(id) {
+		await requirePresets().setDefault(id);
+	}
+	async function toggleFav(id) {
+		await requirePresets().toggleFav(id);
+	}
+	async function setFavorites(ids) {
+		await requirePresets().setFavorites(ids);
+	}
+	function batch(fn) {
+		return opts.presetsHandle ? opts.presetsHandle.batch(fn) : fn();
+	}
+	function resolveDefaultId() {
+		const pinned = (userConf.value?.data)?.defaultPresetId;
+		if (!pinned) return STANDARD_PRESET_ID;
+		if (isSystemPresetId(pinned)) return systemPresetsById.value.has(pinned) ? pinned : STANDARD_PRESET_ID;
+		return presetsById.value.has(pinned) ? pinned : STANDARD_PRESET_ID;
+	}
+	function bootstrap() {
+		if (!opts.presetsHandle) return;
+		const handle = opts.presetsHandle;
+		const stop = watch(() => handle.loading.value, (loading) => {
+			if (loading) return;
+			stop();
+			const id = resolveDefaultId();
+			const { snapshot, nextActiveId } = resolveSnapshot(id);
+			const base = isSystemPresetId(id) ? expandSystemSnapshot(snapshot) : snapshot;
+			const draftEnabled = !!(opts.draftHandle && opts.persistDrafts);
+			apply(draftEnabled ? opts.draftHandle.hydrate(base) : base);
+			activeId.value = nextActiveId;
+			if (draftEnabled) opts.draftHandle.watchAndPersist(() => captureSnapshot(), () => activeSnapshot.value);
+			nextTick(() => {
+				gate.value = true;
+			});
+		}, { immediate: true });
+	}
+	return {
+		slice: {
+			presets,
+			presetsById,
+			userConf,
+			capabilities,
+			systemPresets,
+			systemPresetsById,
+			availableAspects,
+			available,
+			activeId,
+			activeSnapshot,
+			isDirty,
+			canSaveActive,
+			currentUser,
+			isOwned: (id) => handle.isOwned(id),
+			dialogOpen,
+			ready,
+			captureSnapshot,
+			apply,
+			resetActive,
+			clearLocalDraft,
+			resolveDefaultId,
+			saveActive,
+			saveAs,
+			rename,
+			remove,
+			togglePublic,
+			setDefault,
+			toggleFav,
+			setFavorites,
+			batch
+		},
+		internals: {
+			gate,
+			bootstrap
+		}
+	};
+}
+function inertMutator() {
+	throw new Error("[vue-table] presets feature not configured (preset.url missing)");
+}
+function createInertHandle(fallbackSystemPresets) {
+	const systemList = fallbackSystemPresets ?? resolveSystemPresets();
+	const systemPresets = computed(() => systemList);
+	const systemPresetsById = computed(() => {
+		const map = /* @__PURE__ */ new Map();
+		for (const sp of systemList) map.set(sp.id, sp);
+		return map;
+	});
+	return {
+		presets: shallowRef([]),
+		presetsById: computed(() => /* @__PURE__ */ new Map()),
+		userConf: shallowRef(null),
+		capabilities: ref(null),
+		systemPresets,
+		systemPresetsById,
+		available: computed(() => false),
+		loading: ref(false),
+		error: ref(null),
+		currentUser: computed(() => null),
+		activePresetId: ref(null),
+		activePreset: computed(() => null),
+		isOwned: () => false,
+		reload: async () => {},
+		batch: (fn) => fn(),
+		savePreset: inertMutator,
+		savePresetAs: inertMutator,
+		renamePreset: inertMutator,
+		deletePreset: inertMutator,
+		togglePublic: inertMutator,
+		setDefault: inertMutator,
+		toggleFav: inertMutator,
+		setFavorites: inertMutator
+	};
+}
+//#endregion
+//#region src/composables/state/create-window-fetcher.ts
+function createWindowFetcher(inputs) {
+	const { blockSize, dragReleaseDebounceMs, tableDef, totalCount, results, resultsStart, queryingNext, getGeneration, isQueryBlocked, buildCurrentQuery, dispatchPages, reportError } = inputs;
+	const windowCache = shallowRef(/* @__PURE__ */ new Map());
+	/** Per-block firstIndex values currently in flight. `loadingAt(absIdx)`
+	* derives membership via `blockStartFor(absIdx, blockSize)`. */
+	const windowLoading = shallowRef(/* @__PURE__ */ new Set());
+	const errors = shallowRef(/* @__PURE__ */ new Map());
+	const topIndex = ref(0);
+	const viewportRowCount = ref(0);
+	const settlements = [];
+	let flushScheduled = false;
+	function flushSettlements() {
+		flushScheduled = false;
+		if (settlements.length === 0) return;
+		const currentGen = getGeneration();
+		let applied = false;
+		let nextCache = windowCache.value;
+		let nextLoading = windowLoading.value;
+		let nextErrors = errors.value;
+		let totalCountChanged = false;
+		let nextTotal = totalCount.value;
+		for (const s of settlements) {
+			if (s.gen !== currentGen) continue;
+			if (!applied) {
+				applied = true;
+				nextCache = new Map(windowCache.value);
+				nextLoading = new Set(windowLoading.value);
+				nextErrors = new Map(errors.value);
+			}
+			nextLoading.delete(s.firstIndex);
+			if (s.kind === "ok") {
+				for (let i = 0; i < s.rows.length; i++) nextCache.set(s.firstIndex + i, s.rows[i]);
+				nextErrors.delete(s.firstIndex);
+				nextTotal = s.count;
+				totalCountChanged = true;
+			} else {
+				nextErrors.set(s.firstIndex, s.error);
+				reportError(s.error, s.sourceKind);
+			}
+		}
+		settlements.length = 0;
+		if (!applied) return;
+		windowCache.value = nextCache;
+		windowLoading.value = nextLoading;
+		errors.value = nextErrors;
+		if (totalCountChanged && nextTotal !== totalCount.value) totalCount.value = nextTotal;
+		const fwd = walkForwardAbsorb(results.value, resultsStart.value, nextCache);
+		const bwd = walkBackwardAbsorb(fwd.newResults, fwd.newResultsStart, nextCache);
+		if (bwd.newResults !== results.value) {
+			results.value = bwd.newResults;
+			resultsStart.value = bwd.newResultsStart;
+		}
+	}
+	function scheduleFlush() {
+		if (flushScheduled) return;
+		flushScheduled = true;
+		queueMicrotask(flushSettlements);
+	}
+	function loadRangeInternal(skip, limit, kind) {
+		if (isQueryBlocked()) return Promise.resolve();
+		const blocks = pageAlignedBlocksFor(skip, limit, blockSize);
+		if (blocks.length === 0) return Promise.resolve();
+		const cache = windowCache.value;
+		const loading = windowLoading.value;
+		const missing = [];
+		for (const b of blocks) {
+			if (loading.has(b.firstIndex)) continue;
+			const end = b.firstIndex + blockSize;
+			for (let idx = b.firstIndex; idx < end; idx++) if (!cache.has(idx)) {
+				missing.push(b);
+				break;
+			}
+		}
+		if (missing.length === 0) return Promise.resolve();
+		const thisGen = getGeneration();
+		const baseQuery = buildCurrentQuery();
+		const nextLoading = new Set(windowLoading.value);
+		const prevErrors = errors.value;
+		let nextErrors = prevErrors;
+		let errorsChanged = false;
+		for (const b of missing) {
+			nextLoading.add(b.firstIndex);
+			if (prevErrors.has(b.firstIndex)) {
+				if (!errorsChanged) {
+					nextErrors = new Map(prevErrors);
+					errorsChanged = true;
+				}
+				nextErrors.delete(b.firstIndex);
+			}
+		}
+		windowLoading.value = nextLoading;
+		if (errorsChanged) errors.value = nextErrors;
+		const promises = missing.map(async (b) => {
+			try {
+				const { data, count } = await dispatchPages(baseQuery, b.page, blockSize);
+				if (thisGen !== getGeneration()) return;
+				settlements.push({
+					kind: "ok",
+					gen: thisGen,
+					firstIndex: b.firstIndex,
+					rows: data,
+					count
+				});
+				scheduleFlush();
+			} catch (err) {
+				if (thisGen !== getGeneration()) return;
+				const error = err instanceof Error ? err : new Error(String(err));
+				settlements.push({
+					kind: "err",
+					gen: thisGen,
+					firstIndex: b.firstIndex,
+					error,
+					sourceKind: kind
+				});
+				scheduleFlush();
+			}
+		});
+		return Promise.allSettled(promises).then(() => void 0);
+	}
+	function loadRange(skip, limit) {
+		return loadRangeInternal(skip, limit, "loadRange");
+	}
+	function queryNext() {
+		if (queryingNext.value) return;
+		if (isQueryBlocked()) return;
+		queryingNext.value = true;
+		loadRangeInternal(resultsStart.value + results.value.length, blockSize, "queryNext").finally(() => {
+			queryingNext.value = false;
+		});
+	}
+	function dataAt(absIdx) {
+		return windowCache.value.get(absIdx);
+	}
+	function loadingAt(absIdx) {
+		if (blockSize <= 0) return false;
+		return windowLoading.value.has(blockStartFor(absIdx, blockSize));
+	}
+	function errorAt(absIdx) {
+		if (blockSize <= 0) return null;
+		return errors.value.get(blockStartFor(absIdx, blockSize)) ?? null;
+	}
+	function clearSettlements() {
+		settlements.length = 0;
+	}
+	function resetWindow() {
+		settlements.length = 0;
+		windowCache.value = /* @__PURE__ */ new Map();
+		windowLoading.value = /* @__PURE__ */ new Set();
+		errors.value = /* @__PURE__ */ new Map();
+	}
+	let pendingJumpPlan = null;
+	const debouncedJumpDispatch = debounce(() => {
+		const plan = pendingJumpPlan;
+		pendingJumpPlan = null;
+		if (plan) loadRange(plan.skip, plan.limit);
+	}, dragReleaseDebounceMs);
+	const prefetchBuffer = Math.max(1, Math.floor(blockSize / 4));
+	watch([() => topIndex.value, () => viewportRowCount.value], () => {
+		if (tableDef.value === null) return;
+		if (viewportRowCount.value <= 0) return;
+		const plan = planFetch({
+			top: topIndex.value,
+			viewport: viewportRowCount.value,
+			totalCount: totalCount.value,
+			cache: windowCache.value,
+			blockSize,
+			buffer: prefetchBuffer
+		});
+		if (plan === null) return;
+		if (plan.mode === "jump") {
+			pendingJumpPlan = plan;
+			debouncedJumpDispatch();
+		} else {
+			if (windowLoading.value.has(blockStartFor(plan.skip, blockSize))) return;
+			loadRange(plan.skip, plan.limit);
+		}
+	});
+	function disposeDebounces() {
+		debouncedJumpDispatch.cancel();
+	}
+	return {
+		windowCache,
+		windowLoading,
+		errors,
+		topIndex,
+		viewportRowCount,
+		dataAt,
+		loadingAt,
+		errorAt,
+		loadRange,
+		queryNext,
+		clearSettlements,
+		resetWindow,
+		disposeDebounces
+	};
+}
+//#endregion
+//#region src/composables/use-table-state.ts
+const TABLE_KEY = "__as_table";
+const FILTER_DEBOUNCE_MS = 500;
+const DEFAULT_BLOCK_SIZE = 100;
+const DEFAULT_DRAG_RELEASE_DEBOUNCE_MS = 300;
+const DEFAULT_ITEMS_PER_PAGE = 25;
+let _tblUid = 0;
+/**
+* Coerce a primitive cell value to a string for the static-mode query
+* function's substring search and locale-aware sort. Objects fall back to
+* `""` so `'[object Object]'` never leaks into the search index. Module
+* scope so it's not recreated on every fetch.
+*/
+function cellAsString(v) {
+	if (v == null) return "";
+	if (typeof v === "string") return v;
+	if (typeof v === "number" || typeof v === "boolean") return v.toString();
+	return "";
+}
+/**
+* Promise-based dialog slot. A second `request()` while one is open
+* auto-resolves the prior one with `cancelValue` (the user couldn't have
+* answered both). `dismiss()` is the same path; `accept(v)` resolves with `v`.
+*/
+function createRequestSlot(cancelValue) {
+	const r = shallowRef(null);
+	function request(body) {
+		if (r.value) {
+			r.value.resolve(cancelValue);
+			r.value = null;
+		}
+		return new Promise((resolve) => {
+			r.value = {
+				...body,
+				resolve
+			};
+		});
+	}
+	function accept(value) {
+		const req = r.value;
+		if (!req) return;
+		r.value = null;
+		req.resolve(value);
+	}
+	function dismiss() {
+		const req = r.value;
+		if (!req) return;
+		r.value = null;
+		req.resolve(cancelValue);
+	}
+	return {
+		ref: r,
+		request,
+		accept,
+		dismiss
+	};
+}
+function createTableState(opts) {
+	const client = opts.client;
+	const modelOpts = opts.model;
+	const selectionOpts = opts.selection;
+	const windowOpts = opts.window;
+	const queryOpts = opts.query;
+	const blockSize = windowOpts?.blockSize ?? DEFAULT_BLOCK_SIZE;
+	const dragReleaseDebounceMs = windowOpts?.dragReleaseDebounceMs ?? DEFAULT_DRAG_RELEASE_DEBOUNCE_MS;
+	const tableDef = shallowRef(null);
+	const loadingMetadata = ref(true);
+	const allColumns = shallowRef([]);
+	const filterFields = modelOpts?.filterFields ?? shallowRef([]);
+	const columnNames = modelOpts?.columnNames ?? shallowRef([]);
+	const columnWidths = modelOpts?.columnWidths ?? ref({});
+	const sorters = modelOpts?.sorters ?? shallowRef([]);
+	const columns = computed(() => {
+		const all = allColumns.value;
+		if (all.length === 0 || columnNames.value.length === 0) return [];
+		const map = new Map(all.map((c) => [c.path, c]));
+		const result = [];
+		for (const name of columnNames.value) {
+			const col = map.get(name);
+			if (col) result.push(col);
+		}
+		return result;
+	});
+	const rowDelete = ref(false);
+	const includeActions = ref(false);
+	const filters = shallowRef({});
+	const results = shallowRef([]);
+	const resultsStart = ref(0);
+	const querying = ref(false);
+	const queryingNext = ref(false);
+	const totalCount = ref(0);
+	const loadedCount = computed(() => results.value.length);
+	const pagination = ref({
+		page: 1,
+		itemsPerPage: opts.limit ?? DEFAULT_ITEMS_PER_PAGE
+	});
+	const queryError = ref(null);
+	const metadataError = ref(null);
+	const lastError = ref(null);
+	function reportError(error, kind) {
+		lastError.value = {
+			error,
+			kind
+		};
+	}
+	const mustRefresh = ref(false);
+	const searchTerm = ref("");
+	const configDialogOpen = ref(false);
+	const configTab = ref("columns");
+	const filterDialogColumn = ref(null);
+	const { slice: presetSlice, internals: presetInternals } = createPresetState({
+		columnNames,
+		columnWidths,
+		filterFields,
+		filters,
+		sorters,
+		pagination,
+		allColumns,
+		presetsHandle: opts.preset?.presetsHandle,
+		draftHandle: opts.preset?.draftHandle,
+		availableAspects: opts.preset?.availableAspects,
+		persistDrafts: opts.preset?.persistDrafts,
+		fallbackSystemPresets: opts.preset?.fallbackSystemPresets
+	});
+	presetInternals.bootstrap();
+	const promptSlot = createRequestSlot(false);
+	const confirmRequest = promptSlot.ref;
+	function promptFn(message, opts = {}) {
+		return promptSlot.request({
+			...opts,
+			message
+		});
+	}
+	const acceptPrompt = () => promptSlot.accept(true);
+	const dismissPrompt = promptSlot.dismiss;
+	const formSlot = createRequestSlot(null);
+	const actionFormRequest = formSlot.ref;
+	function requestActionInput(action, ctx) {
+		return formSlot.request({
+			action,
+			identifiers: ctx.identifiers,
+			preferredId: ctx.preferredId
+		});
+	}
+	const acceptActionForm = formSlot.accept;
+	const dismissActionForm = formSlot.dismiss;
+	const stateUid = `tbl-${++_tblUid}`;
+	function rowId(absIndex) {
+		return `${stateUid}-row-${absIndex}`;
+	}
+	let generation = 0;
+	let queryDetected = false;
+	let skipPaginationWatch = 0;
+	function buildCurrentQuery() {
+		return buildTableQuery({
+			visibleColumnPaths: columnNames.value,
+			sorters: sorters.value,
+			forceSorters: queryOpts?.forceSorters,
+			filters: filters.value,
+			forceFilters: queryOpts?.forceFilters,
+			search: searchTerm.value || void 0,
+			includeActions: includeActions.value
+		});
+	}
+	function dispatchPages(query, page, size) {
+		return (queryOpts?.fn ?? ((q, p, s) => client.pages(q, p, s)))(query, page, size);
+	}
+	function resetPagination() {
+		if (pagination.value.page !== 1) {
+			skipPaginationWatch++;
+			pagination.value = {
+				...pagination.value,
+				page: 1
+			};
+		}
+	}
+	/** -1 == nothing active. */
+	const activeIndex = ref(-1);
+	const { windowCache, windowLoading, errors, topIndex, viewportRowCount, dataAt, loadingAt, errorAt, loadRange, queryNext, clearSettlements, resetWindow, disposeDebounces } = createWindowFetcher({
+		blockSize,
+		dragReleaseDebounceMs,
+		tableDef,
+		totalCount,
+		results,
+		resultsStart,
+		queryingNext,
+		getGeneration: () => generation,
+		isQueryBlocked: () => !!queryOpts?.blockQuery,
+		buildCurrentQuery,
+		dispatchPages,
+		reportError
+	});
+	function getActiveRow() {
+		const abs = activeIndex.value;
+		if (abs < 0) return void 0;
+		return dataAt(abs);
+	}
+	const { selectedRows, selectedCount, rowValueFn, isPkSelected, toggleActiveSelection } = createSelectionApi(selectionOpts, getActiveRow);
+	const { actions } = createActions({
+		tableDef,
+		client,
+		rowDelete: () => rowDelete.value,
+		scheduleQuery,
+		refreshOnAction: () => opts.actions?.refreshOnAction?.(),
+		onResolved: opts.actions?.onResolved
+	});
+	let stateRef = null;
+	const { hasMainActionListener, hasMainActionAvailable, registerMainActionListener, requestMainAction } = createMainActionRegistry({
+		getActiveIndex: () => activeIndex.value,
+		getActiveRow,
+		getDefaultRowAction: () => actions.default.row,
+		invokeFallback: (action, row, event) => {
+			if (!stateRef) return;
+			const preferredId = tableDef.value?.preferredId ?? [];
+			const identifiers = collectIdentifiers(stateRef, [row], preferredId);
+			triggerAction(stateRef, action, {
+				identifiers,
+				preferredId
+			}, event);
+		}
+	});
+	const { navMode, navViewportRowCount, setActive, clearActive, handleNavKey } = createNavController({
+		activeIndex,
+		totalCount,
+		results,
+		viewportRowCount,
+		topIndex,
+		hasMainActionAvailable,
+		requestMainAction,
+		toggleActiveSelection
+	});
+	async function runQuery(kind) {
+		if (queryOpts?.blockQuery) return;
+		mustRefresh.value = false;
+		if (kind !== "initial" && topIndex.value !== 0) topIndex.value = 0;
+		const thisGen = ++generation;
+		clearSettlements();
+		querying.value = true;
+		queryDetected = true;
+		try {
+			const query = buildCurrentQuery();
+			const { page, itemsPerPage } = pagination.value;
+			const newResultsStart = (page - 1) * itemsPerPage;
+			const fetchSize = viewportRowCount.value > 0 ? blockSize : itemsPerPage;
+			const { data, count } = await dispatchPages(query, fetchSize === itemsPerPage ? page : Math.floor(newResultsStart / fetchSize) + 1, fetchSize);
+			if (thisGen !== generation) return;
+			const fresh = /* @__PURE__ */ new Map();
+			for (let i = 0; i < data.length; i++) fresh.set(newResultsStart + i, data[i]);
+			windowCache.value = fresh;
+			windowLoading.value = /* @__PURE__ */ new Set();
+			errors.value = /* @__PURE__ */ new Map();
+			results.value = data;
+			resultsStart.value = newResultsStart;
+			totalCount.value = count;
+			queryError.value = null;
+		} catch (err) {
+			if (thisGen !== generation) return;
+			const error = err instanceof Error ? err : new Error(String(err));
+			queryError.value = error;
+			results.value = [];
+			windowCache.value = /* @__PURE__ */ new Map();
+			windowLoading.value = /* @__PURE__ */ new Set();
+			totalCount.value = 0;
+			reportError(error, kind);
+		} finally {
+			if (thisGen === generation) querying.value = false;
+		}
+	}
+	let pendingScheduledKind = null;
+	let queryFlushScheduled = false;
+	function scheduleQuery(kind = "query") {
+		if (queryOpts?.blockQuery) return;
+		if (tableDef.value === null) return;
+		pendingScheduledKind = pendingScheduledKind ?? kind;
+		querying.value = true;
+		if (queryFlushScheduled) return;
+		queryFlushScheduled = true;
+		queueMicrotask(() => {
+			queryFlushScheduled = false;
+			const k = pendingScheduledKind;
+			pendingScheduledKind = null;
+			if (k === null) return;
+			if (tableDef.value === null) return;
+			runQuery(k);
+		});
+	}
+	function query() {
+		scheduleQuery("query");
+	}
+	function requestRefresh() {
+		mustRefresh.value = true;
+		scheduleQuery();
+	}
+	async function queryImmediate() {
+		pendingScheduledKind = null;
+		if (queryOpts?.blockQuery) return;
+		if (tableDef.value === null) return;
+		await runQuery("query");
+	}
+	function invalidate() {
+		generation++;
+		results.value = [];
+		resetWindow();
+		resultsStart.value = (pagination.value.page - 1) * pagination.value.itemsPerPage;
+		totalCount.value = 0;
+	}
+	function writeColumnWidth(path, width) {
+		const entry = columnWidths.value[path];
+		if (!entry || entry.w === width) return;
+		columnWidths.value = {
+			...columnWidths.value,
+			[path]: {
+				...entry,
+				w: width
+			}
+		};
+	}
+	const state = {
+		tableDef,
+		loadingMetadata,
+		columnNames,
+		columns,
+		allColumns,
+		columnWidths,
+		filterFields,
+		filters,
+		sorters,
+		results,
+		resultsStart,
+		windowCache,
+		windowLoading,
+		topIndex,
+		viewportRowCount,
+		navViewportRowCount,
+		querying,
+		queryingNext,
+		totalCount,
+		loadedCount,
+		pagination,
+		queryError,
+		metadataError,
+		lastError,
+		mustRefresh,
+		searchTerm,
+		configDialogOpen,
+		configTab,
+		filterDialogColumn,
+		selectedRows,
+		selectedCount,
+		rowValueFn,
+		isPkSelected,
+		rowDelete,
+		includeActions,
+		activeIndex,
+		navMode,
+		hasMainActionListener,
+		rowId,
+		setActive,
+		clearActive,
+		toggleActiveSelection,
+		requestMainAction,
+		handleNavKey,
+		registerMainActionListener,
+		actions,
+		confirmRequest,
+		prompt: promptFn,
+		acceptPrompt,
+		dismissPrompt,
+		actionFormRequest,
+		requestActionInput,
+		acceptActionForm,
+		dismissActionForm,
+		query,
+		queryImmediate,
+		queryNext,
+		loadRange,
+		invalidate,
+		dataAt,
+		loadingAt,
+		errorAt,
+		resetFilters() {
+			if (Object.keys(filters.value).length === 0) return;
+			filters.value = {};
+		},
+		showConfigDialog(tab) {
+			configTab.value = tab ?? "columns";
+			configDialogOpen.value = true;
+		},
+		addFilterField(path) {
+			if (!filterFields.value.includes(path)) filterFields.value = [...filterFields.value, path];
+		},
+		removeFilterField(path) {
+			if (!filterFields.value.includes(path)) return;
+			filterFields.value = filterFields.value.filter((f) => f !== path);
+		},
+		setFieldFilter(path, conditions) {
+			if (!conditions.some(isFilled)) {
+				if (!(path in filters.value)) return;
+				const { [path]: _, ...rest } = filters.value;
+				filters.value = rest;
+			} else filters.value = {
+				...filters.value,
+				[path]: conditions
+			};
+		},
+		setColumnWidth(path, width) {
+			writeColumnWidth(path, width);
+		},
+		resetColumnWidth(path) {
+			const entry = columnWidths.value[path];
+			if (entry) writeColumnWidth(path, entry.d);
+		},
+		removeFieldFilter(path) {
+			const { [path]: _, ...rest } = filters.value;
+			filters.value = rest;
+		},
+		openFilterDialog(column) {
+			filterDialogColumn.value = column;
+		},
+		closeFilterDialog() {
+			filterDialogColumn.value = null;
+		},
+		applyUrlQuery,
+		preset: presetSlice
+	};
+	stateRef = state;
+	let lastEmittedUrl = "";
+	let hydratingFromUrl = false;
+	const urlDefaultItemsPerPage = opts.limit ?? DEFAULT_ITEMS_PER_PAGE;
+	const urlQuerySync = queryOpts?.urlQuerySync;
+	function serializeStateForUrl() {
+		return stateToUrlQueryString({
+			filters: filters.value,
+			sorters: sorters.value,
+			page: pagination.value.page,
+			itemsPerPage: pagination.value.itemsPerPage,
+			searchTerm: searchTerm.value
+		}, {
+			defaultItemsPerPage: urlDefaultItemsPerPage,
+			sync: urlQuerySync
+		});
+	}
+	function urlsEquivalent(a, b) {
+		if (a === b) return true;
+		try {
+			return decodeURIComponent(a) === decodeURIComponent(b);
+		} catch {
+			return false;
+		}
+	}
+	function emitUrlIfChanged() {
+		if (!queryOpts?.onUrlQueryChange) return;
+		if (hydratingFromUrl) return;
+		if (queryOpts.urlQueryReady && !queryOpts.urlQueryReady.value) return;
+		const next = serializeStateForUrl();
+		if (next === lastEmittedUrl) return;
+		lastEmittedUrl = next;
+		queryOpts.onUrlQueryChange(next);
+	}
+	function applyUrlQuery(urlString) {
+		if (urlsEquivalent(urlString, lastEmittedUrl)) return;
+		const cols = allColumns.value;
+		const parsed = urlQueryStringToState(urlString, {
+			knownFields: cols.length > 0 ? cols.map((c) => c.path) : void 0,
+			sync: urlQuerySync
+		});
+		const currentItemsPerPage = pagination.value.itemsPerPage;
+		const skip = parsed.skip ?? 0;
+		const nextPage = skip > 0 && currentItemsPerPage > 0 ? Math.floor(skip / currentItemsPerPage) + 1 : 1;
+		const wasQueryDetected = queryDetected;
+		hydratingFromUrl = true;
+		const filtersGate = resolveAspectGate(urlQuerySync?.filters);
+		if (filtersGate !== "none") {
+			const next = { ...filters.value };
+			for (const path in parsed.filters) next[path] = parsed.filters[path];
+			filters.value = next;
+		}
+		if (resolveAspectGate(urlQuerySync?.sorters) !== "none") {
+			const urlFields = /* @__PURE__ */ new Set();
+			for (const s of parsed.sorters) urlFields.add(s.field);
+			const merged = [...sorters.value.filter((s) => !urlFields.has(s.field)), ...parsed.sorters];
+			if (!sortersEqual(sorters.value, merged)) sorters.value = merged;
+		}
+		if (urlQuerySync?.search !== false) {
+			if (searchTerm.value !== parsed.searchTerm) searchTerm.value = parsed.searchTerm;
+		}
+		if (urlQuerySync?.pagination !== false) {
+			if (pagination.value.page !== nextPage) pagination.value = {
+				...pagination.value,
+				page: nextPage
+			};
+		}
+		if (filtersGate !== "none") {
+			const present = new Set(filterFields.value);
+			let merged = null;
+			for (const f in parsed.filters) {
+				if (present.has(f)) continue;
+				(merged ??= filterFields.value.slice()).push(f);
+				present.add(f);
+			}
+			if (merged) filterFields.value = merged;
+		}
+		lastEmittedUrl = serializeStateForUrl();
+		nextTick(() => {
+			hydratingFromUrl = false;
+			if (wasQueryDetected && !queryOpts?.blockQuery && tableDef.value !== null) scheduleQuery();
+		});
+	}
+	const debouncedFilterQuery = debounce(() => {
+		if (queryDetected) scheduleQuery();
+	}, FILTER_DEBOUNCE_MS);
+	watch([() => filters.value, () => searchTerm.value], () => {
+		if (hydratingFromUrl) return;
+		if (!queryDetected) return;
+		mustRefresh.value = true;
+		resetPagination();
+		debouncedFilterQuery();
+	});
+	watch(() => sorters.value, (next, prev) => {
+		if (hydratingFromUrl) return;
+		if (sortersEqual(prev, next)) return;
+		if (!queryDetected) return;
+		requestRefresh();
+	}, { immediate: false });
+	watch(() => columnNames.value, (next, prev) => {
+		if (!queryDetected) return;
+		if (sameColumnSet(prev, next)) return;
+		requestRefresh();
+	}, { immediate: false });
+	watch(() => pagination.value, (next, prev) => {
+		if (skipPaginationWatch > 0) {
+			skipPaginationWatch--;
+			return;
+		}
+		if (hydratingFromUrl) return;
+		if (next.page === prev.page && next.itemsPerPage === prev.itemsPerPage) return;
+		if (!queryDetected) return;
+		scheduleQuery();
+	});
+	watch([
+		() => filters.value,
+		() => sorters.value,
+		() => searchTerm.value,
+		() => pagination.value
+	], () => emitUrlIfChanged());
+	watch(() => includeActions.value, () => {
+		if (!queryDetected) return;
+		requestRefresh();
+	});
+	const presetGateOpen = () => opts.preset?.presetsHandle ? presetInternals.gate.value : true;
+	watch([
+		() => tableDef.value,
+		() => queryOpts?.urlQueryReady?.value ?? true,
+		presetGateOpen
+	], ([def, urlReady, presetReady]) => {
+		if (queryDetected) return;
+		if (def === null || !urlReady || !presetReady) return;
+		if (queryOpts?.queryOnMount === false) return;
+		if (allColumns.value.length === 0) return;
+		if (results.value.length !== 0) return;
+		queryDetected = true;
+		scheduleQuery("initial");
+	});
+	onScopeDispose(() => {
+		debouncedFilterQuery.cancel();
+		disposeDebounces();
+		promptSlot.dismiss();
+		formSlot.dismiss();
+	});
+	return {
+		state,
+		internals: {
+			init(def) {
+				allColumns.value = def.columns;
+				const reconciled = reconcileColumnWidthDefaults(def.columns, columnWidths.value);
+				if (reconciled !== columnWidths.value) columnWidths.value = reconciled;
+				if (columnNames.value.length === 0) columnNames.value = getVisibleColumns(def).map((c) => c.path);
+				tableDef.value = def;
+			},
+			resetPagination
+		}
+	};
+}
+/**
+* Build a `ReactiveTableState` backed by an in-memory row list. Used by the
+* enum value-help branch (`column.options`) where there's no client and no
+* metadata fetch — sorting/searching/pagination run locally against `rows`.
+*/
+function createStaticTableState(opts) {
+	let _state = null;
+	const queryFn = (q, page, size) => {
+		if (!_state) return Promise.resolve({
+			data: [],
+			count: 0,
+			page,
+			itemsPerPage: size,
+			pages: 1
+		});
+		return buildStaticQueryFn(opts, _state)(q, page, size);
+	};
+	const result = createTableState({
+		client: {},
+		selection: opts.selection,
+		limit: opts.limit,
+		query: { fn: queryFn }
+	});
+	_state = result.state;
+	result.state.loadingMetadata.value = false;
+	result.internals.init({
+		type: void 0,
+		columns: opts.columns,
+		flatMap: /* @__PURE__ */ new Map(),
+		primaryKeys: [],
+		preferredId: [],
+		crud: {
+			query: [],
+			pages: [],
+			one: []
+		},
+		canRemove: false,
+		actions: {
+			table: [],
+			row: [],
+			rows: [],
+			default: {}
+		},
+		searchable: (opts.searchPaths?.length ?? 0) > 0,
+		vectorSearchable: false,
+		searchIndexes: [],
+		relations: []
+	});
+	return result;
+}
+function buildStaticQueryFn(opts, state) {
+	const searchPaths = opts.searchPaths ?? [];
+	return (_query, page, size) => {
+		let filtered = opts.rows;
+		const term = state.searchTerm.value.trim().toLowerCase();
+		if (term && searchPaths.length > 0) filtered = filtered.filter((row) => searchPaths.some((p) => cellAsString(row[p]).toLowerCase().includes(term)));
+		const active = state.sorters.value;
+		if (active.length > 0) filtered = filtered.toSorted((a, b) => {
+			for (const s of active) {
+				const dir = s.direction === "desc" ? -1 : 1;
+				const av = a[s.field];
+				const bv = b[s.field];
+				if (typeof av === "number" && typeof bv === "number") {
+					if (av < bv) return -dir;
+					if (av > bv) return dir;
+				} else {
+					const cmp = cellAsString(av).localeCompare(cellAsString(bv));
+					if (cmp !== 0) return cmp * dir;
+				}
+			}
+			return 0;
+		});
+		const start = (page - 1) * size;
+		return Promise.resolve({
+			data: filtered.slice(start, start + size),
+			count: filtered.length,
+			page,
+			itemsPerPage: size,
+			pages: Math.max(1, Math.ceil(filtered.length / size))
+		});
+	};
+}
+/** Provide the full table context to the component subtree. */
+function provideTableContext(ctx) {
+	provide(TABLE_KEY, ctx);
+}
+/** Inject the full table context (throws if used outside as-table-root). */
+function useTableContext() {
+	const ctx = inject(TABLE_KEY);
+	if (!ctx) throw new Error("[vue-table] useTableContext() called outside of <as-table-root>.");
+	return ctx;
+}
+/**
+* Inject the table context if present; return undefined when no
+* `<as-table-root>` ancestor provided one. Use from components that may mount
+* inside or outside a table subtree (`<AsTableBase>` in combobox/listbox modes,
+* external composables that probe for context).
+*/
+function useTableContextOptional() {
+	return inject(TABLE_KEY);
+}
+/**
+* Register `listener` as a main-action handler whenever `enabled` is truthy.
+* Reactive — toggling `enabled` registers / disposes live. Skipping
+* registration when `enabled` is false is what lets `handleNavKey` fall
+* back to `toggle-select` semantics; see `requestMainAction` early-return
+* gate. Callers detect "did the parent bind `@main-action`?" via
+* `useHasEmitListener("onMainAction")`.
+*/
+function useRegisterMainActionListener(state, listener, enabled) {
+	let dispose = null;
+	const stop = watch(() => toValue(enabled), (on) => {
+		if (on && !dispose) dispose = state.registerMainActionListener(listener);
+		else if (!on && dispose) {
+			dispose();
+			dispose = null;
+		}
+	}, { immediate: true });
+	onBeforeUnmount(() => {
+		stop();
+		dispose?.();
+		dispose = null;
+	});
+}
+//#endregion
+export { useTableContext as a, applyRowGate as c, extractIdentifier as d, intentClass as f, ROW_ACTIONS_TYPE as g, ROW_ACTIONS_PATH as h, useRegisterMainActionListener as i, ariaLabelFor as l, triggerAction as m, createTableState as n, useTableContextOptional as o, intentToScope as p, provideTableContext as r, DEFAULT_AVAILABLE_ASPECTS as s, createStaticTableState as t, collectIdentifiers as u };