@lavalogic/scoria 0.37.44 → 0.37.45

package/dist/Components/Table/Types/Context/FilteringState.svelte.js

@@ -1,19 +1,10 @@
 import { PaginationType } from '../Pagination/PaginationType.js';
 import { SvelteMap } from 'svelte/reactivity';
 /**
- * Phase 6.2 god-object decomposition - sub-context that owns the
- * filtering-related state, the relayed per-type `FilterFn` derived
- * values, the `filteredData` $derived chain, the user-facing toggle
- * flags (`showQuickFiltering`, `showSelectedOnly`), the remote-filter
- * slot, and the `updateFilters` `OnChangeFn` slot.
- *
- * `TableContext` retains delegating getters / setters for every legacy
- * surface (`filteredIndices`, `filteredData`, `showQuickFiltering`,
- * `showSelectedOnly`, `remoteFilters`, `dateFilter`, `numberFilter`,
- * `selectFilter`, `boolFilter`, `stringFilter`, `updateFilters`); future
- * consumers can read `tableContext._filtering` directly once the
- * migration completes (see
- * `src/stories/Concepts/TableContext-decomposition.mdx`).
+ * Sub-context owning filtering-related state: relayed per-type
+ * `FilterFn` derived values, the `filteredData` `$derived` chain, the
+ * user-facing toggle flags (`showQuickFiltering`, `showSelectedOnly`),
+ * the remote-filter slot, and the `updateFilters` `OnChangeFn` slot.
  */
 export class FilteringState {
     _deps;
@@ -54,10 +45,9 @@ export class FilteringState {
     }
     /**
      * Whether the quick-filter row is currently visible. The setter
-     * enforces the `allowQuickFiltering` gate (a master init option):
-     * if quick filtering is disabled at the table level, the setter is
-     * a no-op except for the debug log. Mirrors the pre-extraction
-     * `TableContext.showQuickFiltering` setter verbatim.
+     * enforces the `allowQuickFiltering` master gate: when quick
+     * filtering is disabled at the table level, the setter is a no-op
+     * (with a debug log).
      */
     get showQuickFiltering() {
         return this._showQuickFiltering;
@@ -152,9 +142,8 @@ export class FilteringState {
      *
      * Reactivity note: `selectedItems` is intentionally NOT touched
      * outside the `showSelectedOnly` branches. Reading it unconditionally
-     * would invalidate `filteredData` → `sortedData` → `currentPageData`
-     * → the entire row model on every single toggle (regression caught
-     * during Phase-5 Group 2).
+     * would invalidate `filteredData` -> `sortedData` ->
+     * `currentPageData` -> the entire row model on every single toggle.
      */
     filteredData = $derived.by(() => {
         const repoData = this._deps.getRepoData();

package/dist/Components/Table/Types/Context/FocusState.svelte.d.ts

@@ -74,71 +74,52 @@ export interface FocusStateDeps<T extends object> {
     tabBackward: () => void;
     /** Logger gate; mirrors the parent `TableContext.debug` field. */
     getDebug: () => boolean;
-    /** Returns the parent `TableContext`. Used by
-     *  `getFocusDetailsFor` to construct `TableFocusDetails`
-     *  lazily on cache-miss (Phase 7.1 Item C). The thunk is
-     *  used instead of a direct ref so the sub-context never
-     *  closes over the parent at construction time. */
+    /** Returns the parent `TableContext`. Used by `getFocusDetailsFor`
+     *  to construct `TableFocusDetails` lazily on cache miss. The thunk
+     *  is used instead of a direct ref so the sub-context never closes
+     *  over the parent at construction time. */
     getTableContextRef: () => unknown;
 }
 /**
- * Phase 6.6 god-object decomposition - sub-context that owns every
- * focus + keyboard-navigation concern previously held directly on
- * `TableContext`:
+ * Sub-context owning every focus + keyboard-navigation concern:
  *
  * - `focusStart` / `focusEnd` (the two `CellCoordinates` slots that
  *   define the focused cell-range);
- * - `focusStartIsBeingEdited` (the editing-mode flag);
+ * - `focusStartIsBeingEdited` (editing-mode flag);
  * - `isMousingDown` (drag-select sentinel for mouse-driven multi-cell
  *   selection);
- * - the `focusedRowIndices` / `focusedColumnIds` derived sets that
- *   power the per-cell `TableFocusDetails` outline computation;
+ * - `focusedRowIndices` / `focusedColumnIds` derived sets that power
+ *   the per-cell `TableFocusDetails` outline computation;
  * - `startFocus` / `moveFocus` / `unfocus` / `endFocus` / `setFocusEnd`
- *   (consumer-facing writers - mouse-driven and direct);
+ *   (consumer-facing writers, mouse-driven and direct);
  * - `focusToTop` / `focusToBottom` / `moveToTop` / `moveToBottom` /
  *   `focusToStart` / `focusToEnd` / `moveToStart` / `moveToEnd`
  *   (range jumps);
  * - `moveFocusUp` / `setFocusUp` / `moveFocusDown` / `setFocusDown` /
  *   `moveFocusLeft` / `setFocusLeft` / `moveFocusRight` / `setFocusRight`
  *   (single-cell vs. range arrow moves);
- * - `handleTdKeydown` (the table-container `onkeydown` router);
- * - `handleKeystroke` (the dispatch into the arrow/Home/End/Ctrl+A/
- *   Ctrl+C paths);
+ * - `handleTdKeydown` (table-container `onkeydown` router);
+ * - `handleKeystroke` (arrow / Home / End / Ctrl+A / Ctrl+C dispatch);
  * - `focusStartVisualColumn` / `focusEndVisualColumn` (visual-column
  *   getters powered by `getVisualColumnIndexById`).
  *
  * Effect lifecycle: the parent owns the `$effect` that publishes
- * `_focusedRowIndices` / `_focusedColumnIds`. That effect now calls
- * into this sub-context through `setFocusedDerived(rows, cols)`
- * rather than mutating the state slots directly. The effect lives
- * on `TableContext` because it needs the parent's
- * `paginationRowModel` + `_visualColumns` reads.
- *
- * `TableContext` retains delegating getters / setters / methods for
- * every legacy surface (`focusStart`, `focusEnd`, `focusStartIsBeingEdited`,
- * `isMousingDown`, `focusedRowIndices`, `focusedColumnIds`,
- * `focusStartVisualColumn`, `focusEndVisualColumn`, `startFocus`,
- * `moveFocus`, `unfocus`, `endFocus`, `setFocusEnd`, `setFocusUp`,
- * `setFocusDown`, `setFocusLeft`, `setFocusRight`, `moveFocusUp`,
- * `moveFocusDown`, `moveFocusLeft`, `moveFocusRight`, `moveToTop`,
- * `moveToBottom`, `moveToStart`, `moveToEnd`, `focusToTop`,
- * `focusToBottom`, `focusToStart`, `focusToEnd`, `handleTdKeydown`)
- * so existing consumers need no migration.
+ * `_focusedRowIndices` / `_focusedColumnIds`. That effect calls into
+ * this sub-context through `setFocusedDerived(rows, cols)` rather
+ * than mutating state slots directly. The effect lives on
+ * `TableContext` because it reads `paginationRowModel` and
+ * `_visualColumns`.
  *
  * @remarks
- * Group 2 Item C (per-cell `TableFocusDetails` reuse) is deferred for
- * Phase 6.6. The cache would need a `${rowKey}:${columnId}` key, but
- * `selectionExtractor` can be async (the sub-context's `cachedKey`
- * returns `RowIdType | Promise<RowIdType>`), so the cache lookup
- * cannot complete synchronously inside a cell render. The reuse
- * requires a follow-up refactor that either:
- *   a) memoises `TableFocusDetails` instances on the row reference
- *      (a `WeakMap<TableCell<T>, TableFocusDetails<T, RowIdType>>`),
- *      which side-steps the async key entirely, or
+ * Per-cell `TableFocusDetails` reuse is deferred. A cache would need a
+ * `${rowKey}:${columnId}` key, but `selectionExtractor` can be async
+ * (`cachedKey` returns `RowIdType | Promise<RowIdType>`), so a sync
+ * lookup at cell-render time is impossible. A follow-up either:
+ *   a) memoises `TableFocusDetails` on the row reference itself
+ *      (`WeakMap<TableCell<T>, TableFocusDetails<T, RowIdType>>`,
+ *      which side-steps the async key entirely), or
  *   b) hoists the key resolution into a `$state` slot populated by
  *      `updateSelectedItems` so the lookup is sync at render time.
- * Both are larger surface changes than the FocusState extraction;
- * tracked under Phase 6.7 BREAKING-CHANGES.md.
  */
 export declare class FocusState<T extends object> {
     private readonly _deps;

package/dist/Components/Table/Types/Context/FocusState.svelte.js

@@ -2,63 +2,45 @@ import { tick } from 'svelte';
 import { devCatch } from '../../../../Helpers/Helpers.svelte.js';
 import { TableFocusDetails } from '../Focus/TableFocusDetails.svelte.js';
 /**
- * Phase 6.6 god-object decomposition - sub-context that owns every
- * focus + keyboard-navigation concern previously held directly on
- * `TableContext`:
+ * Sub-context owning every focus + keyboard-navigation concern:
  *
  * - `focusStart` / `focusEnd` (the two `CellCoordinates` slots that
  *   define the focused cell-range);
- * - `focusStartIsBeingEdited` (the editing-mode flag);
+ * - `focusStartIsBeingEdited` (editing-mode flag);
  * - `isMousingDown` (drag-select sentinel for mouse-driven multi-cell
  *   selection);
- * - the `focusedRowIndices` / `focusedColumnIds` derived sets that
- *   power the per-cell `TableFocusDetails` outline computation;
+ * - `focusedRowIndices` / `focusedColumnIds` derived sets that power
+ *   the per-cell `TableFocusDetails` outline computation;
  * - `startFocus` / `moveFocus` / `unfocus` / `endFocus` / `setFocusEnd`
- *   (consumer-facing writers - mouse-driven and direct);
+ *   (consumer-facing writers, mouse-driven and direct);
  * - `focusToTop` / `focusToBottom` / `moveToTop` / `moveToBottom` /
  *   `focusToStart` / `focusToEnd` / `moveToStart` / `moveToEnd`
  *   (range jumps);
  * - `moveFocusUp` / `setFocusUp` / `moveFocusDown` / `setFocusDown` /
  *   `moveFocusLeft` / `setFocusLeft` / `moveFocusRight` / `setFocusRight`
  *   (single-cell vs. range arrow moves);
- * - `handleTdKeydown` (the table-container `onkeydown` router);
- * - `handleKeystroke` (the dispatch into the arrow/Home/End/Ctrl+A/
- *   Ctrl+C paths);
+ * - `handleTdKeydown` (table-container `onkeydown` router);
+ * - `handleKeystroke` (arrow / Home / End / Ctrl+A / Ctrl+C dispatch);
  * - `focusStartVisualColumn` / `focusEndVisualColumn` (visual-column
  *   getters powered by `getVisualColumnIndexById`).
  *
  * Effect lifecycle: the parent owns the `$effect` that publishes
- * `_focusedRowIndices` / `_focusedColumnIds`. That effect now calls
- * into this sub-context through `setFocusedDerived(rows, cols)`
- * rather than mutating the state slots directly. The effect lives
- * on `TableContext` because it needs the parent's
- * `paginationRowModel` + `_visualColumns` reads.
- *
- * `TableContext` retains delegating getters / setters / methods for
- * every legacy surface (`focusStart`, `focusEnd`, `focusStartIsBeingEdited`,
- * `isMousingDown`, `focusedRowIndices`, `focusedColumnIds`,
- * `focusStartVisualColumn`, `focusEndVisualColumn`, `startFocus`,
- * `moveFocus`, `unfocus`, `endFocus`, `setFocusEnd`, `setFocusUp`,
- * `setFocusDown`, `setFocusLeft`, `setFocusRight`, `moveFocusUp`,
- * `moveFocusDown`, `moveFocusLeft`, `moveFocusRight`, `moveToTop`,
- * `moveToBottom`, `moveToStart`, `moveToEnd`, `focusToTop`,
- * `focusToBottom`, `focusToStart`, `focusToEnd`, `handleTdKeydown`)
- * so existing consumers need no migration.
+ * `_focusedRowIndices` / `_focusedColumnIds`. That effect calls into
+ * this sub-context through `setFocusedDerived(rows, cols)` rather
+ * than mutating state slots directly. The effect lives on
+ * `TableContext` because it reads `paginationRowModel` and
+ * `_visualColumns`.
  *
  * @remarks
- * Group 2 Item C (per-cell `TableFocusDetails` reuse) is deferred for
- * Phase 6.6. The cache would need a `${rowKey}:${columnId}` key, but
- * `selectionExtractor` can be async (the sub-context's `cachedKey`
- * returns `RowIdType | Promise<RowIdType>`), so the cache lookup
- * cannot complete synchronously inside a cell render. The reuse
- * requires a follow-up refactor that either:
- *   a) memoises `TableFocusDetails` instances on the row reference
- *      (a `WeakMap<TableCell<T>, TableFocusDetails<T, RowIdType>>`),
- *      which side-steps the async key entirely, or
+ * Per-cell `TableFocusDetails` reuse is deferred. A cache would need a
+ * `${rowKey}:${columnId}` key, but `selectionExtractor` can be async
+ * (`cachedKey` returns `RowIdType | Promise<RowIdType>`), so a sync
+ * lookup at cell-render time is impossible. A follow-up either:
+ *   a) memoises `TableFocusDetails` on the row reference itself
+ *      (`WeakMap<TableCell<T>, TableFocusDetails<T, RowIdType>>`,
+ *      which side-steps the async key entirely), or
  *   b) hoists the key resolution into a `$state` slot populated by
  *      `updateSelectedItems` so the lookup is sync at render time.
- * Both are larger surface changes than the FocusState extraction;
- * tracked under Phase 6.7 BREAKING-CHANGES.md.
  */
 export class FocusState {
     _deps;
@@ -702,27 +684,20 @@ export class FocusState {
         this.moveFocus({ ...this._focusStart, row: newEndRowIndex });
     }
     // -----------------------------------------------------------------
-    // Per-cell TableFocusDetails reuse (Phase 7.1 Item C)
-    //
-    // Prior to Phase 7.1, every cell component (TableTextInput,
-    // FocusableImmutableCell, TableNumberInput, etc.) wrote
-    // `$derived(new TableFocusDetails(cell, tableContext))`. The
-    // `$derived` re-runs on each reactive dep change, so a freshly
-    // constructed `TableFocusDetails` was the dominant per-cell cost.
-    //
-    // Phase 6.6 deferred this because the natural cache key
-    // `${rowKey}:${columnId}` cannot be computed synchronously inside
-    // a cell render (SelectionState.cachedKey can return a Promise).
+    // Per-cell TableFocusDetails reuse.
     //
-    // Approach: use the cell reference ITSELF as the WeakMap key. Cell
-    // objects are constructed by `createRow` / `rowsPromise`; within a
-    // single render pass the same cell instance is passed through to
-    // each cell component, so the cache hits across the $derived
-    // re-evaluations that fire while the cell is mounted. When Item G
-    // stabilises Row references across pagination changes, cell refs
-    // also become stable and the cache hits across page flips too.
+    // Cell components run `$derived(new TableFocusDetails(cell, ctx))`
+    // which re-evaluates on every reactive dep change, making the
+    // `TableFocusDetails` construction the dominant per-cell cost.
     //
-    // `WeakMap` ensures cell objects do not pin TableFocusDetails
+    // The cache is keyed on the cell REFERENCE itself (a WeakMap)
+    // because a `${rowKey}:${columnId}` string key cannot be computed
+    // synchronously inside a cell render (`SelectionState.cachedKey`
+    // can return a Promise). Cell objects are constructed by
+    // `createRow` / `rowsPromise`; within a single render pass the same
+    // cell instance is passed to every component, so the cache hits
+    // across the `$derived` re-evaluations that fire while the cell is
+    // mounted. `WeakMap` ensures cells do not pin `TableFocusDetails`
     // after the row is dropped; GC reclaims both together.
     // -----------------------------------------------------------------
     _focusDetailsCache = new WeakMap();
@@ -739,9 +714,7 @@ export class FocusState {
         let details = this._focusDetailsCache.get(cell);
         if (!details) {
             // The TableContext ref is supplied via a thunk to keep this
-            // sub-context decoupled from the parent. The thunk is
-            // expected to return the *current* parent reference; in
-            // practice the parent never recycles its TableContext.
+            // sub-context decoupled from the parent.
             const parent = this._deps.getTableContextRef();
             details = new TableFocusDetails(cell, parent);
             this._focusDetailsCache.set(cell, details);

package/dist/Components/Table/Types/Context/ITable.d.ts

@@ -9,14 +9,11 @@ import type { HeaderGroup } from '../HeaderGroup.js';
 import type { OnChangeFn } from '../OnChangeFn.js';
 import type { PaginationState } from '../Pagination/PaginationState.js';
 /**
- * Surface returned by `TableContext.table`. Mirrors the tanstack-table shape
- * scoria's table API was originally derived from, narrowed to the methods the
- * scoria Table actually exposes.
- *
- * The commented-out `extends X, Y, Z` lines record the tanstack-derived
- * mixins that have not yet been implemented; they are retained as a backlog
- * marker. Deleting them is deferred (workorder Types-Context-supporting
- * finding 1) until a decision is made on which mixins to port.
+ * Surface returned by `TableContext.table`. Mirrors the tanstack-table
+ * shape scoria's table API derives from, narrowed to the methods the
+ * scoria Table actually exposes. The commented-out `extends X, Y, Z`
+ * lines mark tanstack-derived mixins not yet implemented; retained as
+ * a backlog marker pending a decision on which to port.
  */
 export interface ITable<T extends object> {
     data: Array<T>;

package/dist/Components/Table/Types/Context/PreferencesState.svelte.d.ts

@@ -7,28 +7,21 @@ import type { SortingState as SortingStateArray } from '../DataRepository/Sortin
 import type { SavedTableSettings, TableSettings } from './TableSettings.js';
 /**
  * Conservative typeguard for the persisted preset list. Storage is
- * same-origin-writable so the only contract we can rely on is the array
- * shape; downstream `reassignDefsToPresets` performs deeper checks and
- * drops presets that fail. We assert the outer envelope and the bare
- * minimum for each entry: a string `name` and an array `columnDefs`.
- *
- * Lifted from `TableContext.svelte.ts` during Phase 6.4 god-object
- * decomposition; semantics unchanged.
+ * same-origin-writable so only the array shape can be trusted;
+ * downstream `reassignDefsToPresets` performs deeper checks and drops
+ * presets that fail. Asserts the outer envelope plus the bare minimum
+ * per entry: a string `name` and an array `columnDefs`.
  */
 export declare function isJSONColumnDefSetArray(raw: unknown): raw is Array<JSONColumnDefSet>;
 /**
  * Typeguard for the persisted user-level table settings blob. Every
- * field is optional, but every present field must be boolean: anything
+ * field is optional, but every present field must be boolean; anything
  * else is a sign of schema drift or a tampered slot.
- *
- * Lifted from `TableContext.svelte.ts` during Phase 6.4.
  */
 export declare function isSavedTableSettings(raw: unknown): raw is SavedTableSettings;
 /**
  * Typeguard for a non-empty string. Used for the persisted selected
  * preset name slot.
- *
- * Lifted from `TableContext.svelte.ts` during Phase 6.4.
  */
 export declare function isNonEmptyString(raw: unknown): raw is string;
 /**
@@ -64,44 +57,34 @@ export interface PreferencesStateDeps<T extends object> {
     setColumnVisibility: (state: VisibilityState) => void;
     /** Apply the column-pinning map when a preset is restored. */
     setColumnPinning: (state: ColumnPinningState) => void;
-    /** Apply the sort instruction list when a preset is restored. May
-     *  be `undefined` when no pagination repository is attached yet;
-     *  the writer is a best-effort hook (mirrors the pre-extraction
-     *  `paginationRepo?.updateSorting?.()` call). */
+    /** Apply the sort instruction list when a preset is restored. The
+     *  writer is a best-effort hook (`paginationRepo?.updateSorting?.()`
+     *  no-ops when no pagination repository is attached yet). */
     applySortingState: (state: SortingStateArray) => void;
     /** Logger gate; mirrors the parent `TableContext.debug` field. */
     getDebug: () => boolean;
 }
 /**
- * Phase 6.4 god-object decomposition - sub-context that owns every
- * persistence / preferences concern previously held directly on
- * `TableContext`:
+ * Sub-context owning every persistence / preferences concern:
  *
- * - `_columnPresets` (the persisted preset list `$state`),
- * - `_selectedPreset` (the currently-active preset `$state`),
- * - `userIdSegment` (the sanitised user-id segment used in storage
- *   keys; `$derived` over `getUserId()`),
+ * - `_columnPresets` (persisted preset list `$state`);
+ * - `_selectedPreset` (currently-active preset `$state`);
+ * - `userIdSegment` (sanitised user-id segment used in storage keys;
+ *   `$derived` over `getUserId()`);
  * - `saveColumnPreset(name)` (snapshot the live layout, persist the
- *   list, mark the new preset as selected),
+ *   list, mark the new preset as selected);
  * - `setSelectedPreset(preset)` (apply the preset to the live layout
- *   and persist the selected name),
+ *   and persist the selected name);
  * - `loadPresets()` / `loadSelectedPresetName()` /
  *   `loadSavedSettings()` (boot-time hydration helpers; the parent
- *   owns the orchestration because it depends on `setupDefaultColumnDefs`
- *   running first),
- * - `clearPresetsAndSelection()` (drop both persisted slots),
+ *   owns the orchestration because it depends on
+ *   `setupDefaultColumnDefs` running first);
+ * - `clearPresetsAndSelection()` (drop both persisted slots);
  * - `persistSettings(settings)` (write the per-table TableSettings
- *   blob),
- * - the schema-validation typeguards
- *   (`isJSONColumnDefSetArray`, `isSavedTableSettings`,
- *   `isNonEmptyString`) - exported alongside the class.
- *
- * `TableContext` retains delegating getters / setters / methods for
- * every legacy surface (`columnPresets`, `selectedPreset`,
- * `saveColumnPreset`, `setSelectedPreset`, `_updateLocalStorageSettings`)
- * so existing consumers need no migration. Future consumers can read
- * `tableContext._preferences` directly once the migration is complete
- * (see `src/stories/Concepts/TableContext-decomposition.mdx`).
+ *   blob);
+ * - schema-validation typeguards (`isJSONColumnDefSetArray`,
+ *   `isSavedTableSettings`, `isNonEmptyString`) - exported alongside
+ *   the class.
  *
  * Every `localStorage` access is funnelled through this sub-context so
  * the `scoria-table:<user>:<tableName>:<suffix>` namespace convention
@@ -172,11 +155,8 @@ export declare class PreferencesState<T extends object> {
     /**
      * Boot-time hydration helper. Reads the persisted selected-preset
      * name. Returns `null` for missing / empty / storage-error slots
-     * so the parent can fall back to the first preset (or the
-     * default).
-     *
-     * Mirrors the pre-extraction try/catch around `getItem` verbatim:
-     * the same dev-only warning is emitted on read failure.
+     * so the parent can fall back to the first preset (or the default).
+     * Emits a dev-only warning on `getItem` failure.
      */
     loadSelectedPresetName(): string | null;
     /**
@@ -199,8 +179,7 @@ export declare class PreferencesState<T extends object> {
     persistSelectedPresetName(name: string): void;
     /**
      * Persist the per-table settings blob (`isCompact`,
-     * `singleClickEditing`, etc.) as JSON. Format and key remain
-     * exactly as before the extraction.
+     * `singleClickEditing`, etc.) as JSON.
      */
     persistSettings(settings: TableSettings): void;
     /**
@@ -209,15 +188,11 @@ export declare class PreferencesState<T extends object> {
      * because Map does not survive `JSON.stringify`; the reader (via
      * `loadPresets` -> `reassignDefsToPresets`) rehydrates it through
      * `adaptJSONPinningState`.
-     *
-     * Pulled out of `saveColumnPreset` so the per-preset
-     * `toJSON()` walk is unit-testable in isolation.
      */
     persistPresets(presets: ReadonlyArray<ColumnDefSet<T>>): void;
     /**
-     * Apply a saved column preset to the live table layout and
-     * persist the selection by name. Mirrors the pre-extraction
-     * `TableContext.setSelectedPreset` verbatim:
+     * Apply a saved column preset to the live table layout and persist
+     * the selection by name:
      *
      * 1. Replace `columnDefs`, `columnVisibility`, `columnPinning`.
      * 2. Forward the preset's `sortingState` to the data-repository
@@ -233,10 +208,8 @@ export declare class PreferencesState<T extends object> {
      * Snapshot the current column layout into a new preset, replacing
      * any existing preset whose name matches case-insensitively, and
      * persist the full preset list to `localStorage`. Marks the new
-     * preset as selected (which also persists its name).
-     *
-     * Mirrors the pre-extraction `TableContext.saveColumnPreset`
-     * verbatim. No-op when `name` is empty.
+     * preset as selected (which also persists its name). No-op when
+     * `name` is empty.
      */
     readonly saveColumnPreset: (name: string) => void;
 }

package/dist/Components/Table/Types/Context/PreferencesState.svelte.js

@@ -2,13 +2,10 @@ import { dev } from '$app/environment';
 import { readJSON } from '../../../../Helpers/Storage.js';
 /**
  * Conservative typeguard for the persisted preset list. Storage is
- * same-origin-writable so the only contract we can rely on is the array
- * shape; downstream `reassignDefsToPresets` performs deeper checks and
- * drops presets that fail. We assert the outer envelope and the bare
- * minimum for each entry: a string `name` and an array `columnDefs`.
- *
- * Lifted from `TableContext.svelte.ts` during Phase 6.4 god-object
- * decomposition; semantics unchanged.
+ * same-origin-writable so only the array shape can be trusted;
+ * downstream `reassignDefsToPresets` performs deeper checks and drops
+ * presets that fail. Asserts the outer envelope plus the bare minimum
+ * per entry: a string `name` and an array `columnDefs`.
  */
 export function isJSONColumnDefSetArray(raw) {
     if (!Array.isArray(raw)) {
@@ -24,10 +21,8 @@ export function isJSONColumnDefSetArray(raw) {
 }
 /**
  * Typeguard for the persisted user-level table settings blob. Every
- * field is optional, but every present field must be boolean: anything
+ * field is optional, but every present field must be boolean; anything
  * else is a sign of schema drift or a tampered slot.
- *
- * Lifted from `TableContext.svelte.ts` during Phase 6.4.
  */
 export function isSavedTableSettings(raw) {
     if (typeof raw !== 'object' || raw === null) {
@@ -45,42 +40,31 @@ export function isSavedTableSettings(raw) {
 /**
  * Typeguard for a non-empty string. Used for the persisted selected
  * preset name slot.
- *
- * Lifted from `TableContext.svelte.ts` during Phase 6.4.
  */
 export function isNonEmptyString(raw) {
     return typeof raw === 'string' && raw.length > 0;
 }
 /**
- * Phase 6.4 god-object decomposition - sub-context that owns every
- * persistence / preferences concern previously held directly on
- * `TableContext`:
+ * Sub-context owning every persistence / preferences concern:
  *
- * - `_columnPresets` (the persisted preset list `$state`),
- * - `_selectedPreset` (the currently-active preset `$state`),
- * - `userIdSegment` (the sanitised user-id segment used in storage
- *   keys; `$derived` over `getUserId()`),
+ * - `_columnPresets` (persisted preset list `$state`);
+ * - `_selectedPreset` (currently-active preset `$state`);
+ * - `userIdSegment` (sanitised user-id segment used in storage keys;
+ *   `$derived` over `getUserId()`);
  * - `saveColumnPreset(name)` (snapshot the live layout, persist the
- *   list, mark the new preset as selected),
+ *   list, mark the new preset as selected);
  * - `setSelectedPreset(preset)` (apply the preset to the live layout
- *   and persist the selected name),
+ *   and persist the selected name);
  * - `loadPresets()` / `loadSelectedPresetName()` /
  *   `loadSavedSettings()` (boot-time hydration helpers; the parent
- *   owns the orchestration because it depends on `setupDefaultColumnDefs`
- *   running first),
- * - `clearPresetsAndSelection()` (drop both persisted slots),
+ *   owns the orchestration because it depends on
+ *   `setupDefaultColumnDefs` running first);
+ * - `clearPresetsAndSelection()` (drop both persisted slots);
  * - `persistSettings(settings)` (write the per-table TableSettings
- *   blob),
- * - the schema-validation typeguards
- *   (`isJSONColumnDefSetArray`, `isSavedTableSettings`,
- *   `isNonEmptyString`) - exported alongside the class.
- *
- * `TableContext` retains delegating getters / setters / methods for
- * every legacy surface (`columnPresets`, `selectedPreset`,
- * `saveColumnPreset`, `setSelectedPreset`, `_updateLocalStorageSettings`)
- * so existing consumers need no migration. Future consumers can read
- * `tableContext._preferences` directly once the migration is complete
- * (see `src/stories/Concepts/TableContext-decomposition.mdx`).
+ *   blob);
+ * - schema-validation typeguards (`isJSONColumnDefSetArray`,
+ *   `isSavedTableSettings`, `isNonEmptyString`) - exported alongside
+ *   the class.
  *
  * Every `localStorage` access is funnelled through this sub-context so
  * the `scoria-table:<user>:<tableName>:<suffix>` namespace convention
@@ -89,9 +73,8 @@ export function isNonEmptyString(raw) {
 export class PreferencesState {
     _deps;
     _columnPresets = $state([]);
-    //FIXME why was this allowed to be undefined? Mirrors the pre-extraction
-    // `TableContext._selectedPreset` field; retained as `undefined`-capable
-    // for source compatibility.
+    //FIXME why is this allowed to be undefined? Retained as
+    // `undefined`-capable for backwards source compatibility.
     _selectedPreset = $state();
     /**
      * Sanitised segment of the persisted-storage key path. Resolves to
@@ -168,11 +151,8 @@ export class PreferencesState {
     /**
      * Boot-time hydration helper. Reads the persisted selected-preset
      * name. Returns `null` for missing / empty / storage-error slots
-     * so the parent can fall back to the first preset (or the
-     * default).
-     *
-     * Mirrors the pre-extraction try/catch around `getItem` verbatim:
-     * the same dev-only warning is emitted on read failure.
+     * so the parent can fall back to the first preset (or the default).
+     * Emits a dev-only warning on `getItem` failure.
      */
     loadSelectedPresetName() {
         let savedPresetName = null;
@@ -221,8 +201,7 @@ export class PreferencesState {
     }
     /**
      * Persist the per-table settings blob (`isCompact`,
-     * `singleClickEditing`, etc.) as JSON. Format and key remain
-     * exactly as before the extraction.
+     * `singleClickEditing`, etc.) as JSON.
      */
     persistSettings(settings) {
         localStorage.setItem(this.storageKey('settings'), JSON.stringify(settings));
@@ -233,9 +212,6 @@ export class PreferencesState {
      * because Map does not survive `JSON.stringify`; the reader (via
      * `loadPresets` -> `reassignDefsToPresets`) rehydrates it through
      * `adaptJSONPinningState`.
-     *
-     * Pulled out of `saveColumnPreset` so the per-preset
-     * `toJSON()` walk is unit-testable in isolation.
      */
     persistPresets(presets) {
         const jsonFriendly = presets.map((preset) => {
@@ -253,9 +229,8 @@ export class PreferencesState {
         localStorage.setItem(this.storageKey('presets'), JSON.stringify(jsonFriendly));
     }
     /**
-     * Apply a saved column preset to the live table layout and
-     * persist the selection by name. Mirrors the pre-extraction
-     * `TableContext.setSelectedPreset` verbatim:
+     * Apply a saved column preset to the live table layout and persist
+     * the selection by name:
      *
      * 1. Replace `columnDefs`, `columnVisibility`, `columnPinning`.
      * 2. Forward the preset's `sortingState` to the data-repository
@@ -281,10 +256,8 @@ export class PreferencesState {
      * Snapshot the current column layout into a new preset, replacing
      * any existing preset whose name matches case-insensitively, and
      * persist the full preset list to `localStorage`. Marks the new
-     * preset as selected (which also persists its name).
-     *
-     * Mirrors the pre-extraction `TableContext.saveColumnPreset`
-     * verbatim. No-op when `name` is empty.
+     * preset as selected (which also persists its name). No-op when
+     * `name` is empty.
      */
     saveColumnPreset = (name) => {
         if (!name) {