@atscript/vue-table 0.1.133 → 0.1.135

package/dist/{types-BZ0HssRY.d.cts → types-CyAmAg10.d.cts}

@@ -1,8 +1,54 @@
 import { Component, ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from "vue";
-import { ClientError, TDbActionInfo, TDbActionProcessor, TDbDeleteResult } from "@atscript/db-client";
+import { ClientError, PageResult, TDbActionInfo, TDbActionProcessor, TDbDeleteResult } from "@atscript/db-client";
+import { Uniquery } from "@uniqu/core";
 import { ColumnDef, PaginationControl, SortControl, TableDef } from "@atscript/ui";
 import { AsPresetEntryRow, AspectMask, ColumnWidthsMap, ConfigTab, FieldFilters, PresetAspect, PresetCapabilities, PresetSnapshot, SelectionMode, SystemPreset, SystemPresetInput, TableStateMethods } from "@atscript/ui-table";
 
+//#region src/composables/state/intent-scope.d.ts
+interface ActionBuckets {
+  default: TVueTableActionInfo | undefined;
+  others: TVueTableActionInfo[];
+  rows: TVueTableActionInfo[];
+}
+/**
+ * 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.
+ */
+declare function extractIdentifier(source: unknown, preferredId: readonly string[]): Record<string, unknown> | undefined;
+//#endregion
+//#region src/composables/state/row-actions-config.d.ts
+/**
+ * A {@link RowActionsConfig} compiled into the two passes a surface runs per
+ * row. Built once per config change (not once per row per render), so the
+ * `include` / `exclude` sets and the override lookups exist once.
+ */
+interface RowActionsPolicy {
+  /**
+   * Narrow + relabel already backend-gated buckets. Callers run
+   * `applyRowGate` FIRST — that order is the whole safety story: `include`
+   * can only narrow what the server allowed for the row, and `overrides`
+   * (presentation only) cannot resurrect an action the server gated away.
+   * Returns the input reference when the policy touches nothing.
+   */
+  apply: (buckets: ActionBuckets) => ActionBuckets;
+  /**
+   * The app-owned actions for `row`. `include` lists SERVER action names —
+   * being listed in `extra` IS an app action's opt-in — so only `exclude` and
+   * the action's own `enabled(row)` apply here. Pass no row to skip the
+   * per-row gate (a surface with no row in hand).
+   */
+  extra: (row?: Record<string, unknown>) => TVueTableActionInfo[];
+}
+//#endregion
 //#region src/types.d.ts
 /** UI-side sentinel for the synthesised row-delete processor. */
 declare const REMOVE_PROCESSOR = "__remove";
@@ -28,6 +74,52 @@ interface InvokeOpts {
    * actions without a form.
    */
   input?: unknown;
+  /**
+   * The row the action was triggered from. Only consumed by client-only row
+   * actions (`RowActionsConfig.extra`), whose `onInvoke(row, pk)` receives it.
+   * Since 0.1.134.
+   */
+  row?: Record<string, unknown>;
+}
+/**
+ * A row action the APP owns — it has no server counterpart, so the backend
+ * never gates it. Either `href` (rendered as a real anchor, mapped through
+ * `state.resolveHref`) or `onInvoke` (runs locally, then settles as an
+ * `@action` emit with `kind: 'custom'`). Since 0.1.134.
+ */
+interface LocalRowAction {
+  /** Unique among the row actions; also the `@action` emit's `action.name`. */
+  name: string;
+  label: string;
+  icon?: string;
+  intent?: TDbActionInfo["intent"];
+  /** Confirmation copy — same `$1` / `$N` substitution as a server action. */
+  promptText?: string | [string, string];
+  /** Link target for the row. Rendered as an anchor, mapped through `state.resolveHref`. */
+  href?: (row: Record<string, unknown>) => string;
+  /** Local handler. Awaited; a rejection settles the action as an error result. */
+  onInvoke?: (row: Record<string, unknown>, pk?: Record<string, unknown>) => void | Promise<void>;
+  /** Per-row gate. Returning `false` hides the action for that row. */
+  enabled?: (row: Record<string, unknown>) => boolean;
+}
+/**
+ * Per-screen presentation policy for the row-actions cell. Narrows and
+ * relabels what the server declared, and appends app-owned actions.
+ *
+ * Backend eligibility stays authoritative: `include` / `exclude` can only
+ * narrow the set a row's `$actions` already allows, and `overrides` only
+ * change how an action looks — neither can surface an action the server
+ * gated away. Since 0.1.134.
+ */
+interface RowActionsConfig {
+  /** Allowlist of server action names. Omitted = every eligible action. */
+  include?: string[];
+  /** Denylist of server action names, applied after `include`. */
+  exclude?: string[];
+  /** Presentation overrides keyed by server action name. */
+  overrides?: Record<string, Partial<Pick<TVueTableActionInfo, "label" | "icon" | "intent" | "promptText">>>;
+  /** App-owned actions appended after the server ones. */
+  extra?: LocalRowAction[];
 }
 /** Discriminated result returned by `state.actions.invoke`. Never throws. */
 type ActionResult = {
@@ -406,6 +498,13 @@ interface ReactiveTableState extends TableStateMethods {
    * remounting.
    */
   rowDelete: Ref<boolean | RowDeleteOpt>;
+  /**
+   * Per-screen row-action policy — writable ref owned by `<AsTableRoot>`,
+   * like {@link rowDelete}. `<AsRowActions>` reads it from the context, so a
+   * standalone `<AsRowActions>` inside the table honours it too (an explicit
+   * `:actions` prop on that component wins). Since 0.1.134.
+   */
+  rowActions: Ref<RowActionsConfig | undefined>;
   /**
    * `?$actions=true` opt-in — writable ref owned by the renderer.
    * `<AsTable>` / `<AsWindowTable>` flip this on whenever their
@@ -557,6 +656,52 @@ interface ReactiveTableState extends TableStateMethods {
    * watchers refetch in reaction to the writes.
    */
   applyUrlQuery: (urlString: string) => void;
+  /**
+   * Build the Uniquery the table's own fetch would send right now — same
+   * filters, sorters, search, force-filters and `$select` projection. Used by
+   * `useTableExport` so an export never drifts from what is on screen.
+   * Since 0.1.134.
+   */
+  buildQuery: (opts?: {
+    columnPaths?: string[];
+    includeActions?: boolean;
+  }) => Uniquery;
+  /**
+   * Run one page through the table's configured query function (or its
+   * client). The single fetch path — a custom `queryFn` is honoured here too.
+   * Since 0.1.134.
+   */
+  fetchPage: (query: Uniquery, page: number, size: number) => Promise<PageResult<Record<string, unknown>>>;
+  /**
+   * Paths of the client-owned (`local`) columns — the ones no server field
+   * backs, so they never enter `$select`, `$sort` or filters. Since 0.1.134.
+   */
+  localColumnPaths: ComputedRef<Set<string>>;
+  /**
+   * Re-order already-loaded rows so a sorter on a client-owned column takes
+   * effect: the page is sorted by the FULL sorter list, which leaves the
+   * server's own ordering intact and slots the local sorter in at its real
+   * priority. Page-local by definition — it can only order what is loaded —
+   * and a no-op (returns the input reference) without a local sorter, in
+   * window mode, or when the rows arrive pre-sorted. Since 0.1.134.
+   */
+  applyLocalSort: <T extends Record<string, unknown>>(rows: T[]) => T[];
+  /**
+   * Whether a sorter on a client-owned column currently does anything — the
+   * single rule behind every sort affordance, so the header and the config
+   * dialog cannot offer different sets. `false` only in window mode behind a
+   * server fetcher, where rows are cached by absolute index and dropped as
+   * the viewport moves; an in-memory provider orders the whole dataset before
+   * it slices, so the sort holds there. Since 0.1.135.
+   */
+  localSortAvailable: ComputedRef<boolean>;
+  /**
+   * The row-action policy from {@link rowActions}, compiled once per config
+   * change. Every surface that renders row actions reads it — the row-actions
+   * cell and the selection toolbar — so they cannot show different sets.
+   * Since 0.1.134.
+   */
+  rowActionsPolicy: ComputedRef<RowActionsPolicy>;
   /**
    * Preset feature surface. Always present; inert (`available=false`,
    * mutators throw) when `useTable({ preset })` was not configured.
@@ -672,4 +817,4 @@ interface PresetSurface {
   lastError: Ref<Error | null>;
 }
 //#endregion
-export { TableNavBridge as S, RowSelectableVerdict as _, EnterAction as a, TVueTableActionInfo as b, NavKeyOptions as c, ReactiveTableState as d, RowAttrsHook as f, RowSelectableHook as g, RowHookContext as h, ConfirmOptions as i, PresetConfig as l, RowDeleteOpt as m, ColumnMenuConfig as n, InvokeOpts as o, RowClassHook as p, ConfigTab as r, MainActionRequest as s, ActionResult as t, QueryErrorKind as u, TAsCellTypeComponents as v, TableActionsState as x, TAsTableControls as y };
+export { TableActionsState as C, TVueTableActionInfo as S, extractIdentifier as T, RowHookContext as _, EnterAction as a, TAsCellTypeComponents as b, MainActionRequest as c, QueryErrorKind as d, ReactiveTableState as f, RowDeleteOpt as g, RowClassHook as h, ConfirmOptions as i, NavKeyOptions as l, RowAttrsHook as m, ColumnMenuConfig as n, InvokeOpts as o, RowActionsConfig as p, ConfigTab as r, LocalRowAction as s, ActionResult as t, PresetConfig as u, RowSelectableHook as v, TableNavBridge as w, TAsTableControls as x, RowSelectableVerdict as y };

package/dist/{types-CXz-4dPz.d.mts → types-yS6-QFfT.d.mts}

@@ -1,8 +1,54 @@
 import { ColumnDef, PaginationControl, SortControl, TableDef } from "@atscript/ui";
 import { Component, ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from "vue";
 import { AsPresetEntryRow, AspectMask, ColumnWidthsMap, ConfigTab, FieldFilters, PresetAspect, PresetCapabilities, PresetSnapshot, SelectionMode, SystemPreset, SystemPresetInput, TableStateMethods } from "@atscript/ui-table";
-import { ClientError, TDbActionInfo, TDbActionProcessor, TDbDeleteResult } from "@atscript/db-client";
+import { ClientError, PageResult, TDbActionInfo, TDbActionProcessor, TDbDeleteResult } from "@atscript/db-client";
+import { Uniquery } from "@uniqu/core";
 
+//#region src/composables/state/intent-scope.d.ts
+interface ActionBuckets {
+  default: TVueTableActionInfo | undefined;
+  others: TVueTableActionInfo[];
+  rows: TVueTableActionInfo[];
+}
+/**
+ * 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.
+ */
+declare function extractIdentifier(source: unknown, preferredId: readonly string[]): Record<string, unknown> | undefined;
+//#endregion
+//#region src/composables/state/row-actions-config.d.ts
+/**
+ * A {@link RowActionsConfig} compiled into the two passes a surface runs per
+ * row. Built once per config change (not once per row per render), so the
+ * `include` / `exclude` sets and the override lookups exist once.
+ */
+interface RowActionsPolicy {
+  /**
+   * Narrow + relabel already backend-gated buckets. Callers run
+   * `applyRowGate` FIRST — that order is the whole safety story: `include`
+   * can only narrow what the server allowed for the row, and `overrides`
+   * (presentation only) cannot resurrect an action the server gated away.
+   * Returns the input reference when the policy touches nothing.
+   */
+  apply: (buckets: ActionBuckets) => ActionBuckets;
+  /**
+   * The app-owned actions for `row`. `include` lists SERVER action names —
+   * being listed in `extra` IS an app action's opt-in — so only `exclude` and
+   * the action's own `enabled(row)` apply here. Pass no row to skip the
+   * per-row gate (a surface with no row in hand).
+   */
+  extra: (row?: Record<string, unknown>) => TVueTableActionInfo[];
+}
+//#endregion
 //#region src/types.d.ts
 /** UI-side sentinel for the synthesised row-delete processor. */
 declare const REMOVE_PROCESSOR = "__remove";
@@ -28,6 +74,52 @@ interface InvokeOpts {
    * actions without a form.
    */
   input?: unknown;
+  /**
+   * The row the action was triggered from. Only consumed by client-only row
+   * actions (`RowActionsConfig.extra`), whose `onInvoke(row, pk)` receives it.
+   * Since 0.1.134.
+   */
+  row?: Record<string, unknown>;
+}
+/**
+ * A row action the APP owns — it has no server counterpart, so the backend
+ * never gates it. Either `href` (rendered as a real anchor, mapped through
+ * `state.resolveHref`) or `onInvoke` (runs locally, then settles as an
+ * `@action` emit with `kind: 'custom'`). Since 0.1.134.
+ */
+interface LocalRowAction {
+  /** Unique among the row actions; also the `@action` emit's `action.name`. */
+  name: string;
+  label: string;
+  icon?: string;
+  intent?: TDbActionInfo["intent"];
+  /** Confirmation copy — same `$1` / `$N` substitution as a server action. */
+  promptText?: string | [string, string];
+  /** Link target for the row. Rendered as an anchor, mapped through `state.resolveHref`. */
+  href?: (row: Record<string, unknown>) => string;
+  /** Local handler. Awaited; a rejection settles the action as an error result. */
+  onInvoke?: (row: Record<string, unknown>, pk?: Record<string, unknown>) => void | Promise<void>;
+  /** Per-row gate. Returning `false` hides the action for that row. */
+  enabled?: (row: Record<string, unknown>) => boolean;
+}
+/**
+ * Per-screen presentation policy for the row-actions cell. Narrows and
+ * relabels what the server declared, and appends app-owned actions.
+ *
+ * Backend eligibility stays authoritative: `include` / `exclude` can only
+ * narrow the set a row's `$actions` already allows, and `overrides` only
+ * change how an action looks — neither can surface an action the server
+ * gated away. Since 0.1.134.
+ */
+interface RowActionsConfig {
+  /** Allowlist of server action names. Omitted = every eligible action. */
+  include?: string[];
+  /** Denylist of server action names, applied after `include`. */
+  exclude?: string[];
+  /** Presentation overrides keyed by server action name. */
+  overrides?: Record<string, Partial<Pick<TVueTableActionInfo, "label" | "icon" | "intent" | "promptText">>>;
+  /** App-owned actions appended after the server ones. */
+  extra?: LocalRowAction[];
 }
 /** Discriminated result returned by `state.actions.invoke`. Never throws. */
 type ActionResult = {
@@ -406,6 +498,13 @@ interface ReactiveTableState extends TableStateMethods {
    * remounting.
    */
   rowDelete: Ref<boolean | RowDeleteOpt>;
+  /**
+   * Per-screen row-action policy — writable ref owned by `<AsTableRoot>`,
+   * like {@link rowDelete}. `<AsRowActions>` reads it from the context, so a
+   * standalone `<AsRowActions>` inside the table honours it too (an explicit
+   * `:actions` prop on that component wins). Since 0.1.134.
+   */
+  rowActions: Ref<RowActionsConfig | undefined>;
   /**
    * `?$actions=true` opt-in — writable ref owned by the renderer.
    * `<AsTable>` / `<AsWindowTable>` flip this on whenever their
@@ -557,6 +656,52 @@ interface ReactiveTableState extends TableStateMethods {
    * watchers refetch in reaction to the writes.
    */
   applyUrlQuery: (urlString: string) => void;
+  /**
+   * Build the Uniquery the table's own fetch would send right now — same
+   * filters, sorters, search, force-filters and `$select` projection. Used by
+   * `useTableExport` so an export never drifts from what is on screen.
+   * Since 0.1.134.
+   */
+  buildQuery: (opts?: {
+    columnPaths?: string[];
+    includeActions?: boolean;
+  }) => Uniquery;
+  /**
+   * Run one page through the table's configured query function (or its
+   * client). The single fetch path — a custom `queryFn` is honoured here too.
+   * Since 0.1.134.
+   */
+  fetchPage: (query: Uniquery, page: number, size: number) => Promise<PageResult<Record<string, unknown>>>;
+  /**
+   * Paths of the client-owned (`local`) columns — the ones no server field
+   * backs, so they never enter `$select`, `$sort` or filters. Since 0.1.134.
+   */
+  localColumnPaths: ComputedRef<Set<string>>;
+  /**
+   * Re-order already-loaded rows so a sorter on a client-owned column takes
+   * effect: the page is sorted by the FULL sorter list, which leaves the
+   * server's own ordering intact and slots the local sorter in at its real
+   * priority. Page-local by definition — it can only order what is loaded —
+   * and a no-op (returns the input reference) without a local sorter, in
+   * window mode, or when the rows arrive pre-sorted. Since 0.1.134.
+   */
+  applyLocalSort: <T extends Record<string, unknown>>(rows: T[]) => T[];
+  /**
+   * Whether a sorter on a client-owned column currently does anything — the
+   * single rule behind every sort affordance, so the header and the config
+   * dialog cannot offer different sets. `false` only in window mode behind a
+   * server fetcher, where rows are cached by absolute index and dropped as
+   * the viewport moves; an in-memory provider orders the whole dataset before
+   * it slices, so the sort holds there. Since 0.1.135.
+   */
+  localSortAvailable: ComputedRef<boolean>;
+  /**
+   * The row-action policy from {@link rowActions}, compiled once per config
+   * change. Every surface that renders row actions reads it — the row-actions
+   * cell and the selection toolbar — so they cannot show different sets.
+   * Since 0.1.134.
+   */
+  rowActionsPolicy: ComputedRef<RowActionsPolicy>;
   /**
    * Preset feature surface. Always present; inert (`available=false`,
    * mutators throw) when `useTable({ preset })` was not configured.
@@ -672,4 +817,4 @@ interface PresetSurface {
   lastError: Ref<Error | null>;
 }
 //#endregion
-export { TableNavBridge as S, RowSelectableVerdict as _, EnterAction as a, TVueTableActionInfo as b, NavKeyOptions as c, ReactiveTableState as d, RowAttrsHook as f, RowSelectableHook as g, RowHookContext as h, ConfirmOptions as i, PresetConfig as l, RowDeleteOpt as m, ColumnMenuConfig as n, InvokeOpts as o, RowClassHook as p, ConfigTab as r, MainActionRequest as s, ActionResult as t, QueryErrorKind as u, TAsCellTypeComponents as v, TableActionsState as x, TAsTableControls as y };
+export { TableActionsState as C, TVueTableActionInfo as S, extractIdentifier as T, RowHookContext as _, EnterAction as a, TAsCellTypeComponents as b, MainActionRequest as c, QueryErrorKind as d, ReactiveTableState as f, RowDeleteOpt as g, RowClassHook as h, ConfirmOptions as i, NavKeyOptions as l, RowAttrsHook as m, ColumnMenuConfig as n, InvokeOpts as o, RowActionsConfig as p, ConfigTab as r, LocalRowAction as s, ActionResult as t, PresetConfig as u, RowSelectableHook as v, TableNavBridge as w, TAsTableControls as x, RowSelectableVerdict as y };

package/dist/{use-table-Bk-jSxOM.mjs → use-table-BVptAnaS.mjs}

@@ -1,5 +1,5 @@
-import { n as createTableState, r as provideTableContext, s as DEFAULT_AVAILABLE_ASPECTS } from "./use-table-state-DLJbW753.mjs";
-import { n as useTableSelection } from "./use-table-selection-C84z4OZy.mjs";
+import { n as createTableState, r as provideTableContext, s as DEFAULT_AVAILABLE_ASPECTS } from "./use-table-state-CwfgWmuk.mjs";
+import { n as useTableSelection } from "./use-table-selection-ULbKT2xW.mjs";
 import { createTableDef, getMetaEntry, resetMetaCache } from "@atscript/ui";
 import { computed, inject, isRef, ref, shallowRef, toValue, watch } from "vue";
 import { PresetsClient, STANDARD_PRESET_ID, debounce, deserializeDraft, isEmptyDraft, isSystemPresetId, isUnavailableError, resolveSystemPresets, serializeDraft, stableStringify } from "@atscript/ui-table";
@@ -368,6 +368,24 @@ function clearTableCache() {
 	resetMetaCache();
 }
 /**
+* The tail every table setup shares: wire selection persistence, then publish
+* the context to the subtree. Split out so the local (`:rows`) path in
+* `<AsTableRoot>` and `useTable` cannot drift on which keys get provided.
+*/
+function finalizeTableState(state, client, opts) {
+	useTableSelection(state, { mode: opts?.selectionPersistence ?? "trim" });
+	if (opts?.provideContext === false) return;
+	provideTableContext({
+		state,
+		client,
+		controls: opts?.controls ?? {},
+		types: opts?.types,
+		components: opts?.components,
+		formTypes: opts?.formTypes,
+		formComponents: opts?.formComponents
+	});
+}
+/**
 * Main entry composable for table setup.
 *
 * @param url — Table endpoint URL (e.g. "/db/tables/products")
@@ -427,6 +445,7 @@ function useTable(url, opts) {
 			resolveHref: opts?.resolveHref,
 			onResolved: opts?.onActionResolved
 		},
+		displayColumns: opts?.displayColumns,
 		preset: {
 			presetsHandle,
 			draftHandle,
@@ -435,16 +454,7 @@ function useTable(url, opts) {
 			persistDrafts: preset?.persistDrafts ?? false
 		}
 	});
-	useTableSelection(state, { mode: opts?.selectionPersistence ?? "trim" });
-	if (opts?.provideContext !== false) provideTableContext({
-		state,
-		client,
-		controls: opts?.controls ?? {},
-		types: opts?.types,
-		components: opts?.components,
-		formTypes: opts?.formTypes,
-		formComponents: opts?.formComponents
-	});
+	finalizeTableState(state, client, opts);
 	defPromise.then((def) => {
 		internals.init(def);
 	}).catch((err) => {
@@ -455,4 +465,4 @@ function useTable(url, opts) {
 	return state;
 }
 //#endregion
-export { AS_PRESETS_APP as a, useLocalDraft as i, useTable as n, injectPresetsApp as o, usePresets as r, clearTableCache as t };
+export { useLocalDraft as a, usePresets as i, finalizeTableState as n, AS_PRESETS_APP as o, useTable as r, injectPresetsApp as s, clearTableCache as t };

package/dist/{use-table-CdFFqaEx.cjs → use-table-Bm2a0g9D.cjs}

@@ -1,5 +1,5 @@
-const require_use_table_state = require("./use-table-state-D6dHOFrA.cjs");
-const require_use_table_selection = require("./use-table-selection-Cmiu1h4S.cjs");
+const require_use_table_state = require("./use-table-state-jljSQQ8m.cjs");
+const require_use_table_selection = require("./use-table-selection-DtCV3rhu.cjs");
 let _atscript_ui = require("@atscript/ui");
 let vue = require("vue");
 let _atscript_ui_table = require("@atscript/ui-table");
@@ -368,6 +368,24 @@ function clearTableCache() {
 	(0, _atscript_ui.resetMetaCache)();
 }
 /**
+* The tail every table setup shares: wire selection persistence, then publish
+* the context to the subtree. Split out so the local (`:rows`) path in
+* `<AsTableRoot>` and `useTable` cannot drift on which keys get provided.
+*/
+function finalizeTableState(state, client, opts) {
+	require_use_table_selection.useTableSelection(state, { mode: opts?.selectionPersistence ?? "trim" });
+	if (opts?.provideContext === false) return;
+	require_use_table_state.provideTableContext({
+		state,
+		client,
+		controls: opts?.controls ?? {},
+		types: opts?.types,
+		components: opts?.components,
+		formTypes: opts?.formTypes,
+		formComponents: opts?.formComponents
+	});
+}
+/**
 * Main entry composable for table setup.
 *
 * @param url — Table endpoint URL (e.g. "/db/tables/products")
@@ -427,6 +445,7 @@ function useTable(url, opts) {
 			resolveHref: opts?.resolveHref,
 			onResolved: opts?.onActionResolved
 		},
+		displayColumns: opts?.displayColumns,
 		preset: {
 			presetsHandle,
 			draftHandle,
@@ -435,16 +454,7 @@ function useTable(url, opts) {
 			persistDrafts: preset?.persistDrafts ?? false
 		}
 	});
-	require_use_table_selection.useTableSelection(state, { mode: opts?.selectionPersistence ?? "trim" });
-	if (opts?.provideContext !== false) require_use_table_state.provideTableContext({
-		state,
-		client,
-		controls: opts?.controls ?? {},
-		types: opts?.types,
-		components: opts?.components,
-		formTypes: opts?.formTypes,
-		formComponents: opts?.formComponents
-	});
+	finalizeTableState(state, client, opts);
 	defPromise.then((def) => {
 		internals.init(def);
 	}).catch((err) => {
@@ -467,6 +477,12 @@ Object.defineProperty(exports, "clearTableCache", {
 		return clearTableCache;
 	}
 });
+Object.defineProperty(exports, "finalizeTableState", {
+	enumerable: true,
+	get: function() {
+		return finalizeTableState;
+	}
+});
 Object.defineProperty(exports, "injectPresetsApp", {
 	enumerable: true,
 	get: function() {

package/dist/{use-table-component-DlLganVc.cjs → use-table-component-Bpy5mg_P.cjs}

@@ -1,4 +1,4 @@
-const require_use_table_state = require("./use-table-state-D6dHOFrA.cjs");
+const require_use_table_state = require("./use-table-state-jljSQQ8m.cjs");
 //#region src/composables/use-table-component.ts
 /**
 * Resolve a single skin-slot component from the injected `controls` map,

package/dist/{use-table-component-KuzZxAP8.mjs → use-table-component-DYzKgCC4.mjs}

@@ -1,4 +1,4 @@
-import { o as useTableContextOptional } from "./use-table-state-DLJbW753.mjs";
+import { o as useTableContextOptional } from "./use-table-state-CwfgWmuk.mjs";
 //#region src/composables/use-table-component.ts
 /**
 * Resolve a single skin-slot component from the injected `controls` map,

package/dist/{use-table-nav-bridge-B9SSEajW.mjs → use-table-nav-bridge-LCL6vq9F.mjs}

@@ -1,4 +1,4 @@
-import { o as useTableContextOptional } from "./use-table-state-DLJbW753.mjs";
+import { o as useTableContextOptional } from "./use-table-state-CwfgWmuk.mjs";
 //#region src/composables/use-table-nav-bridge.ts
 function isPassthroughKey(event) {
 	const key = event.key;

package/dist/{use-table-nav-bridge-CVUmTjDr.cjs → use-table-nav-bridge-qyvyRm6S.cjs}

@@ -1,4 +1,4 @@
-const require_use_table_state = require("./use-table-state-D6dHOFrA.cjs");
+const require_use_table_state = require("./use-table-state-jljSQQ8m.cjs");
 //#region src/composables/use-table-nav-bridge.ts
 function isPassthroughKey(event) {
 	const key = event.key;