@atscript/vue-table 0.1.146 → 0.1.148

package/dist/{use-table-state-Ddr2UZzB.cjs → use-table-state-BQchKxUr.cjs}

@@ -186,6 +186,24 @@ function rowsActionGate(rows) {
 		return text;
 	});
 }
+/** Disabled reason of a non-query-target action in a query selection. Since 0.1.147. */
+const QUERY_TARGET_UNSUPPORTED_REASON = "Not available for all matching rows — select rows individually";
+/**
+* The gate a query selection ("every row matching the query") puts on the
+* `'rows'` actions: enabled iff the action takes a query target
+* (`queryTarget`) of at least `count` rows; otherwise kept DISABLED with the
+* reason ({@link QUERY_TARGET_UNSUPPORTED_REASON}, or "At most {max} rows").
+* The loaded rows' `$actions` are deliberately not consulted — a sample of
+* the matching rows cannot speak for the rest; the server gates every row
+* when the action runs. Since 0.1.147.
+*/
+function queryTargetGate(count) {
+	return (a) => {
+		if (!a.queryTarget) return QUERY_TARGET_UNSUPPORTED_REASON;
+		const max = a.queryTarget.maxRows;
+		return count > max ? `At most ${rowsLabel(max)}` : true;
+	};
+}
 /**
 * Apply the BULK union gate to a `{default, others, rows}` triple. See
 * {@link rowsActionGate} for the union semantics; identity-stable (returns
@@ -212,47 +230,111 @@ function intentToScope(intent) {
 		default: return;
 	}
 }
+/** The value at a dot `path` of `row` (a flat dotted key wins). */
+function valueAt(row, path) {
+	return Object.hasOwn(row, path) ? row[path] : require_get_cell_value.getCellValue(row, path);
+}
+/** Write `value` at a dot `path` of `out`, creating the nested objects. */
+function setAt(out, path, value) {
+	(0, _atscript_ui.setByPath)({ value: out }, path, value);
+}
+/**
+* The fields an action identifier is built from — `tableDef.identifierFields`
+* (`preferredId` plus every delegated action's `idMap` path), falling back to
+* `preferredId` for a hand-built `TableDef` without it. Since 0.1.147.
+*/
+function identifierFieldsOf(def) {
+	return def?.identifierFields ?? def?.preferredId ?? [];
+}
 /**
 * 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
+* - a row-shaped object (default `rowValueFn`) → picks the `fields` (a dot
+*   path keeps the row's nesting: `ref.key` → `{ ref: { key } }`);
+* - a scalar value when `fields` has exactly one entry (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.
+* `fields` is usually `identifierFields` (see {@link identifierFieldsOf}), so
+* the identifier carries what a delegated action maps from; each action then
+* takes the part it needs ({@link actionIdentifiers}).
+*
+* Returns `undefined` when `fields` is empty, the source is
+* `null`/`undefined`, or a scalar can't be paired with a single field.
 */
-function extractIdentifier(source, preferredId) {
+function extractIdentifier(source, fields) {
 	if (source === void 0 || source === null) return void 0;
-	if (preferredId.length === 0) return void 0;
+	if (fields.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];
+		for (const k of fields) setAt(out, k, valueAt(row, k));
 		return out;
 	}
-	if (preferredId.length === 1) return { [preferredId[0]]: source };
+	if (fields.length === 1) return { [fields[0]]: source };
 }
 /**
 * Map a list of sources (full row objects or scalar `rowValueFn` values)
 * through `extractIdentifier`. Scalar sources resolve to their loaded row via
 * `state.rowOf` so consumers that override `rowValueFn` to return a scalar
 * can still reconstruct multi-field identifiers; a scalar whose row is not
-* loaded falls back to itself (a single-field `preferredId` wraps it).
+* loaded falls back to itself (a single field wraps it — or, when `fields`
+* has several, the table's single-field `preferredId` does).
 */
-function collectIdentifiers(state, sources, preferredId) {
-	if (preferredId.length === 0 || sources.length === 0) return [];
+function collectIdentifiers(state, sources, fields) {
+	if (fields.length === 0 || sources.length === 0) return [];
 	const out = [];
 	for (const s of sources) {
 		if (s === void 0 || s === null) continue;
-		const id = extractIdentifier(state.rowOf(s) ?? s, preferredId);
+		const row = state.rowOf(s);
+		const id = extractIdentifier(row ?? s, fields) ?? (row ? void 0 : extractIdentifier(s, preferredIdOf(state)));
 		if (id) out.push(id);
 	}
 	return out;
 }
+/** The fields `action` is addressed by: its `idMap` paths, else `preferredId`. */
+function actionFields(action, preferredId) {
+	return action.idMap ? Object.values(action.idMap) : preferredId;
+}
+/**
+* The identifiers `action` is sent, from the table's identifiers (built
+* from `identifierFields`): a delegated action (`idMap`) keeps exactly its
+* map's paths — the client maps them to the owner's identification — any
+* other action exactly the `preferredId` fields, the identification the
+* server validates. No fields → no identifiers. Identifiers already in that
+* shape come back as the same array. Since 0.1.147.
+*/
+function actionIdentifiers(action, ids, preferredId) {
+	const fields = actionFields(action, preferredId);
+	if (fields.length === 0) return [];
+	const flat = !fields.some((f) => f.includes("."));
+	const exact = (id) => {
+		return Object.keys(id).length === fields.length && fields.every((f) => f in id);
+	};
+	if (flat && ids.every(exact)) return ids;
+	return project(ids, fields, setAt);
+}
+/** `ids` cut down to `fields`, each written with `write`. */
+function project(ids, fields, write) {
+	return ids.map((id) => {
+		const out = {};
+		for (const f of fields) write(out, f, valueAt(id, f));
+		return out;
+	});
+}
+/**
+* A query target's `exclude` for `action`: like {@link actionIdentifiers},
+* but keyed by the flat (dotted) field names — the shape the server matches
+* exclusions by.
+*/
+function excludeIdentifiers(action, ids, preferredId) {
+	const fields = actionFields(action, preferredId);
+	if (fields.length === 0) return [];
+	return project(ids, fields, (out, f, v) => {
+		out[f] = v;
+	});
+}
 /**
 * Accessible name of an action trigger. A disabled action appends its reason
 * (`"Ship, Order already shipped"` — the same `label, reason` shape as the
@@ -330,7 +412,7 @@ function isModClick(e) {
 */
 function actionHref(state, action, id) {
 	if (action.processor !== "navigate" || action.inputForm) return void 0;
-	const href = (0, _atscript_ui.navigateHrefFor)(action, id, state.tableDef.value?.preferredId ?? []);
+	const href = (0, _atscript_ui.navigateHrefFor)(action, id, preferredIdOf(state));
 	return href === void 0 ? void 0 : state.resolveHref(href);
 }
 /**
@@ -378,6 +460,14 @@ function createNavigateGestures(state, promptCtx, hrefFor) {
 		}
 	};
 }
+/** The table's `preferredId` (empty before its definition loads). */
+function preferredIdOf(state) {
+	return state.tableDef.value?.preferredId ?? [];
+}
+/** Row count a prompt speaks about — `count` when set, else the identifiers. */
+function countOf(ctx) {
+	return ctx.count ?? ctx.identifiers.length;
+}
 /**
 * Run `state.prompt()` if the action declares a `promptText`. Resolves
 * `true` on accept, or `true` immediately when no prompt is needed.
@@ -386,18 +476,32 @@ function createNavigateGestures(state, promptCtx, hrefFor) {
 * picks `singular` when there is at most one identifier, `plural` otherwise.
 * Substitutions:
 * - `$1` → `formatIdentifier(ctx.identifiers[0], ctx.preferredId)`
-* - `$N` → `String(ctx.identifiers.length)`
+* - `$N` → the row count (`ctx.count`, else `ctx.identifiers.length`)
+*
+* A query-targeted run (`ctx.target`) is always confirmed: an action without
+* a `promptText` asks "Run “{label}” on {N} rows?".
 */
 async function confirmAction(state, action, ctx) {
 	const raw = action.promptText;
-	if (!raw) return true;
-	const count = ctx.identifiers.length;
+	const count = countOf(ctx);
+	if (!raw) {
+		if (!ctx.target) return true;
+		return state.prompt(targetPrompt(action, count), { scope: intentToScope(action.intent) });
+	}
 	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, () => (0, _atscript_db_client.formatIdentifier)(ctx.identifiers[0], ctx.preferredId)).replace(/\$N/g, () => String(ctx.identifiers.length));
+	return template.replace(/\$1/g, () => (0, _atscript_db_client.formatIdentifier)(ctx.identifiers[0], ctx.preferredId)).replace(/\$N/g, () => String(countOf(ctx)));
+}
+/** `N row(s)`. */
+function rowsLabel(count) {
+	return `${count} ${count === 1 ? "row" : "rows"}`;
+}
+/** Default confirmation of a query-targeted run without a `promptText`. */
+function targetPrompt(action, count) {
+	return `Run “${action.label || action.name}” on ${rowsLabel(count)}?`;
 }
 /**
 * Dispatch user-initiated invocation: actions with `inputForm` open the form
@@ -409,7 +513,11 @@ function substitute(template, ctx) {
 */
 async function triggerAction(state, action, ctx, event) {
 	if (isActionDisabled(action)) return;
-	const pk = pkForLevel(action.level, ctx.identifiers);
+	if (ctx.target) {
+		await triggerTargetAction(state, action, ctx, ctx.target, event);
+		return;
+	}
+	const pk = pkForLevel(action.level, actionIdentifiers(action, ctx.identifiers, ctx.preferredId));
 	if (action.inputForm) {
 		const input = await state.requestActionInput(action, ctx);
 		if (input === null) return;
@@ -427,6 +535,42 @@ async function triggerAction(state, action, ctx, event) {
 	});
 }
 /**
+* The query-target path of {@link triggerAction}: count the matching rows
+* (`state.actions.countTarget` — a failure settles as the action's error
+* result), confirm with that count (the input form, which shows it, or the
+* prompt), then run with `expectCount` so a set that changed in between is
+* re-confirmed once with its new count instead of silently run.
+*/
+async function triggerTargetAction(state, action, ctx, selection, event) {
+	if (action.level !== "rows" || !action.queryTarget) return;
+	const exclude = excludeIdentifiers(action, selection.exclude, ctx.preferredId);
+	const target = {
+		filter: selection.filter,
+		search: selection.search,
+		index: selection.index,
+		exclude: exclude.length > 0 ? exclude : void 0
+	};
+	const matched = await state.actions.countTarget(action, target, event);
+	if (matched === void 0) return;
+	const counted = {
+		...ctx,
+		identifiers: [],
+		count: matched
+	};
+	let input;
+	if (action.inputForm) {
+		input = await state.requestActionInput(action, counted);
+		if (input === null) return;
+	} else if (!await confirmAction(state, action, counted)) return;
+	state.actions.invoke(action, void 0, {
+		event,
+		input,
+		target,
+		expectCount: matched,
+		confirmTargetChange: (now) => state.prompt(`The rows matching the query changed. ${targetPrompt(action, now)}`, { scope: intentToScope(action.intent) })
+	});
+}
+/**
 * Pick the `pk` argument to forward to `state.actions.invoke` based on the
 * action's level. `'table'` → `undefined`; `'row'` → first identifier;
 * `'rows'` → full array.
@@ -557,6 +701,24 @@ const REMOVE_DEFAULTS = {
 	intent: "negative",
 	promptText: ["Delete item $1?", "Delete $N items?"]
 };
+/** `true` for a {@link TDbActionTargetSummary}-shaped handler return. */
+function isTargetSummary(data) {
+	if (typeof data !== "object" || data === null) return false;
+	const d = data;
+	return typeof d.matched === "number" && typeof d.processed === "number" && Array.isArray(d.skipped) && Array.isArray(d.failed);
+}
+/** The new match count of a 409 `TARGET_CHANGED` refusal, else `undefined`. */
+function targetChangedCount(err) {
+	const e = err;
+	return e?.name === "ActionTargetError" && e.code === "TARGET_CHANGED" && typeof e.matched === "number" ? e.matched : void 0;
+}
+/** `data.message` when the handler returned one. */
+function messageOf(data) {
+	return typeof data === "object" && data !== null && "message" in data ? data.message : void 0;
+}
+function toError(err) {
+	return err instanceof Error ? err : new Error(String(err));
+}
 function createActions(opts) {
 	const invoking = (0, vue.shallowRef)(/* @__PURE__ */ new Set());
 	const lastResult = (0, vue.shallowRef)(/* @__PURE__ */ new Map());
@@ -606,12 +768,16 @@ function createActions(opts) {
 					};
 					break;
 				default: {
+					if (callOpts?.target) {
+						result = await invokeOnTarget(action, callOpts.target, callOpts);
+						break;
+					}
 					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
+						message: messageOf(data)
 					};
 					break;
 				}
@@ -620,15 +786,62 @@ function createActions(opts) {
 			result = {
 				ok: false,
 				kind: "error",
-				error: err instanceof Error ? err : new Error(String(err))
+				error: toError(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 (result.ok && result.kind === "backend" && result.target) opts.onTargetSettled?.();
 		if (opts.onResolved) opts.onResolved(action, idsForAction(action.level, pk), result, callOpts?.event);
 		return result;
 	}
+	/**
+	* `client.actionOnQuery` with the confirmed `expectCount`; a 409
+	* `TARGET_CHANGED` asks `confirmTargetChange` once with the new count and,
+	* on yes, runs again expecting it. Throws what the client throws.
+	*/
+	async function invokeOnTarget(action, target, callOpts) {
+		let expectCount = callOpts.expectCount;
+		const run = () => opts.client.actionOnQuery(action.name, {
+			...target,
+			expectCount
+		}, callOpts.input);
+		let data;
+		try {
+			data = await run();
+		} catch (err) {
+			const now = targetChangedCount(err);
+			if (now === void 0 || !await callOpts.confirmTargetChange?.(now)) throw err;
+			expectCount = now;
+			data = await run();
+		}
+		const summary = isTargetSummary(data) ? data : void 0;
+		return {
+			ok: true,
+			kind: "backend",
+			data,
+			message: messageOf(data),
+			target: {
+				matched: summary?.matched ?? expectCount ?? 0,
+				summary
+			}
+		};
+	}
+	async function countTarget(action, target, event) {
+		try {
+			return (await opts.client.countActionTarget(action.name, target)).matched;
+		} catch (err) {
+			const result = {
+				ok: false,
+				kind: "error",
+				error: toError(err)
+			};
+			setLastResult(action.name, result);
+			opts.onResolved?.(action, [], result, event);
+			return;
+		}
+	}
 	return {
 		actions: {
 			get table() {
@@ -650,6 +863,7 @@ function createActions(opts) {
 				return groups.value.cellRow;
 			},
 			invoke,
+			countTarget,
 			invoking,
 			lastResult
 		},
@@ -727,10 +941,12 @@ const SELECTABLE = Object.freeze({ ok: true });
 const NOT_SELECTABLE = Object.freeze({ ok: false });
 /**
 * The header tri-state from how many of the rows in scope are eligible and
-* how many of those are selected.
+* how many of those are selected. In a query selection (`queryMode`) the
+* header is never `"none"`: rows outside the loaded ones stay selected, so a
+* page whose rows are all excluded still reads `"some"`.
 */
-function toSelectAllState(selected, selectable) {
-	if (selected === 0) return "none";
+function toSelectAllState(selected, selectable, queryMode = false) {
+	if (selected === 0 && !queryMode) return "none";
 	return selected >= selectable ? "all" : "some";
 }
 /** Normalise a {@link RowSelectableHook} return value. `""` carries no reason. */
@@ -743,8 +959,27 @@ function verdictOf(value) {
 }
 function createSelectionApi(opts, getActiveRow, activeIndex, windowCache) {
 	const selectedRows = opts?.selectedRows ?? (0, vue.shallowRef)([]);
-	const selectedCount = (0, vue.computed)(() => selectedRows.value.length);
+	const querySelection = opts?.querySelection ?? (0, vue.shallowRef)(null);
+	const selectedCount = (0, vue.computed)(() => {
+		const q = querySelection.value;
+		return q ? Math.max(0, q.total - q.excluded.length) : selectedRows.value.length;
+	});
+	const selection = (0, vue.computed)(() => {
+		const q = querySelection.value;
+		return q ? {
+			mode: "query",
+			query: q.query,
+			excluded: q.excluded,
+			total: q.total,
+			count: selectedCount.value
+		} : {
+			mode: "ids",
+			ids: selectedRows.value,
+			count: selectedCount.value
+		};
+	});
 	const rowValueFn = opts?.rowValueFn ?? ((row) => row);
+	const identityOf = opts?.identityOf ?? ((value) => value);
 	const rowByValue = (0, vue.computed)(() => {
 		const map = /* @__PURE__ */ new Map();
 		for (const row of windowCache.value.values()) map.set(rowValueFn(row), row);
@@ -757,6 +992,10 @@ function createSelectionApi(opts, getActiveRow, activeIndex, windowCache) {
 	}
 	const selectedRowObjects = (0, vue.computed)(() => {
 		const out = [];
+		if (querySelection.value) {
+			for (const row of windowCache.value.values()) if (!excludedSet.value.has(identityOf(rowValueFn(row)))) out.push(row);
+			return out;
+		}
 		for (const value of selectedRows.value) {
 			const row = rowOf(value);
 			if (row) out.push(row);
@@ -764,8 +1003,27 @@ function createSelectionApi(opts, getActiveRow, activeIndex, windowCache) {
 		return out;
 	});
 	const selectedSet = (0, vue.computed)(() => new Set(selectedRows.value));
+	/** Identity keys of the excluded values (see `identityOf`). */
+	const excludedSet = (0, vue.computed)(() => new Set((querySelection.value?.excluded ?? []).map(identityOf)));
 	function isPkSelected(pk) {
-		return selectedSet.value.has(pk);
+		return querySelection.value ? !excludedSet.value.has(identityOf(pk)) : selectedSet.value.has(pk);
+	}
+	/** Replace the query selection's `excluded` list (a no-op when unchanged). */
+	function setExcluded(next) {
+		const q = querySelection.value;
+		if (q && next !== q.excluded) querySelection.value = {
+			...q,
+			excluded: next
+		};
+	}
+	function enterQuerySelection(query, total) {
+		if (selectedRows.value.length > 0) selectedRows.value = [];
+		querySelection.value = {
+			query,
+			signature: (0, _atscript_ui_table.selectionSignature)(query),
+			excluded: [],
+			total
+		};
 	}
 	const rowSelectable = (0, vue.ref)();
 	function isRowSelectable(row, index) {
@@ -788,32 +1046,57 @@ function createSelectionApi(opts, getActiveRow, activeIndex, windowCache) {
 		for (let i = 0; i < rows.length; i++) if (isRowSelectable(rows[i], i).ok) n++;
 		return n;
 	}
-	function eligiblePks(rows) {
-		return (0, _atscript_ui_table.rowsToPks)(selectableRows(rows), rowValueFn);
+	function eligiblePks(rows, indexOf) {
+		return (0, _atscript_ui_table.rowsToPks)(indexOf ? rows.filter((row, i) => isRowSelectable(row, indexOf(i)).ok) : selectableRows(rows), rowValueFn);
 	}
 	function addPks(pks) {
+		if (querySelection.value) {
+			const drop = new Set(pks.map(identityOf));
+			const excluded = querySelection.value.excluded;
+			const next = excluded.filter((pk) => !drop.has(identityOf(pk)));
+			setExcluded(next.length === excluded.length ? excluded : next);
+			return;
+		}
 		const current = selectedSet.value;
 		const added = [...new Set(pks)].filter((pk) => !current.has(pk));
 		if (added.length > 0) selectedRows.value = [...selectedRows.value, ...added];
 	}
 	function removePks(pks) {
+		if (querySelection.value) {
+			const seen = new Set(excludedSet.value);
+			const added = [];
+			for (const pk of pks) {
+				const key = identityOf(pk);
+				if (seen.has(key)) continue;
+				seen.add(key);
+				added.push(pk);
+			}
+			if (added.length > 0) setExcluded([...querySelection.value.excluded, ...added]);
+			return;
+		}
 		const drop = new Set(pks);
 		const next = selectedRows.value.filter((pk) => !drop.has(pk));
 		if (next.length !== selectedRows.value.length) selectedRows.value = next;
 	}
 	function selectAll(rows, indexOf) {
-		addPks((0, _atscript_ui_table.rowsToPks)(indexOf ? rows.filter((row, i) => isRowSelectable(row, indexOf(i)).ok) : selectableRows(rows), rowValueFn));
+		addPks(eligiblePks(rows, indexOf));
 	}
 	function deselectAll(rows) {
 		removePks(eligiblePks(rows));
 	}
-	function toggleAll(rows) {
-		const pks = eligiblePks(rows);
-		const selected = pks.filter((pk) => selectedSet.value.has(pk)).length;
-		if (toSelectAllState(selected, pks.length) === "all") removePks(pks);
+	function toggleAll(rows, indexOf) {
+		const pks = eligiblePks(rows, indexOf);
+		const all = pks.every(isPkSelected);
+		if (querySelection.value) {
+			if (all) clearSelection();
+			else addPks(pks);
+			return;
+		}
+		if (pks.length > 0 && all) removePks(pks);
 		else addPks(pks);
 	}
 	function clearSelection() {
+		if (querySelection.value) querySelection.value = null;
 		if (selectedRows.value.length > 0) selectedRows.value = [];
 	}
 	function toggleActiveSelection(mode) {
@@ -821,10 +1104,18 @@ function createSelectionApi(opts, getActiveRow, activeIndex, windowCache) {
 		const row = getActiveRow();
 		if (row === void 0) return;
 		if (!isRowSelectable(row, activeIndex.value).ok) return;
+		const q = querySelection.value;
+		if (q) {
+			setExcluded((0, _atscript_ui_table.togglePk)(q.excluded, rowValueFn(row), "multi", identityOf));
+			return;
+		}
 		selectedRows.value = (0, _atscript_ui_table.togglePk)(selectedRows.value, rowValueFn(row), mode);
 	}
 	return {
 		selectedRows,
+		querySelection,
+		selection,
+		enterQuerySelection,
 		selectedCount,
 		selectedSet,
 		rowValueFn,
@@ -1868,7 +2159,8 @@ function sameResidualFilters(a, b) {
 */
 function warnUnsupportedFilter(issue) {
 	if (!_atscript_ui_table.DEV) return;
-	console.warn(`[vue-table] URL filter left out (${issue.reason}): ${JSON.stringify(issue.expr)}. Field filters cannot express it, so the table shows more rows than the URL described.`);
+	const why = issue.reason === "syntax" ? "It does not parse" : "Field filters cannot express it";
+	console.warn(`[vue-table] URL filter left out (${issue.reason}): ${issue.raw ?? JSON.stringify(issue.expr)}. ${why}, so the table shows more rows than the URL described.`);
 }
 /**
 * The report for fields the table left out when nobody handles it
@@ -1907,6 +2199,8 @@ function createTableState(opts) {
 	});
 	const rowDelete = (0, vue.ref)(false);
 	const includeActions = (0, vue.ref)(false);
+	const selectMode = (0, vue.ref)("none");
+	const allowSelectAllMatching = (0, vue.ref)(false);
 	const rowActions = (0, vue.ref)(void 0);
 	/**
 	* The per-screen row-action policy, compiled once per config change instead
@@ -2012,7 +2306,8 @@ function createTableState(opts) {
 		return formSlot.request({
 			action,
 			identifiers: ctx.identifiers,
-			preferredId: ctx.preferredId
+			preferredId: ctx.preferredId,
+			count: ctx.count
 		});
 	}
 	const actionFormDisplay = formSlot.display;
@@ -2064,10 +2359,33 @@ function createTableState(opts) {
 	}
 	/** Reads the value a sorter orders by — a display column's `sortValue` wins. */
 	const sortValueOf = createSortValueReader(opts.displayColumns);
+	/** The app-authored scope, read live — the query, local sort and chrome all go through these. */
+	const forceFilters = (0, vue.computed)(() => (0, vue.toValue)(queryOpts?.forceFilters));
+	const timeZone = (0, vue.computed)(() => (0, vue.toValue)(queryOpts?.timeZone));
+	const weekStart = (0, vue.computed)(() => (0, vue.toValue)(queryOpts?.weekStart));
+	/**
+	* Turns a typed filter value into what the server accepts (date periods in
+	* `timeZone`, boolean text → boolean). Rebuilt when the columns, the zone or
+	* the week start change; "today" is read at each query build.
+	*/
+	const encodeCondition = (0, vue.computed)(() => (0, _atscript_ui_table.createColumnValueEncoder)(allColumns.value, {
+		timeZone: timeZone.value,
+		weekStart: weekStart.value
+	}));
+	const forceSorters = (0, vue.computed)(() => (0, vue.toValue)(queryOpts?.forceSorters) ?? []);
+	/** Whether a date filter is set — the only filters a zone or week-start change affects. */
+	function hasFilledTemporalFilter() {
+		for (const c of allColumns.value) {
+			if (!c.valueKind || !(0, _atscript_ui_table.isTemporalKind)((0, _atscript_ui_table.columnFilterKind)(c))) continue;
+			if (filters.value[c.path]?.some(_atscript_ui_table.isFilled)) return true;
+		}
+		return false;
+	}
 	function applyLocalSort(rows) {
 		if (queryOpts?.preSorted) return rows;
 		if (splitSorters.value.local.length === 0 || sortersIgnored()) return rows;
-		return (0, _atscript_ui_table.sortRowsLocally)(rows, queryOpts?.forceSorters?.length ? (0, _atscript_ui_table.mergeSorters)(queryOpts.forceSorters, sorters.value) : sorters.value, sortValueOf);
+		const forced = forceSorters.value;
+		return (0, _atscript_ui_table.sortRowsLocally)(rows, forced.length ? (0, _atscript_ui_table.mergeSorters)(forced, sorters.value) : sorters.value, sortValueOf);
 	}
 	/**
 	* The query's view of the model, gated to the fields this caller can use.
@@ -2110,8 +2428,10 @@ function createTableState(opts) {
 		const available = tableDef.value?.fetchableFields ?? knownFields.value?.columns ?? /* @__PURE__ */ new Set();
 		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);
+		for (const p of (0, vue.toValue)(queryOpts?.alwaysSelected) ?? []) if (available.has(p)) extra.add(p);
+		const def = tableDef.value;
+		if (def?.identifierFields && def.identifierFields !== def.preferredId) {
+			for (const p of def.identifierFields) if (available.has(p) && !def.preferredId.includes(p)) extra.add(p);
 		}
 		const model = queryModel.value;
 		if (_atscript_ui_table.DEV && model.stripped.length > 0) {
@@ -2127,10 +2447,11 @@ function createTableState(opts) {
 			visibleColumnPaths: (buildOpts?.columnPaths ?? model.columnNames).filter((p) => !localPaths.has(p) && (!known || known.columns.has(p))),
 			extraSelect: extra.size ? [...extra] : void 0,
 			sorters: model.sorters,
-			forceSorters: queryOpts?.forceSorters,
+			forceSorters: forceSorters.value,
 			filters: model.filters,
+			encodeCondition: encodeCondition.value,
 			residualFilters: model.residual,
-			forceFilters: queryOpts?.forceFilters,
+			forceFilters: forceFilters.value,
 			search: searchTerm.value || void 0,
 			ignoreSorters: sortersIgnored(),
 			includeActions: buildOpts?.includeActions ?? includeActions.value
@@ -2187,14 +2508,79 @@ function createTableState(opts) {
 		if (idx < 0) return void 0;
 		return navMode.value === "window" ? dataAt(idx) : results.value[idx];
 	}
-	const { selectedRows, selectedCount, rowValueFn, rowByValue, rowOf, selectedRowObjects, isPkSelected, rowSelectable, isRowSelectable, selectableRows, selectableCount, selectAll, deselectAll, toggleAll, clearSelection, toggleActiveSelection } = createSelectionApi(selectionOpts, getActiveRow, activeIndex, windowCache);
+	/**
+	* A query selection's exclusions compare row objects (the default
+	* `rowValueFn`) by their identifier — a refetch replaces every row object.
+	*/
+	let identityDef = null;
+	let identityCache = /* @__PURE__ */ new WeakMap();
+	function selectionIdentity(value) {
+		const def = tableDef.value;
+		if (value === null || typeof value !== "object") return value;
+		if (def !== identityDef) {
+			identityDef = def;
+			identityCache = /* @__PURE__ */ new WeakMap();
+		}
+		if (identityCache.has(value)) return identityCache.get(value);
+		const id = extractIdentifier(value, identifierFieldsOf(def));
+		const key = id ? JSON.stringify(Object.values(id)) : value;
+		identityCache.set(value, key);
+		return key;
+	}
+	const selection = createSelectionApi({
+		...selectionOpts,
+		identityOf: selectionIdentity
+	}, getActiveRow, activeIndex, windowCache);
+	const { selectedRows, querySelection, selection: tableSelection, selectedCount, rowValueFn, rowByValue, rowOf, selectedRowObjects, isPkSelected, rowSelectable, isRowSelectable, selectableRows, selectableCount, selectAll, deselectAll, toggleAll, clearSelection, toggleActiveSelection } = selection;
+	const loadedEligiblePks = (0, vue.computed)(() => {
+		const out = [];
+		const offset = navMode.value === "window" ? 0 : resultsStart.value;
+		const gated = !!rowSelectable.value;
+		for (const [abs, row] of windowCache.value) if (!gated || isRowSelectable(row, abs - offset).ok) out.push(rowValueFn(row));
+		return out;
+	});
+	const loadedSelectedCount = (0, vue.computed)(() => {
+		let n = 0;
+		for (const pk of loadedEligiblePks.value) if (isPkSelected(pk)) n++;
+		return n;
+	});
+	const hasQueryTargetAction = (0, vue.computed)(() => tableDef.value?.actions.rows.some((a) => !!a.queryTarget) ?? false);
+	const canSelectAllMatching = (0, vue.computed)(() => allowSelectAllMatching.value && selectMode.value === "multi" && !queryOpts?.fn && totalCount.value > windowCache.value.size && hasQueryTargetAction.value);
+	/** The filter / search / index of the query the table would send now. */
+	function currentSelectionQuery() {
+		return (0, _atscript_ui_table.selectionQueryOf)(buildCurrentQuery({ includeActions: false }));
+	}
+	function selectAllMatching() {
+		if (!canSelectAllMatching.value) return;
+		selection.enterQuerySelection(currentSelectionQuery(), totalCount.value);
+	}
+	const holdingQuerySelection = (0, vue.computed)(() => querySelection.value !== null);
+	(0, vue.watch)(() => holdingQuerySelection.value ? (0, _atscript_ui_table.selectionSignature)(currentSelectionQuery()) : null, (live) => {
+		const q = querySelection.value;
+		if (live === null || !q || live === q.signature) return;
+		querySelection.value = null;
+		selectionOpts?.onSelectionReset?.({ reason: "scope" });
+	});
+	(0, vue.watch)([totalCount, querying], ([count, busy]) => {
+		const q = querySelection.value;
+		if (!q || busy || queryError.value || count === q.total) return;
+		if (count === 0 && windowCache.value.size === 0) return;
+		querySelection.value = {
+			...q,
+			total: count
+		};
+	});
+	(0, vue.watch)(selectedRows, (rows) => {
+		if (rows.length > 0 && querySelection.value) querySelection.value = null;
+	});
 	const { actions } = createActions({
 		tableDef,
 		client,
 		rowDelete: () => rowDelete.value,
 		scheduleQuery,
 		refreshOnAction: () => opts.actions?.refreshOnAction?.(),
-		onResolved: opts.actions?.onResolved
+		onResolved: opts.actions?.onResolved,
+		onTargetSettled: clearSelection
 	});
 	let stateRef = null;
 	const { hasMainActionListener, hasMainActionAvailable, registerMainActionListener, requestMainAction } = createMainActionRegistry({
@@ -2206,7 +2592,7 @@ function createTableState(opts) {
 			const action = resolveRowActions(stateRef, row, { withRows: false }).default;
 			if (!action) return;
 			const preferredId = tableDef.value?.preferredId ?? [];
-			const identifiers = collectIdentifiers(stateRef, [row], preferredId);
+			const identifiers = collectIdentifiers(stateRef, [row], identifierFieldsOf(tableDef.value));
 			triggerAction(stateRef, action, {
 				identifiers,
 				preferredId,
@@ -2350,6 +2736,9 @@ function createTableState(opts) {
 		metadataError,
 		lastError,
 		mustRefresh,
+		forceFilters,
+		forceSorters,
+		timeZone,
 		searchTerm,
 		ignoreSortersWhenSearched,
 		configDialogOpen,
@@ -2357,6 +2746,14 @@ function createTableState(opts) {
 		filterDialogColumn,
 		selectedRows,
 		selectedCount,
+		querySelection,
+		selection: tableSelection,
+		allowSelectAllMatching,
+		selectMode,
+		loadedEligiblePks,
+		loadedSelectedCount,
+		canSelectAllMatching,
+		selectAllMatching,
 		rowValueFn,
 		rowByValue,
 		rowOf,
@@ -2634,6 +3031,27 @@ function createTableState(opts) {
 		resetPagination();
 		debouncedFilterQuery();
 	});
+	const readScope = () => ({
+		filter: (0, _atscript_ui_table.stableValueKey)(forceFilters.value ?? null),
+		sorters: (0, _atscript_ui_table.stableValueKey)(forceSorters.value),
+		selected: ((0, vue.toValue)(queryOpts?.alwaysSelected) ?? []).join("\0"),
+		zone: `${timeZone.value ?? ""}|${weekStart.value ?? ""}`
+	});
+	let scope = readScope();
+	(0, vue.watch)(() => Object.values(readScope()).join("
"), () => {
+		const prev = scope;
+		scope = readScope();
+		if (!queryDetected) return;
+		const filterChanged = scope.filter !== prev.filter;
+		if (!filterChanged && scope.sorters === prev.sorters && scope.selected === prev.selected && (scope.zone === prev.zone || !hasFilledTemporalFilter())) return;
+		mustRefresh.value = true;
+		if (hydratingFromUrl) {
+			if (filterChanged && urlQuerySync?.pagination === false) resetPagination();
+			return;
+		}
+		if (filterChanged) resetPagination();
+		scheduleQuery();
+	});
 	(0, vue.watch)(() => sorters.value, (next, prev) => {
 		if (hydratingFromUrl) return;
 		if ((0, _atscript_ui_table.sortersEqual)(prev, next)) return;
@@ -2742,6 +3160,7 @@ function createStaticTableState(opts) {
 			itemsPerPage: size,
 			pages: 1
 		});
+		if (opts.remote) return opts.remote({ searchTerm: _state.searchTerm.value }, page, size);
 		fetcher ??= buildStaticQueryFn(opts, _state);
 		return fetcher(q, page, size);
 	};
@@ -2766,6 +3185,7 @@ function createStaticTableState(opts) {
 		flatMap: /* @__PURE__ */ new Map(),
 		fetchableFields: new Set(opts.columns.map((c) => c.path)),
 		primaryKeys: [],
+		identifierFields: [],
 		preferredId: [],
 		crud: {
 			query: [],
@@ -2883,6 +3303,12 @@ Object.defineProperty(exports, "INTERACTIVE_SELECTOR", {
 		return INTERACTIVE_SELECTOR;
 	}
 });
+Object.defineProperty(exports, "QUERY_TARGET_UNSUPPORTED_REASON", {
+	enumerable: true,
+	get: function() {
+		return QUERY_TARGET_UNSUPPORTED_REASON;
+	}
+});
 Object.defineProperty(exports, "ROW_ACTIONS_PATH", {
 	enumerable: true,
 	get: function() {
@@ -2895,6 +3321,18 @@ Object.defineProperty(exports, "ROW_ACTIONS_TYPE", {
 		return ROW_ACTIONS_TYPE;
 	}
 });
+Object.defineProperty(exports, "actionIdentifiers", {
+	enumerable: true,
+	get: function() {
+		return actionIdentifiers;
+	}
+});
+Object.defineProperty(exports, "applyGate", {
+	enumerable: true,
+	get: function() {
+		return applyGate;
+	}
+});
 Object.defineProperty(exports, "applyRowsGate", {
 	enumerable: true,
 	get: function() {
@@ -2943,6 +3381,12 @@ Object.defineProperty(exports, "extractIdentifier", {
 		return extractIdentifier;
 	}
 });
+Object.defineProperty(exports, "identifierFieldsOf", {
+	enumerable: true,
+	get: function() {
+		return identifierFieldsOf;
+	}
+});
 Object.defineProperty(exports, "intentClass", {
 	enumerable: true,
 	get: function() {
@@ -2997,6 +3441,12 @@ Object.defineProperty(exports, "provideTableContext", {
 		return provideTableContext;
 	}
 });
+Object.defineProperty(exports, "queryTargetGate", {
+	enumerable: true,
+	get: function() {
+		return queryTargetGate;
+	}
+});
 Object.defineProperty(exports, "readPresetLabel", {
 	enumerable: true,
 	get: function() {
@@ -3015,6 +3465,12 @@ Object.defineProperty(exports, "rowActionHref", {
 		return rowActionHref;
 	}
 });
+Object.defineProperty(exports, "rowsLabel", {
+	enumerable: true,
+	get: function() {
+		return rowsLabel;
+	}
+});
 Object.defineProperty(exports, "toSelectAllState", {
 	enumerable: true,
 	get: function() {