@atscript/vue-table 0.1.132 → 0.1.134

package/dist/{use-table-state-BxX3SpeW.mjs → use-table-state-mBXx11aH.mjs}

@@ -1,6 +1,7 @@
+import { t as getCellValue } from "./get-cell-value-Cb3X8nUn.mjs";
 import { navigateHrefFor } 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 { STANDARD_PRESET_ID, blockStartFor, buildTableQuery, cellAsString, debounce, derivePresetAspects, fromWireSnapshot, isDirtyAgainst, isFilled, isSystemPresetId, mergeDisplayColumns, mergeSorters, pageAlignedBlocksFor, planFetch, reconcileColumnWidthDefaults, resolveAspectGate, resolveSystemPresets, rowsToPks, sameColumnSet, sortRowsLocally, 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. */
@@ -43,18 +44,25 @@ function rowActionGate(row) {
 	return names ? gateFor(new Set(names)) : null;
 }
 /**
-* Filter a `{default, others, rows}` triple through an availability `gate`.
-* When `gate` is `null`, returns the input `buckets` reference unchanged so
-* source-array references stay stable downstream (no spurious recomputes in
-* consumers that compare array identity). Shared by the single-row
-* (`applyRowGate`) and bulk (`applyRowsGate`) paths.
+* Walk a `{default, others, rows}` triple once: keep the actions `gate`
+* admits, then run each survivor through `map`. Both are optional — with
+* neither, the input `buckets` reference comes back unchanged so source-array
+* references stay stable downstream (no spurious recomputes in consumers that
+* compare array identity). Shared by the single-row (`applyRowGate`), bulk
+* (`applyRowsGate`) and per-screen-policy paths.
 */
-function applyGate(buckets, gate) {
-	if (!gate) return buckets;
+function applyGate(buckets, gate, map) {
+	if (!gate && !map) return buckets;
+	const keep = gate ?? (() => true);
+	const walk = (list) => {
+		const kept = gate ? list.filter(keep) : list;
+		return map ? kept.map(map) : kept;
+	};
+	const def = buckets.default;
 	return {
-		default: buckets.default && gate(buckets.default) ? buckets.default : void 0,
-		others: buckets.others.filter(gate),
-		rows: buckets.rows.filter(gate)
+		default: def && keep(def) ? map ? map(def) : def : void 0,
+		others: walk(buckets.others),
+		rows: walk(buckets.rows)
 	};
 }
 /**
@@ -281,12 +289,16 @@ async function triggerAction(state, action, ctx, event) {
 		if (input === null) return;
 		state.actions.invoke(action, pk, {
 			event,
-			input
+			input,
+			row: ctx.row
 		});
 		return;
 	}
 	if (!await confirmAction(state, action, ctx)) return;
-	state.actions.invoke(action, pk, { event });
+	state.actions.invoke(action, pk, {
+		event,
+		row: ctx.row
+	});
 }
 /**
 * Pick the `pk` argument to forward to `state.actions.invoke` based on the
@@ -308,6 +320,75 @@ function idsForAction(level, pk) {
 	return pk === void 0 ? [] : [pk];
 }
 //#endregion
+//#region src/composables/state/row-actions-config.ts
+/** The app definition behind a client-only action, or `undefined` for a server action. */
+function localActionOf(action) {
+	return action.$local;
+}
+/** Wrap an app-owned action in the descriptor shape the row-actions cell renders. */
+function toLocalActionInfo(local) {
+	return {
+		name: local.name,
+		label: local.label,
+		level: "row",
+		processor: "custom",
+		value: "",
+		icon: local.icon,
+		intent: local.intent,
+		promptText: local.promptText,
+		$local: local
+	};
+}
+/**
+* Render-time href for a row action, whichever kind it is: a client-only
+* action builds its own from the row — still mapped through
+* `state.resolveHref`, so router base paths apply exactly as they do for a
+* server `navigate` action — and a server action goes through
+* {@link actionHref}.
+*/
+function rowActionHref(state, action, id, row) {
+	const local = localActionOf(action);
+	if (local) return local.href && row !== void 0 ? state.resolveHref(local.href(row)) : void 0;
+	return actionHref(state, action, id);
+}
+const EMPTY = Object.freeze([]);
+/** The identity policy — used when no `RowActionsConfig` is wired. */
+const PASS_THROUGH = {
+	apply: (buckets) => buckets,
+	extra: () => EMPTY
+};
+/** Compile a per-screen {@link RowActionsConfig} into a {@link RowActionsPolicy}. */
+function compileRowActionsConfig(config) {
+	if (!config) return PASS_THROUGH;
+	const include = config.include ? new Set(config.include) : null;
+	const exclude = config.exclude ? new Set(config.exclude) : null;
+	const overrides = config.overrides;
+	const gate = (a) => (!include || include.has(a.name)) && !exclude?.has(a.name);
+	const decorate = overrides ? (action) => {
+		const patch = overrides[action.name];
+		if (!patch) return action;
+		const next = { ...action };
+		for (const key of [
+			"label",
+			"icon",
+			"intent",
+			"promptText"
+		]) {
+			const value = patch[key];
+			if (value !== void 0) next[key] = value;
+		}
+		return next;
+	} : void 0;
+	const locals = (config.extra ?? []).filter((local) => !exclude?.has(local.name));
+	return {
+		apply: (buckets) => applyGate(buckets, gate, decorate),
+		extra: (row) => {
+			if (locals.length === 0) return EMPTY;
+			return (row === void 0 ? locals : locals.filter((l) => l.enabled?.(row) !== false)).map(toLocalActionInfo);
+		}
+	};
+}
+//#endregion
 //#region src/composables/state/create-actions.ts
 const REMOVE_NAME = REMOVE_PROCESSOR;
 const REMOVE_DEFAULTS = {
@@ -340,13 +421,16 @@ function createActions(opts) {
 		let result;
 		try {
 			switch (action.processor) {
-				case "custom":
+				case "custom": {
+					const local = localActionOf(action);
+					if (local?.onInvoke) await local.onInvoke(callOpts?.row ?? {}, Array.isArray(pk) ? pk[0] : pk);
 					result = {
 						ok: true,
 						kind: "custom",
 						dispatched: true
 					};
 					break;
+				}
 				case "navigate":
 					await opts.client.action(action.name, pk);
 					result = {
@@ -478,7 +562,18 @@ function buildRemoveAction(opts) {
 }
 //#endregion
 //#region src/composables/state/create-selection.ts
-function createSelectionApi(opts, getActiveRow) {
+/** Shared verdicts — frozen, so the common case allocates nothing per row. */
+const SELECTABLE = Object.freeze({ ok: true });
+const NOT_SELECTABLE = Object.freeze({ ok: false });
+/** Normalise a {@link RowSelectableHook} return value. `""` carries no reason. */
+function verdictOf(value) {
+	if (value === void 0 || value === true) return SELECTABLE;
+	return value ? {
+		ok: false,
+		reason: value
+	} : NOT_SELECTABLE;
+}
+function createSelectionApi(opts, getActiveRow, activeIndex) {
 	const selectedRows = opts?.selectedRows ?? shallowRef([]);
 	const selectedCount = computed(() => selectedRows.value.length);
 	const rowValueFn = opts?.rowValueFn ?? ((row) => row);
@@ -486,10 +581,49 @@ function createSelectionApi(opts, getActiveRow) {
 	function isPkSelected(pk) {
 		return selectedSet.value.has(pk);
 	}
+	const rowSelectable = ref();
+	function isRowSelectable(row, index) {
+		const hook = rowSelectable.value;
+		if (!hook) return SELECTABLE;
+		return verdictOf(hook(row, {
+			index,
+			get selected() {
+				return isPkSelected(rowValueFn(row));
+			}
+		}));
+	}
+	function selectableRows(rows) {
+		if (!rowSelectable.value) return rows;
+		return rows.filter((row, index) => isRowSelectable(row, index).ok);
+	}
+	function selectableCount(rows) {
+		if (!rowSelectable.value) return rows.length;
+		let n = 0;
+		for (let i = 0; i < rows.length; i++) if (isRowSelectable(rows[i], i).ok) n++;
+		return n;
+	}
+	function selectAll(rows, indexOf) {
+		if (!rowSelectable.value) {
+			selectedRows.value = rowsToPks(rows, rowValueFn);
+			return;
+		}
+		const out = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (let i = 0; i < rows.length; i++) {
+			const row = rows[i];
+			const pk = rowValueFn(row);
+			if (seen.has(pk)) continue;
+			if (!isRowSelectable(row, indexOf ? indexOf(i) : i).ok && !isPkSelected(pk)) continue;
+			seen.add(pk);
+			out.push(pk);
+		}
+		selectedRows.value = out;
+	}
 	function toggleActiveSelection(mode) {
 		if (mode === "none") return;
 		const row = getActiveRow();
 		if (row === void 0) return;
+		if (!isRowSelectable(row, activeIndex.value).ok) return;
 		selectedRows.value = togglePk(selectedRows.value, rowValueFn(row), mode);
 	}
 	return {
@@ -498,6 +632,11 @@ function createSelectionApi(opts, getActiveRow) {
 		selectedSet,
 		rowValueFn,
 		isPkSelected,
+		rowSelectable,
+		isRowSelectable,
+		selectableRows,
+		selectableCount,
+		selectAll,
 		toggleActiveSelection
 	};
 }
@@ -551,6 +690,38 @@ function createMainActionRegistry(opts) {
 }
 //#endregion
 //#region src/composables/state/create-nav-controller.ts
+/**
+* Elements that own Enter / Space (and a pointer drag) themselves.
+* `[contenteditable]` is matched separately because `contenteditable="false"`
+* must NOT count.
+*/
+const INTERACTIVE_SELECTOR = "button, a[href], input, select, textarea, summary, [role=button], [role=link], [role=checkbox], [role=menuitem], [role=switch], [role=tab], [role=option]";
+/**
+* True when the key event started on an interactive element inside a cell,
+* so table nav must not consume Enter / Space. The walk runs from
+* `event.target` up to `event.currentTarget` — the element the handler is
+* bound on — and stops at the cell / row boundary, so a wrapper outside the
+* table can never make a whole table inert. A handler bound ON the
+* interactive element itself (the search-input bridge) is therefore never
+* guarded: the walk has nothing to cross. An interactive element opts BACK
+* IN to table nav — e.g. a cell whose button should not swallow Enter —
+* with `data-as-nav-keys`.
+*/
+function isInteractiveKeyTarget(event) {
+	let el = event.target;
+	const stop = event.currentTarget;
+	while (el && el !== stop && typeof el.matches === "function") {
+		const tag = el.tagName;
+		if (tag === "TD" || tag === "TH" || tag === "TR" || tag === "TBODY" || tag === "TABLE") return false;
+		if (el.matches("button, a[href], input, select, textarea, summary, [role=button], [role=link], [role=checkbox], [role=menuitem], [role=switch], [role=tab], [role=option]") || isEditable(el)) return !el.hasAttribute("data-as-nav-keys");
+		el = el.parentElement;
+	}
+	return false;
+}
+function isEditable(el) {
+	const attr = el.getAttribute("contenteditable");
+	return attr !== null && attr !== "false";
+}
 function createNavController(inputs) {
 	const { activeIndex, navMode, totalCount, results, viewportRowCount, topIndex, hasMainActionAvailable, requestMainAction, toggleActiveSelection } = inputs;
 	const navViewportRowCount = ref(0);
@@ -600,6 +771,7 @@ function createNavController(inputs) {
 		const enterAction = opts?.enterAction ?? "main-action";
 		const mode = opts?.mode ?? "none";
 		const key = event.key;
+		const guarded = (key === "Enter" || key === " ") && isInteractiveKeyTarget(event);
 		const meta = event.metaKey;
 		const ctrl = event.ctrlKey;
 		const alt = event.altKey;
@@ -650,11 +822,13 @@ function createNavController(inputs) {
 				return;
 			case " ":
 				if (mode === "none") return;
+				if (guarded) return;
 				event.preventDefault();
 				toggleActiveSelection(mode);
 				return;
 			case "Enter":
 				if (enterAction === "passthrough") return;
+				if (guarded) return;
 				event.preventDefault();
 				if (enterAction === "toggle-select") {
 					toggleActiveSelection(mode);
@@ -679,6 +853,67 @@ function createNavController(inputs) {
 		handleNavKey
 	};
 }
+/**
+* `@keydown` handler for a row's SELECTION CONTROL (the leading checkbox),
+* shared by `<AsTableBase>` and `<AsWindowTableBase>`. The control carries
+* `role="checkbox"`, so the tbody-level nav handler deliberately leaves
+* Space to it (see {@link isInteractiveKeyTarget}) — this is where it lands.
+*
+* Keys other than Space, and `select="none"`, fall through untouched; only
+* once the press is ours do we consume it, so the Reka-wrapped rendering
+* modes (which never bind this handler) keep Space for their own item.
+* Selectability is NOT re-checked here: `toggleActiveSelection` gates on
+* `rowSelectable` itself, which is the single place that rule lives.
+*/
+function onSelectControlKeydown(event, index, mode, state) {
+	if (event.key !== " ") return;
+	if (mode === "none") return;
+	event.preventDefault();
+	event.stopPropagation();
+	state.setActive(index);
+	state.toggleActiveSelection(mode);
+}
+//#endregion
+//#region src/composables/preset-aspect-display.ts
+const ASPECT_LABELS = {
+	columns: "Displayed Columns",
+	filters: "Displayed Filters",
+	filterOps: "Filter conditions",
+	sorters: "Sorters",
+	itemsPerPage: "Page size"
+};
+const ASPECT_ICONS = {
+	columns: "i-as-columns",
+	filters: "i-as-filter",
+	filterOps: "i-as-filter-ops",
+	sorters: "i-as-sorters",
+	itemsPerPage: "i-as-pin"
+};
+/**
+* Resolve the aspects a stored preset claims. Prefers the server-stamped
+* `aspects` column (cheap), falls back to deriving from `data.content` for
+* older rows or first paint after save before reload settles.
+*/
+function aspectsOf(row, availableAspects) {
+	if (Array.isArray(row.aspects) && row.aspects.length > 0) return row.aspects.filter((a) => availableAspects.includes(a));
+	const wire = row.data?.content;
+	if (!wire) return [];
+	return derivePresetAspects(wire).filter((a) => availableAspects.includes(a));
+}
+function readPresetLabel(row) {
+	return row.label ?? row.data?.label ?? row.id;
+}
+/**
+* Display name for the row's owner. `userLabel` (server-stamped via the
+* host's `getUserLabel` hook) is preferred so the UI shows "Alice" rather
+* than `usr_abc123`. `fallback` is returned when no name is available —
+* picker uses `""`, dialog uses `"—"`.
+*/
+function ownerNameOf(row, fallback = "") {
+	if (typeof row.userLabel === "string" && row.userLabel.length > 0) return row.userLabel;
+	if (typeof row.user === "string" && row.user.length > 0) return row.user;
+	return fallback;
+}
 //#endregion
 //#region src/composables/state/create-preset-state.ts
 const DEFAULT_AVAILABLE_ASPECTS = [
@@ -705,6 +940,26 @@ function defaultColumnPaths(o) {
 function createPresetState(opts) {
 	const availableAspects = opts.availableAspects ?? DEFAULT_AVAILABLE_ASPECTS;
 	const availableSet = new Set(availableAspects);
+	const systemAspects = opts.systemAspects ? availableAspects.filter((a) => opts.systemAspects.includes(a)) : availableAspects;
+	const lastError = ref(null);
+	let trackDepth = 0;
+	/**
+	* Every public mutator runs through here: it is the one place a preset
+	* write failure is recorded. Clears `lastError` on the outermost entry,
+	* records the failure and RETHROWS so the caller can react too.
+	*/
+	async function track(fn) {
+		if (trackDepth === 0) lastError.value = null;
+		trackDepth++;
+		try {
+			return await fn();
+		} catch (err) {
+			lastError.value = err instanceof Error ? err : new Error(String(err));
+			throw err;
+		} finally {
+			trackDepth--;
+		}
+	}
 	const dialogOpen = ref(false);
 	const gate = ref(false);
 	const ready = computed(() => opts.presetsHandle ? gate.value : true);
@@ -795,6 +1050,20 @@ function createPresetState(opts) {
 		if (!mask) return true;
 		return mask[aspect] === true;
 	}
+	/**
+	* Aspects the preset `id` OWNS, i.e. the ones applying it may write:
+	* a system preset owns `systemAspects`, a stored preset owns what its
+	* snapshot claims, and "no preset" (a raw snapshot, or an id with no row)
+	* owns everything available. The one answer every aspect-scoped surface
+	* asks for — apply, system-snapshot expansion, the picker badges and
+	* Save-as mask, the manage dialog rows.
+	*/
+	function ownedAspects(id) {
+		if (!id) return availableAspects;
+		if (isSystemPresetId(id)) return systemAspects;
+		const row = presetsById.value.get(id);
+		return row ? aspectsOf(row, availableAspects) : availableAspects;
+	}
 	function captureSnapshot(mask) {
 		const out = {};
 		for (const aspect of availableAspects) {
@@ -834,7 +1103,7 @@ function createPresetState(opts) {
 	function apply(idOrSnapshot) {
 		const { snapshot, nextActiveId } = resolveSnapshot(idOrSnapshot);
 		const isSystem = typeof idOrSnapshot === "string" && nextActiveId !== null && isSystemPresetId(nextActiveId);
-		for (const aspect of availableAspects) {
+		for (const aspect of ownedAspects(nextActiveId)) {
 			const value = snapshot[aspect];
 			ASPECT_HANDLERS[aspect].apply(opts, value, isSystem);
 		}
@@ -860,9 +1129,12 @@ function createPresetState(opts) {
 	* "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) {
+	function expandSystemSnapshot(snapshot, id) {
+		const out = {};
+		const owned = ownedAspects(id);
+		const ownedSet = new Set(owned);
+		for (const [key, value] of Object.entries(snapshot)) if (ownedSet.has(key)) out[key] = value;
+		for (const aspect of owned) {
 			const handler = ASPECT_HANDLERS[aspect];
 			if (!handler.expandDefault) continue;
 			if (out[aspect] !== void 0) continue;
@@ -873,7 +1145,7 @@ function createPresetState(opts) {
 	const activeSnapshot = computed(() => {
 		const id = activeId.value;
 		if (!id) return {};
-		if (isSystemPresetId(id)) return expandSystemSnapshot(systemPresetsById.value.get(id)?.content ?? {});
+		if (isSystemPresetId(id)) return expandSystemSnapshot(systemPresetsById.value.get(id)?.content ?? {}, id);
 		const row = presetsById.value.get(id);
 		if (!row) return {};
 		const wire = row.data?.content;
@@ -884,48 +1156,64 @@ function createPresetState(opts) {
 		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);
+	function saveActive() {
+		return track(async () => {
+			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 togglePublic(id) {
-		await requirePresets().togglePublic(id);
+	function saveAs(label, saveOpts = {}) {
+		return track(async () => {
+			const id = await requirePresets().savePresetAs(label, captureSnapshot(saveOpts.aspects), { public: saveOpts.public });
+			clearLocalDraft();
+			return id;
+		});
 	}
-	async function setDefault(id) {
-		await requirePresets().setDefault(id);
+	function rename(id, label) {
+		return track(async () => {
+			await requirePresets().renamePreset(id, label);
+		});
 	}
-	async function toggleFav(id) {
-		await requirePresets().toggleFav(id);
+	function remove(id) {
+		return track(async () => {
+			const handle = requirePresets();
+			const wasActive = activeId.value === id;
+			await handle.deletePreset(id);
+			if (wasActive) {
+				apply(STANDARD_PRESET_ID);
+				clearLocalDraft();
+			}
+		});
 	}
-	async function setFavorites(ids) {
-		await requirePresets().setFavorites(ids);
+	function togglePublic(id) {
+		return track(async () => {
+			await requirePresets().togglePublic(id);
+		});
+	}
+	function setDefault(id) {
+		return track(async () => {
+			await requirePresets().setDefault(id);
+		});
+	}
+	function toggleFav(id) {
+		return track(async () => {
+			await requirePresets().toggleFav(id);
+		});
+	}
+	function setFavorites(ids) {
+		return track(async () => {
+			await requirePresets().setFavorites(ids);
+		});
 	}
 	function batch(fn) {
-		return opts.presetsHandle ? opts.presetsHandle.batch(fn) : fn();
+		return track(() => opts.presetsHandle ? opts.presetsHandle.batch(fn) : fn());
 	}
 	function resolveDefaultId() {
 		const pinned = (userConf.value?.data)?.defaultPresetId;
@@ -941,7 +1229,7 @@ function createPresetState(opts) {
 			stop();
 			const id = resolveDefaultId();
 			const { snapshot, nextActiveId } = resolveSnapshot(id);
-			const base = isSystemPresetId(id) ? expandSystemSnapshot(snapshot) : snapshot;
+			const base = isSystemPresetId(id) ? expandSystemSnapshot(snapshot, id) : snapshot;
 			const draftEnabled = !!(opts.draftHandle && opts.persistDrafts);
 			apply(draftEnabled ? opts.draftHandle.hydrate(base) : base);
 			activeId.value = nextActiveId;
@@ -960,6 +1248,8 @@ function createPresetState(opts) {
 			systemPresets,
 			systemPresetsById,
 			availableAspects,
+			systemAspects,
+			ownedAspects,
 			available,
 			activeId,
 			activeSnapshot,
@@ -982,7 +1272,8 @@ function createPresetState(opts) {
 			setDefault,
 			toggleFav,
 			setFavorites,
-			batch
+			batch,
+			lastError
 		},
 		internals: {
 			gate,
@@ -1233,17 +1524,21 @@ const DEFAULT_BLOCK_SIZE = 100;
 const DEFAULT_DRAG_RELEASE_DEBOUNCE_MS = 300;
 const DEFAULT_ITEMS_PER_PAGE = 25;
 let _tblUid = 0;
+/** Shared empty sorter list — keeps `splitSorters` identity-stable. */
+const EMPTY_SORTERS = Object.freeze([]);
 /**
-* 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.
+* Build the value reader used for in-memory sorting: a display column's
+* `sortValue(row)` wins for its own key, everything else reads the row by
+* path. Returns `getCellValue` itself when no display column defines one.
 */
-function cellAsString(v) {
-	if (v == null) return "";
-	if (typeof v === "string") return v;
-	if (typeof v === "number" || typeof v === "boolean") return v.toString();
-	return "";
+function createSortValueReader(display) {
+	const map = /* @__PURE__ */ new Map();
+	for (const d of display ?? []) if (d.sortValue) map.set(d.key, d.sortValue);
+	if (map.size === 0) return getCellValue;
+	return (row, field) => {
+		const fn = map.get(field);
+		return fn ? fn(row) : getCellValue(row, field);
+	};
 }
 /**
 * Promise-based dialog slot. A second `request()` while one is open
@@ -1252,17 +1547,20 @@ function cellAsString(v) {
 */
 function createRequestSlot(cancelValue) {
 	const r = shallowRef(null);
+	const display = shallowRef(null);
 	function request(body) {
 		if (r.value) {
 			r.value.resolve(cancelValue);
 			r.value = null;
 		}
-		return new Promise((resolve) => {
+		const promise = new Promise((resolve) => {
 			r.value = {
 				...body,
 				resolve
 			};
 		});
+		display.value = r.value;
+		return promise;
 	}
 	function accept(value) {
 		const req = r.value;
@@ -1276,11 +1574,16 @@ function createRequestSlot(cancelValue) {
 		r.value = null;
 		req.resolve(cancelValue);
 	}
+	function release() {
+		if (r.value === null) display.value = null;
+	}
 	return {
 		ref: r,
+		display,
 		request,
 		accept,
-		dismiss
+		dismiss,
+		release
 	};
 }
 function createTableState(opts) {
@@ -1311,6 +1614,13 @@ function createTableState(opts) {
 	});
 	const rowDelete = ref(false);
 	const includeActions = ref(false);
+	const rowActions = ref(void 0);
+	/**
+	* The per-screen row-action policy, compiled once per config change instead
+	* of once per row per render — and read by every surface that renders row
+	* actions, so the cell and the selection toolbar can't drift apart.
+	*/
+	const rowActionsPolicy = computed(() => compileRowActionsConfig(rowActions.value));
 	const filters = shallowRef({});
 	const results = shallowRef([]);
 	const resultsStart = ref(0);
@@ -1360,6 +1670,7 @@ function createTableState(opts) {
 		presetsHandle: opts.preset?.presetsHandle,
 		draftHandle: opts.preset?.draftHandle,
 		availableAspects: opts.preset?.availableAspects,
+		systemAspects: opts.preset?.systemAspects,
 		persistDrafts: opts.preset?.persistDrafts,
 		fallbackSystemPresets: opts.preset?.fallbackSystemPresets
 	});
@@ -1372,8 +1683,10 @@ function createTableState(opts) {
 			message
 		});
 	}
+	const confirmDisplay = promptSlot.display;
 	const acceptPrompt = () => promptSlot.accept(true);
 	const dismissPrompt = promptSlot.dismiss;
+	const releaseConfirm = promptSlot.release;
 	const formSlot = createRequestSlot(null);
 	const actionFormRequest = formSlot.ref;
 	function requestActionInput(action, ctx) {
@@ -1383,8 +1696,10 @@ function createTableState(opts) {
 			preferredId: ctx.preferredId
 		});
 	}
+	const actionFormDisplay = formSlot.display;
 	const acceptActionForm = formSlot.accept;
 	const dismissActionForm = formSlot.dismiss;
+	const releaseActionForm = formSlot.release;
 	const stateUid = `tbl-${++_tblUid}`;
 	function rowId(absIndex) {
 		return `${stateUid}-row-${absIndex}`;
@@ -1392,23 +1707,65 @@ function createTableState(opts) {
 	let generation = 0;
 	let queryDetected = false;
 	let skipPaginationWatch = 0;
-	function buildCurrentQuery() {
+	/**
+	* Paths of client-owned columns — they have no server field behind them, so
+	* they are stripped from `$select` and from `$sort`. Recomputed only when
+	* the column set changes.
+	*/
+	const localColumnPaths = computed(() => {
+		const out = /* @__PURE__ */ new Set();
+		for (const c of allColumns.value) if (c.local) out.add(c.path);
+		return out;
+	});
+	/**
+	* The active sorters split by who applies them: `server` goes into `$sort`,
+	* `local` targets a client-owned column and is applied in memory. One pass,
+	* one dependency — the two halves are complements.
+	*/
+	const splitSorters = computed(() => {
+		const paths = localColumnPaths.value;
+		if (paths.size === 0) return {
+			local: EMPTY_SORTERS,
+			server: sorters.value
+		};
+		const local = [];
+		const server = [];
+		for (const s of sorters.value) (paths.has(s.field) ? local : server).push(s);
+		return {
+			local,
+			server
+		};
+	});
+	/** `true` while the query deliberately drops user sorters to keep search relevance. */
+	function sortersIgnored() {
+		return ignoreSortersWhenSearched.value && !!searchTerm.value;
+	}
+	/** Reads the value a sorter orders by — a display column's `sortValue` wins. */
+	const sortValueOf = createSortValueReader(opts.displayColumns);
+	function applyLocalSort(rows) {
+		if (queryOpts?.preSorted) return rows;
+		if (splitSorters.value.local.length === 0 || sortersIgnored()) return rows;
+		return sortRowsLocally(rows, queryOpts?.forceSorters?.length ? mergeSorters(queryOpts.forceSorters, sorters.value) : sorters.value, sortValueOf);
+	}
+	function buildCurrentQuery(buildOpts) {
 		const available = tableDef.value?.fetchableFields ?? new Set(allColumns.value.map((c) => c.path));
 		const extra = /* @__PURE__ */ new Set();
 		for (const c of columns.value) for (const p of c.selectWith ?? []) if (available.has(p)) extra.add(p);
 		if (queryOpts?.alwaysSelected) {
 			for (const p of queryOpts.alwaysSelected) if (available.has(p)) extra.add(p);
 		}
+		const localPaths = localColumnPaths.value;
+		const requested = buildOpts?.columnPaths ?? columnNames.value;
 		return buildTableQuery({
-			visibleColumnPaths: columnNames.value,
+			visibleColumnPaths: localPaths.size ? requested.filter((p) => !localPaths.has(p)) : requested,
 			extraSelect: extra.size ? [...extra] : void 0,
-			sorters: sorters.value,
+			sorters: splitSorters.value.server,
 			forceSorters: queryOpts?.forceSorters,
 			filters: filters.value,
 			forceFilters: queryOpts?.forceFilters,
 			search: searchTerm.value || void 0,
-			ignoreSorters: ignoreSortersWhenSearched.value && !!searchTerm.value,
-			includeActions: includeActions.value
+			ignoreSorters: sortersIgnored(),
+			includeActions: buildOpts?.includeActions ?? includeActions.value
 		});
 	}
 	function dispatchPages(query, page, size) {
@@ -1426,6 +1783,10 @@ function createTableState(opts) {
 	/** -1 == nothing active. */
 	const activeIndex = ref(-1);
 	const navMode = ref("pagination");
+	const isQueryBlocked = computed(() => {
+		const blocked = queryOpts?.blockQuery;
+		return typeof blocked === "function" ? !!blocked() : !!blocked;
+	});
 	const { windowCache, windowLoading, errors, topIndex, viewportRowCount, dataAt, loadingAt, errorAt, loadRange, queryNext, clearSettlements, resetWindow, disposeDebounces } = createWindowFetcher({
 		blockSize,
 		dragReleaseDebounceMs,
@@ -1435,7 +1796,7 @@ function createTableState(opts) {
 		resultsStart,
 		queryingNext,
 		getGeneration: () => generation,
-		isQueryBlocked: () => !!queryOpts?.blockQuery,
+		isQueryBlocked: () => isQueryBlocked.value,
 		buildCurrentQuery,
 		dispatchPages,
 		reportError
@@ -1445,7 +1806,7 @@ function createTableState(opts) {
 		if (idx < 0) return void 0;
 		return navMode.value === "window" ? dataAt(idx) : results.value[idx];
 	}
-	const { selectedRows, selectedCount, rowValueFn, isPkSelected, toggleActiveSelection } = createSelectionApi(selectionOpts, getActiveRow);
+	const { selectedRows, selectedCount, rowValueFn, isPkSelected, rowSelectable, isRowSelectable, selectableRows, selectableCount, selectAll, toggleActiveSelection } = createSelectionApi(selectionOpts, getActiveRow, activeIndex);
 	const { actions } = createActions({
 		tableDef,
 		client,
@@ -1481,7 +1842,7 @@ function createTableState(opts) {
 		toggleActiveSelection
 	});
 	async function runQuery(kind, silent = false) {
-		if (queryOpts?.blockQuery) return;
+		if (isQueryBlocked.value) return;
 		mustRefresh.value = false;
 		if (!silent && kind !== "initial" && topIndex.value !== 0) topIndex.value = 0;
 		const thisGen = ++generation;
@@ -1522,7 +1883,7 @@ function createTableState(opts) {
 	let pendingSilent = true;
 	let queryFlushScheduled = false;
 	function scheduleQuery(kind = "query", opts) {
-		if (queryOpts?.blockQuery) return;
+		if (isQueryBlocked.value) return;
 		if (tableDef.value === null) return;
 		pendingScheduledKind = pendingScheduledKind ?? kind;
 		if (!(opts?.silent ?? false)) {
@@ -1552,7 +1913,7 @@ function createTableState(opts) {
 	async function queryImmediate(opts) {
 		pendingScheduledKind = null;
 		pendingSilent = true;
-		if (queryOpts?.blockQuery) return;
+		if (isQueryBlocked.value) return;
 		if (tableDef.value === null) return;
 		await runQuery("query", opts?.silent ?? false);
 	}
@@ -1610,7 +1971,13 @@ function createTableState(opts) {
 		rowValueFn,
 		resolveHref: opts.actions?.resolveHref ?? ((url) => url),
 		isPkSelected,
+		rowSelectable,
+		isRowSelectable,
+		selectableRows,
+		selectableCount,
+		selectAll,
 		rowDelete,
+		rowActions,
 		includeActions,
 		activeIndex,
 		navMode,
@@ -1625,18 +1992,27 @@ function createTableState(opts) {
 		registerMainActionListener,
 		actions,
 		confirmRequest,
+		confirmDisplay,
 		prompt: promptFn,
 		acceptPrompt,
 		dismissPrompt,
+		releaseConfirm,
 		actionFormRequest,
+		actionFormDisplay,
 		requestActionInput,
 		acceptActionForm,
 		dismissActionForm,
+		releaseActionForm,
 		query,
 		queryImmediate,
 		queryNext,
 		loadRange,
 		invalidate,
+		buildQuery: buildCurrentQuery,
+		fetchPage: dispatchPages,
+		localColumnPaths,
+		applyLocalSort,
+		rowActionsPolicy,
 		dataAt,
 		loadingAt,
 		errorAt,
@@ -1777,7 +2153,7 @@ function createTableState(opts) {
 		lastEmittedUrl = serializeStateForUrl();
 		nextTick(() => {
 			hydratingFromUrl = false;
-			if (wasQueryDetected && !queryOpts?.blockQuery && tableDef.value !== null) scheduleQuery();
+			if (wasQueryDetected && !isQueryBlocked.value && tableDef.value !== null) scheduleQuery();
 		});
 	}
 	const debouncedFilterQuery = debounce(() => {
@@ -1795,6 +2171,11 @@ function createTableState(opts) {
 		if (sortersEqual(prev, next)) return;
 		if (searchTerm.value) setIgnoreSortersInternal(false);
 		if (!queryDetected) return;
+		const paths = localColumnPaths.value;
+		if (paths.size > 0) {
+			const keep = (s) => !paths.has(s.field);
+			if (sortersEqual(prev.filter(keep), next.filter(keep))) return;
+		}
 		requestRefresh();
 	}, { immediate: false });
 	watch(() => searchTerm.value, (next, prev) => {
@@ -1838,9 +2219,11 @@ function createTableState(opts) {
 	watch([
 		() => tableDef.value,
 		() => queryOpts?.urlQueryReady?.value ?? true,
-		presetGateOpen
-	], ([def, urlReady, presetReady]) => {
+		presetGateOpen,
+		() => isQueryBlocked.value
+	], ([def, urlReady, presetReady, blocked]) => {
 		if (queryDetected) return;
+		if (blocked) return;
 		if (def === null || !urlReady || !presetReady) return;
 		if (queryOpts?.queryOnMount === false) return;
 		if (allColumns.value.length === 0) return;
@@ -1848,6 +2231,11 @@ function createTableState(opts) {
 		queryDetected = true;
 		scheduleQuery("initial");
 	});
+	watch(() => isQueryBlocked.value, (blocked) => {
+		if (blocked || !queryDetected) return;
+		if (tableDef.value === null) return;
+		scheduleQuery();
+	});
 	onScopeDispose(() => {
 		debouncedFilterQuery.cancel();
 		disposeDebounces();
@@ -1858,10 +2246,11 @@ function createTableState(opts) {
 		state,
 		internals: {
 			init(def) {
-				allColumns.value = def.columns;
-				const reconciled = reconcileColumnWidthDefaults(def.columns, columnWidths.value);
+				const merged = mergeDisplayColumns(def.columns, opts.displayColumns ?? []);
+				allColumns.value = merged;
+				const reconciled = reconcileColumnWidthDefaults(merged, columnWidths.value);
 				if (reconciled !== columnWidths.value) columnWidths.value = reconciled;
-				if (columnNames.value.length === 0) columnNames.value = def.columns.map((c) => c.path);
+				if (columnNames.value.length === 0) columnNames.value = merged.map((c) => c.path);
 				tableDef.value = def;
 			},
 			resetPagination
@@ -1875,6 +2264,7 @@ function createTableState(opts) {
 */
 function createStaticTableState(opts) {
 	let _state = null;
+	let fetcher = null;
 	const queryFn = (q, page, size) => {
 		if (!_state) return Promise.resolve({
 			data: [],
@@ -1883,13 +2273,21 @@ function createStaticTableState(opts) {
 			itemsPerPage: size,
 			pages: 1
 		});
-		return buildStaticQueryFn(opts, _state)(q, page, size);
+		fetcher ??= buildStaticQueryFn(opts, _state);
+		return fetcher(q, page, size);
 	};
 	const result = createTableState({
 		client: {},
 		selection: opts.selection,
 		limit: opts.limit,
-		query: { fn: queryFn }
+		displayColumns: opts.displayColumns,
+		model: opts.model,
+		actions: opts.actions,
+		query: {
+			fn: queryFn,
+			queryOnMount: opts.queryOnMount,
+			preSorted: true
+		}
 	});
 	_state = result.state;
 	result.state.loadingMetadata.value = false;
@@ -1921,26 +2319,24 @@ function createStaticTableState(opts) {
 }
 function buildStaticQueryFn(opts, state) {
 	const searchPaths = opts.searchPaths ?? [];
+	const sortValueOf = createSortValueReader(opts.displayColumns);
+	let sortedFrom = null;
+	let sortedBy = null;
+	let sorted = [];
+	function sortedRows(all) {
+		const by = state.sorters.value;
+		if (all !== sortedFrom || by !== sortedBy) {
+			sorted = sortRowsLocally(all, by, sortValueOf);
+			sortedFrom = all;
+			sortedBy = by;
+		}
+		return sorted;
+	}
 	return (_query, page, size) => {
-		let filtered = opts.rows;
+		const all = toValue(opts.rows);
+		let filtered = opts.localSort === false ? all : sortedRows(all);
 		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;
-		});
+		if (term && searchPaths.length > 0) filtered = filtered.filter((row) => searchPaths.some((p) => cellAsString(getCellValue(row, p)).toLowerCase().includes(term)));
 		const start = (page - 1) * size;
 		return Promise.resolve({
 			data: filtered.slice(start, start + size),
@@ -1994,4 +2390,4 @@ function useRegisterMainActionListener(state, listener, enabled) {
 	});
 }
 //#endregion
-export { isModClick as _, useTableContext as a, ROW_ACTIONS_PATH as b, actionHref as c, ariaLabelFor as d, collectIdentifiers as f, intentToScope as g, intentClass as h, useRegisterMainActionListener as i, applyRowGate as l, extractIdentifier as m, createTableState as n, useTableContextOptional as o, createNavigateGestures as p, provideTableContext as r, DEFAULT_AVAILABLE_ASPECTS as s, createStaticTableState as t, applyRowsGate as u, isPlainLeftClick as v, ROW_ACTIONS_TYPE as x, triggerAction as y };
+export { isModClick as C, ROW_ACTIONS_TYPE as D, ROW_ACTIONS_PATH as E, intentToScope as S, triggerAction as T, ariaLabelFor as _, useTableContext as a, extractIdentifier as b, ASPECT_ICONS as c, readPresetLabel as d, INTERACTIVE_SELECTOR as f, applyRowsGate as g, applyRowGate as h, useRegisterMainActionListener as i, ASPECT_LABELS as l, rowActionHref as m, createTableState as n, useTableContextOptional as o, onSelectControlKeydown as p, provideTableContext as r, DEFAULT_AVAILABLE_ASPECTS as s, createStaticTableState as t, ownerNameOf as u, collectIdentifiers as v, isPlainLeftClick as w, intentClass as x, createNavigateGestures as y };