@lavalogic/scoria 0.37.55 → 0.38.0

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

@@ -5,6 +5,7 @@ import { ClipboardState } from './ClipboardState.svelte.js';
 import { PreferencesState } from './PreferencesState.svelte.js';
 import { QueryValuesState } from './QueryValuesState.svelte.js';
 import { SelectionState } from './SelectionState.svelte.js';
+import { ViewState } from './ViewState.svelte.js';
 import { tick, untrack } from 'svelte';
 import { SvelteMap } from 'svelte/reactivity';
 import { ColumnType } from '../Columns/ColumnType.js';
@@ -15,6 +16,8 @@ import { FilteringState } from './FilteringState.svelte.js';
 import { ColumnLayoutState } from './ColumnLayoutState.svelte.js';
 import { FocusState } from './FocusState.svelte.js';
 import { VirtualisationState } from './VirtualisationState.svelte.js';
+import { NumberDateFilterMode } from '../Filtering/NumberDateFilterMode.js';
+import { StringFilterMode } from '../Filtering/StringFilterMode.js';
 import { PaginationType } from '../Pagination/PaginationType.js';
 import { ToolbarPosition } from '../Toolbar/ToolbarPosition.js';
 const SORTING_ICON_WIDTH = 24;
@@ -26,6 +29,29 @@ const InternalSymbol = Symbol();
  * write once the user settles.
  */
 const LAYOUT_PERSIST_DEBOUNCE_MS = 250;
+/**
+ * Debounce window (ms) for the auto-persist of the live filter state.
+ * Collapses a burst of changes - notably per-keystroke quick-filter
+ * typing - into a single `localStorage` write once the user settles.
+ * Kept equal to `LAYOUT_PERSIST_DEBOUNCE_MS` so the layout and filter
+ * auto-persist effects behave consistently.
+ */
+const FILTER_PERSIST_DEBOUNCE_MS = 250;
+/**
+ * The complete set of filter-mode operator strings scoria recognises -
+ * the union of every `StringFilterMode` and `NumberDateFilterMode`
+ * value. `_applyFilter` validates each persisted mode string against
+ * this set and drops any it no longer knows (schema drift, a removed
+ * operator) rather than forwarding a bogus mode to the repository.
+ *
+ * Built once at module load. Some literals collide between the two enums
+ * (`'='` is both `StringFilterMode.ImplicitEquals` and
+ * `NumberDateFilterMode.Equals`); the `Set` naturally de-duplicates.
+ */
+const KNOWN_FILTER_MODES = new Set([
+    ...Object.values(StringFilterMode),
+    ...Object.values(NumberDateFilterMode),
+]);
 /**
  * Default values applied by `TableContext.init` for any `TableInitOptions`
  * field the consumer omits. Frozen so callers (notably `NestedTable`)
@@ -59,6 +85,8 @@ export class TableContext {
     selectionExtractor;
     getUserId;
     _onEditCell;
+    datatableUuid;
+    remoteLayouts;
     debug;
     static identifier = Symbol();
     /**
@@ -77,13 +105,25 @@ export class TableContext {
         // (cell wrappers compare by reference via the keying cache)
         // and avoids the `selectionExtractor is not a function` crash
         // inside `SelectionState.cachedKey` and `TableRow.svelte`.
-        options.selectionExtractor ?? ((row) => row), options.getUserId, options.onEditCell, options.debug ?? DEFAULT_TABLE_INIT_OPTIONS.debug);
+        options.selectionExtractor ?? ((row) => row), options.getUserId, options.onEditCell, options.datatableUuid, options.remoteLayouts, options.debug ?? DEFAULT_TABLE_INIT_OPTIONS.debug);
         return context;
     }
     // #region constructor
     constructor(INTERNAL_ONLY, defaultColumnDefs, tableName, dataRepo, allowCopy, enableResize, allowColumnReordering, allowQuickFiltering, showQuickFilterByDefault, allowAdvancedFiltering, toolbarPosition, displayFooter, selectionExtractor, getUserId, _onEditCell = () => {
         console.warn('Cannot edit immutable table');
-    }, debug) {
+    }, 
+    /**
+     * Stable per-table identifier supplied by the host app, or
+     * `undefined` when remote saved views are disabled. Stored only;
+     * later steps consume it.
+     */
+    datatableUuid, 
+    /**
+     * Injected backend adapter for saved layouts/filters, or
+     * `undefined` when remote saved views are disabled. Stored only;
+     * later steps consume it.
+     */
+    remoteLayouts, debug) {
         this.defaultColumnDefs = defaultColumnDefs;
         this.tableName = tableName;
         this.allowCopy = allowCopy;
@@ -97,6 +137,8 @@ export class TableContext {
         this.selectionExtractor = selectionExtractor;
         this.getUserId = getUserId;
         this._onEditCell = _onEditCell;
+        this.datatableUuid = datatableUuid;
+        this.remoteLayouts = remoteLayouts;
         this.debug = debug;
         if (INTERNAL_ONLY != InternalSymbol) {
             throw new Error('This class may only be instantiated through the static init() method');
@@ -353,6 +395,11 @@ export class TableContext {
         // `_layoutHydrated` so the boot-time hydration below does not race
         // a write of the default layout over the saved snapshot, and
         // debounced so a drag-resize storm collapses to a single write.
+        //
+        // The same debounced callback also drives the FPM 403 view-state
+        // machine: it compares the freshly captured layout against the
+        // active view's baseline, updates `_viewState.isDirty`, and
+        // persists the `{ active, dirty }` `JSONActiveView` envelope.
         $effect(() => {
             const snapshot = this._captureLayout();
             if (!this._layoutHydrated) {
@@ -364,76 +411,101 @@ export class TableContext {
             this._layoutPersistTimer = setTimeout(() => {
                 this._layoutPersistTimer = undefined;
                 this._preferences.persistLayout(snapshot);
+                // Dirty tracking: the layout is dirty when it diverges
+                // from the active view's baseline. `_captureLayout`
+                // builds its object deterministically, so a stable
+                // `JSON.stringify` comparison is sufficient. When no
+                // baseline has been captured yet (should not happen
+                // past boot) treat the layout as clean.
+                const differs = this._viewBaseline !== undefined &&
+                    JSON.stringify(snapshot) !== JSON.stringify(this._viewBaseline);
+                this._viewState.markDirty('layout', differs);
+                this._persistActiveView();
             }, LAYOUT_PERSIST_DEBOUNCE_MS);
         });
+        // Auto-persist the live filter state (per-column values + modes)
+        // to localStorage on every change - the filter counterpart of the
+        // layout auto-persist effect above. A user's quick-filter / advanced
+        // filter tweaks survive navigation and reload without saving a named
+        // filter view. Gated on the SAME `_layoutHydrated` boot gate (the
+        // boot chain hydrates the filter working copy alongside the layout,
+        // so a single gate covers both) and debounced so per-keystroke
+        // typing collapses to one write.
+        //
+        // Fully independent of the layout effect: it reads only the repo's
+        // filter state, compares against the FILTER baseline, sets the
+        // FILTER dirty flag, and persists the `active-filter-view`
+        // envelope. Editing a layout never re-runs this effect and vice
+        // versa.
+        $effect(() => {
+            const snapshot = this._captureFilter();
+            if (!this._layoutHydrated) {
+                return;
+            }
+            if (this._filterPersistTimer !== undefined) {
+                clearTimeout(this._filterPersistTimer);
+            }
+            this._filterPersistTimer = setTimeout(() => {
+                this._filterPersistTimer = undefined;
+                this._preferences.persistFilter(snapshot);
+                // Dirty tracking: the filter is dirty when it diverges from
+                // the active filter view's baseline. `_captureFilter` builds
+                // its object deterministically (sorted entries / sorted mode
+                // keys), so a stable `JSON.stringify` comparison is
+                // sufficient. When no baseline has been captured yet (should
+                // not happen past boot) treat the filter as clean.
+                const differs = this._filterBaseline !== undefined &&
+                    JSON.stringify(snapshot) !== JSON.stringify(this._filterBaseline);
+                this._viewState.markDirty('filter', differs);
+                this._persistActiveFilterView();
+            }, FILTER_PERSIST_DEBOUNCE_MS);
+        });
         if (browser) {
             this._getUserDefaults();
-            const removeInvalidPresets = () => {
-                this._preferences.clearPresetsAndSelection();
-                const visibilityState = {};
-                this.columnDefs.forEach((def) => {
-                    if (def.defaultHidden || def.columnType === ColumnType.FilterOnly) {
-                        visibilityState[def.id] = false;
-                    }
-                });
-                const defaultPreset = {
-                    name: 'Default',
-                    columnDefs: this.columnDefs,
-                    sortingState: [],
-                    visibilityState,
-                    columnPinningState: {},
-                };
-                this.selectedPreset = defaultPreset;
-                this.columnVisibility = visibilityState;
-                this._preferences.setPresets([...this.columnPresets, defaultPreset]);
-            };
             this.setupDefaultColumnDefs()
                 .then((defs) => {
                 this.showQuickFiltering = this.showQuickFilterByDefault;
                 this.isSelectable = defs.some((it) => it.id.startsWith('is-selectable-'));
-                if (this.allowColumnReordering) {
-                    const presets = this._preferences.loadPresets();
-                    if (presets.length > 0) {
-                        if (presets[0] && areDefsEquivalent(defs, presets[0].columnDefs)) {
-                            return this.reassignDefsToPresets(presets).then((p) => p);
-                        }
-                        else if (dev && presets[0]) {
-                            console.warn(`invalid presets:`, presets);
-                        }
-                    }
-                }
-                return null;
-            })
-                .then((presets) => {
-                if (presets == null) {
-                    removeInvalidPresets();
-                    return;
-                }
-                const savedPresetName = this._preferences.loadSelectedPresetName();
-                if (savedPresetName) {
-                    const preset = presets.find((it) => it.name === savedPresetName);
-                    if (preset && areDefsEquivalent(this.columnDefs, preset.columnDefs)) {
-                        this.columnDefs = preset.columnDefs;
-                        this.columnVisibility = preset.visibilityState;
-                        this.columnPinning = preset.columnPinningState;
-                        this.selectedPreset = preset;
-                    }
-                    else {
-                        localStorage.removeItem(this._preferences.storageKey('selected-preset-name'));
-                        this.selectedPreset = presets[0];
-                        if (presets.at(0)?.visibilityState) {
-                            this.columnVisibility = presets[0].visibilityState;
-                        }
-                    }
-                    this._preferences.setPresets(presets);
-                }
-            })
-                .then(() => {
-                // Restore the auto-saved live layout on top of whatever
-                // the preset flow produced, then open the auto-persist
-                // gate. Runs regardless of which preset branch was taken.
+                // Capture the Default-layout baseline: the factory /
+                // code-defined column state `setupDefaultColumnDefs` just
+                // produced, BEFORE the localStorage working copy is
+                // overlaid. This IS the "Default" view - the FPM 403
+                // view-state machine measures dirtiness against it and
+                // `resetToDefault` restores it.
+                this._defaultLayoutSnapshot = this._captureLayout();
+                this._viewBaseline = this._defaultLayoutSnapshot;
+                // Capture the Default-filter baseline: the empty / initial
+                // filter state at boot, BEFORE the localStorage working
+                // copy is overlaid. This is the "Default" the FPM 403
+                // filter view-state machine measures dirtiness against.
+                this._defaultFilterSnapshot = this._captureFilter();
+                this._filterBaseline = this._defaultFilterSnapshot;
+                // Restore the auto-saved live layout on top of the
+                // factory Default.
                 this._hydrateLayout();
+                // Restore the auto-saved live filter working copy. The
+                // filter counterpart of `_hydrateLayout`; fully
+                // independent of the layout restore.
+                this._hydrateFilter();
+                // Restore the persisted active-view selection on top of
+                // the working copy. The working copy that `_hydrateLayout`
+                // applied stays the live state; this only re-points
+                // `activeView` / the baseline and restores the dirty
+                // flag. Done before the `_layoutHydrated` gate opens so
+                // the auto-persist effect does not clobber it.
+                this._hydrateActiveView();
+                // Restore the persisted filter active-view selection,
+                // independently of the layout one.
+                this._hydrateActiveFilterView();
                 this._layoutHydrated = true;
+                // Fire-and-forget: pull the saved views from the backend.
+                // Deliberately not awaited so a slow / failing network
+                // never blocks the first table render. Once it resolves,
+                // `refreshSavedViews` reconciles the baseline against the
+                // now-known body of a persisted saved-view ref.
+                if (this.remoteLayouts && this.datatableUuid) {
+                    this.refreshSavedViews().catch(devCatch);
+                }
             })
                 .catch(devCatch);
         }
@@ -456,6 +528,13 @@ export class TableContext {
      * to run after the component is gone.
      */
     _layoutPersistTimer = undefined;
+    /**
+     * Pending debounce timer for the filter auto-persist. The filter
+     * counterpart of `_layoutPersistTimer`; deliberately not cleared on
+     * teardown for the same reason - a still-pending `persistFilter`
+     * write should flush, and it only touches `localStorage`.
+     */
+    _filterPersistTimer = undefined;
     _paginationRepo = $state();
     get paginationRepo() {
         return this._paginationRepo;
@@ -537,22 +616,6 @@ export class TableContext {
     set columnDefs(v) {
         this._columnLayout.columnDefs = v;
     }
-    /**
-     * Delegates to `_preferences._columnPresets`. The setter is private
-     * because the public write path is `saveColumnPreset` (which also
-     * persists to localStorage); internal call sites that need to
-     * mutate the list directly call `_preferences.setPresets(...)`.
-     */
-    get columnPresets() {
-        return this._preferences.columnPresets;
-    }
-    /** Delegates to `_preferences._selectedPreset`. */
-    get selectedPreset() {
-        return this._preferences.selectedPreset;
-    }
-    set selectedPreset(v) {
-        this._preferences.selectedPreset = v;
-    }
     /**
      * Delegates to `_focus._focusedRowIndices`. Populated by the
      * focus-derived `$effect` in the constructor through
@@ -866,47 +929,85 @@ export class TableContext {
     /**
      * Persistence / preferences sub-context:
      *
-     * - saved column-presets list and currently-selected preset
-     *   (`columnPresets`, `selectedPreset`);
      * - `userIdSegment` `$derived` (namespaces every
      *   `scoria-table:<user>:<tableName>:<suffix>` storage key);
-     * - `saveColumnPreset` / `setSelectedPreset` writers (apply layout
-     *   AND persist);
-     * - `loadPresets` / `loadSelectedPresetName` / `loadSavedSettings`
-     *   boot-time hydration helpers;
-     * - `persistSettings` writer used by the in-app settings toggles
+     * - `loadSavedSettings` boot-time hydration helper and the
+     *   `persistSettings` writer used by the in-app settings toggles
      *   (`setIsCompact`, `setAlternateRowColours`, etc.);
-     * - schema-validation typeguards (exported alongside the sub-context
-     *   for unit testing).
+     * - the layout / active-view / filter / active-filter-view
+     *   load / persist / clear helpers driving the FPM 403 datatable
+     *   views;
+     * - the `isSavedTableSettings` schema-validation typeguard (exported
+     *   alongside the sub-context for unit testing).
      *
      * The settings fields themselves (`isCompact`, `singleClickEditing`,
      * `alternateRowColours`, etc.) stay on `TableContext` because each
      * drives reactive UI; only the localStorage round-trip lives here.
-     * Delegating getters / setters / methods on `TableContext` cover the
-     * full surface (`columnPresets`, `selectedPreset`, `saveColumnPreset`,
-     * `setSelectedPreset`, `setIsCompact`, etc.).
      */
     _preferences = new PreferencesState({
         getTableName: () => this.tableName,
         getUserId: () => this.getUserId(),
-        getColumnDefs: () => this.columnDefs,
-        getColumnVisibility: () => this.columnVisibility,
-        getColumnPinning: () => this.columnPinning,
-        getSortingArray: () => this.paginationRepo?.sorting,
-        setColumnDefs: (defs) => {
-            this.columnDefs = defs;
-        },
-        setColumnVisibility: (state) => {
-            this.columnVisibility = state;
-        },
-        setColumnPinning: (state) => {
-            this.columnPinning = state;
-        },
-        applySortingState: (state) => {
-            this.paginationRepo?.updateSorting?.(state);
-        },
-        getDebug: () => this.debug,
+        getDatatableUuid: () => this.datatableUuid,
     });
+    /**
+     * Datatable view-selection sub-context (FPM 403):
+     *
+     * - `activeView` - which view the live table belongs to (the
+     *   code-defined Default layout, or a named saved `DatatableView`);
+     * - `isDirty` - whether the live layout has diverged from the active
+     *   view's saved baseline;
+     * - the saved views per kind - `'layout'` and `'filter'` - fetched
+     *   through the injected `remoteLayouts` adapter;
+     * - `dropdownLabel(kind)` - the `$derived` label the toolbar
+     *   view-picker renders.
+     *
+     * `ViewState` tracks the `'layout'` and `'filter'` kinds as two fully
+     * independent slices: applying or dirtying one never touches the
+     * other. It is a pure state holder - the apply / capture / baseline
+     * tracking / adapter calls all live on this class (`_applyLayout` /
+     * `_captureLayout` / `_applyFilter` / `_captureFilter`,
+     * `_viewBaseline` / `_filterBaseline`, the `applyDatatableView` /
+     * `resetToDefault` / `saveCurrentAsNewView` / `saveActiveView` /
+     * `refreshSavedViews` methods below), mirroring how `SelectionState`
+     * keeps its effects on the parent. The dirty comparisons run in the
+     * two debounced auto-persist `$effect`s in the constructor.
+     */
+    _viewState = new ViewState();
+    /**
+     * Baseline `JSONTableLayout` the dirty comparison is measured
+     * against: the saved state of whatever view `_viewState.activeView`
+     * points at. Set to the Default snapshot once `setupDefaultColumnDefs`
+     * completes, and re-pointed at a saved view's `body.layout` whenever
+     * one is applied. `undefined` only in the brief window before the
+     * boot chain captures the Default snapshot.
+     */
+    _viewBaseline = undefined;
+    /**
+     * The Default-layout snapshot, captured once right after
+     * `setupDefaultColumnDefs` (before the working copy is applied). Kept
+     * separately from `_viewBaseline` so `resetToDefault` can restore the
+     * factory layout regardless of which saved view was active.
+     */
+    _defaultLayoutSnapshot = undefined;
+    /**
+     * Baseline `JSONTableFilter` the *filter* dirty comparison is
+     * measured against: the saved state of whatever filter view
+     * `_viewState.activeView('filter')` points at. Set to the Default
+     * filter snapshot once the boot chain runs, and re-pointed at a saved
+     * view's `body.filter` whenever one is applied. The filter
+     * counterpart of `_viewBaseline`; kept entirely separate so layout
+     * and filter dirtiness never cross-contaminate.
+     */
+    _filterBaseline = undefined;
+    /**
+     * The Default-filter snapshot, captured once during the boot chain
+     * (the empty / initial filter state, before the working copy is
+     * applied). Kept separately from `_filterBaseline` so a future
+     * filter-reset can restore the initial filter state regardless of
+     * which saved filter view was active. The filter counterpart of
+     * `_defaultLayoutSnapshot`.
+     */
+    _defaultFilterSnapshot = undefined;
     /**
      * Selection + highlighting + key-cache sub-context:
      *
@@ -1660,31 +1761,6 @@ export class TableContext {
     // 		});
     // 	}
     // };
-    /**
-     * Applies the preset to the live column layout, forwards the
-     * preset's `sortingState` to the data-repository updater, and
-     * persists the selected name. Delegates to
-     * `_preferences.setSelectedPreset`.
-     *
-     * The "no sorting state found" debug warning is emitted here (not
-     * inside the sub-context) so the public surface stays byte-identical
-     * - `_preferences.applySortingState` already no-ops when
-     * `paginationRepo.updateSorting` is absent.
-     */
-    setSelectedPreset = (preset) => {
-        if (!this.paginationRepo?.updateSorting) {
-            console.warn('no sorting state found');
-        }
-        this._preferences.setSelectedPreset(preset);
-    };
-    /**
-     * Adds or replaces a saved preset for the current column layout and
-     * persists the full preset list to localStorage. Delegates to
-     * `_preferences.saveColumnPreset`.
-     */
-    saveColumnPreset = (name) => {
-        this._preferences.saveColumnPreset(name);
-    };
     /**
      * Delegates to `_focus.setFocusEnd`. This listener should be added
      * and removed based on `isMousingDown`.
@@ -1907,6 +1983,469 @@ export class TableContext {
             this._applyLayout(layout);
         }
     }
+    /**
+     * Boot-time hydration for the FPM 403 view-state machine. Reads the
+     * persisted `JSONActiveView` envelope and restores the active-view
+     * selection on top of whatever `_hydrateLayout` produced:
+     *
+     * - no slot / Default ref: the active view stays Default and the
+     *   baseline stays the Default snapshot (already set by the caller);
+     * - a saved-view ref: `activeView` is re-pointed at it, and the
+     *   baseline is repointed at the matching view's `body.layout` IF the
+     *   saved-views list has already loaded. The list is fetched
+     *   fire-and-forget, so it usually has NOT loaded yet at boot - in
+     *   that case the persisted ref is restored as-is and `refreshSavedViews`
+     *   reconciles the baseline once the network resolves.
+     *
+     * The persisted `dirty` flag is restored verbatim via `markDirty`;
+     * the live working copy that `_hydrateLayout` applied is the source
+     * of truth for the layout contents.
+     *
+     * Runs before the `_layoutHydrated` gate opens so the auto-persist
+     * effect does not clobber the restored selection.
+     */
+    _hydrateActiveView() {
+        const persisted = this._preferences.loadActiveView();
+        if (persisted === null) {
+            return;
+        }
+        if (persisted.active.kind === 'saved') {
+            this._viewState.setActiveView('layout', persisted.active);
+            // If the saved-views list happens to be loaded already,
+            // reconcile the baseline now; otherwise `refreshSavedViews`
+            // does it once the fetch resolves.
+            this._reconcileBaselineForActiveView();
+        }
+        this._viewState.markDirty('layout', persisted.dirty);
+    }
+    /**
+     * Re-point `_viewBaseline` at the active view's saved layout. For a
+     * Default active view the baseline is the Default snapshot; for a
+     * saved active view it is the matching `savedLayouts` entry's
+     * `body.layout` (when that entry is known - if the saved-views list
+     * has not loaded yet the baseline is left unchanged and is reconciled
+     * later by `refreshSavedViews`).
+     *
+     * Does NOT recompute the dirty flag - the next auto-persist tick does
+     * that against the updated baseline.
+     */
+    _reconcileBaselineForActiveView() {
+        const active = this._viewState.activeView('layout');
+        if (active.kind === 'default') {
+            if (this._defaultLayoutSnapshot !== undefined) {
+                this._viewBaseline = this._defaultLayoutSnapshot;
+            }
+            return;
+        }
+        const match = this._viewState.savedViews('layout').find((view) => view.id === active.id);
+        if (match && match.body.kind === 'layout') {
+            this._viewBaseline = match.body.layout;
+        }
+    }
+    /**
+     * Persist the current layout `{ active, dirty }` selection as a
+     * `JSONActiveView` envelope. Called (debounced) from the layout
+     * auto-persist `$effect` alongside the working-copy layout write.
+     */
+    _persistActiveView() {
+        const envelope = {
+            active: this._viewState.activeView('layout'),
+            dirty: this._viewState.isDirty('layout'),
+        };
+        this._preferences.persistActiveView(envelope);
+    }
+    // #region FPM 403 A3 - filter serialisation
+    /**
+     * Snapshot the live filter state - the per-column filter values and
+     * per-column filter modes - into the persistable `JSONTableFilter`
+     * shape. The filter counterpart of `_captureLayout`.
+     *
+     * Reads the repository's `filtering` array (`{ id, value }` entries)
+     * and `filterModes` map; reading both makes the filter auto-persist
+     * `$effect` re-subscribe whenever either changes. The `SvelteMap` of
+     * modes is flattened to a plain `Record<string,string>` (a `Map` does
+     * not survive `JSON.stringify`). Entries and mode keys are sorted so
+     * the captured object is deterministic and a stable `JSON.stringify`
+     * comparison drives the dirty flag.
+     *
+     * Sort order and pagination are deliberately excluded - a saved
+     * filter is values + modes only.
+     *
+     * `filtering` and `filterModes` are mandatory on the `IDataRepository`
+     * contract and present on every repo kind (local, built-in remote,
+     * custom remote), so no method is missing here; `Array.isArray` /
+     * `keys()` guard only against a genuinely malformed value.
+     */
+    _captureFilter() {
+        const repo = this.dataRepo;
+        const liveFiltering = repo.filtering;
+        const liveModes = repo.filterModes;
+        const filters = Array.isArray(liveFiltering)
+            ? liveFiltering
+                .map((entry) => ({ id: entry.id, value: entry.value }))
+                .sort((a, b) => a.id.localeCompare(b.id))
+            : [];
+        const modes = {};
+        // Sort the keys so the flattened record is order-stable, which
+        // keeps the `JSON.stringify` dirty comparison deterministic.
+        for (const id of [...liveModes.keys()].sort((a, b) => a.localeCompare(b))) {
+            const mode = liveModes.get(id);
+            if (mode !== undefined) {
+                modes[id] = mode;
+            }
+        }
+        return { filters, modes };
+    }
+    /**
+     * Apply a persisted `JSONTableFilter` to the live filter state. The
+     * filter counterpart of `_applyLayout`.
+     *
+     * 1. `resetFilters()` clears every active filter value first, so the
+     *    applied filter fully replaces (rather than merges into) whatever
+     *    was live;
+     * 2. each `{ id, value }` whose `id` still maps to a live column is
+     *    re-applied via `filterBy` - stale ids (a column removed since
+     *    the filter was saved) are dropped, mirroring how `_applyLayout`
+     *    drops unknown ids;
+     * 3. each mode whose `id` still maps to a live column AND whose mode
+     *    string is a recognised `StringFilterMode` / `NumberDateFilterMode`
+     *    value is re-applied via `setFilterMode`; unknown modes are
+     *    dropped rather than forwarded.
+     *
+     * Modes are applied before values so a value-bearing mode (e.g.
+     * "Empty") sees the column's mode already set. Defensive: a repo
+     * missing `resetFilters` / `filterBy` / `setFilterMode` no-ops the
+     * corresponding step rather than crashing.
+     */
+    _applyFilter(filter) {
+        const repo = this.dataRepo;
+        // Keyed by plain `string` so persisted-snapshot ids - read back as
+        // plain strings - look up cleanly against the live column set.
+        // eslint-disable-next-line svelte/prefer-svelte-reactivity
+        const liveColumnIds = new Set(this.columnDefs.map((def) => def.id));
+        if (typeof repo.resetFilters === 'function') {
+            repo.resetFilters();
+        }
+        // Modes first: a value-bearing mode must be set before its value.
+        if (typeof repo.setFilterMode === 'function') {
+            for (const [id, mode] of Object.entries(filter.modes)) {
+                // Drop stale column ids and unrecognised mode strings.
+                if (liveColumnIds.has(id) && KNOWN_FILTER_MODES.has(mode)) {
+                    repo.setFilterMode(id, mode);
+                }
+            }
+        }
+        if (typeof repo.filterBy === 'function') {
+            for (const entry of filter.filters) {
+                if (liveColumnIds.has(entry.id)) {
+                    repo.filterBy(entry.id, entry.value);
+                }
+            }
+        }
+    }
+    /**
+     * Boot-time hydration. Reads the auto-saved live-filter snapshot and
+     * applies it, restoring the user's last per-column filter values /
+     * modes. No-op when no snapshot is stored. The filter counterpart of
+     * `_hydrateLayout`.
+     */
+    _hydrateFilter() {
+        const filter = this._preferences.loadFilter();
+        if (filter) {
+            this._applyFilter(filter);
+        }
+    }
+    /**
+     * Boot-time hydration for the FPM 403 filter view-state machine.
+     * Reads the persisted *filter* `JSONActiveView` envelope and restores
+     * the filter active-view selection on top of whatever `_hydrateFilter`
+     * produced. The filter counterpart of `_hydrateActiveView`; runs
+     * independently and never touches the layout slice.
+     *
+     * Runs before the `_layoutHydrated` gate opens so the filter
+     * auto-persist effect does not clobber the restored selection.
+     */
+    _hydrateActiveFilterView() {
+        const persisted = this._preferences.loadActiveFilterView();
+        if (persisted === null) {
+            return;
+        }
+        if (persisted.active.kind === 'saved') {
+            this._viewState.setActiveView('filter', persisted.active);
+            this._reconcileBaselineForActiveFilterView();
+        }
+        this._viewState.markDirty('filter', persisted.dirty);
+    }
+    /**
+     * Re-point `_filterBaseline` at the active filter view's saved
+     * filter. The filter counterpart of `_reconcileBaselineForActiveView`:
+     * for a Default active filter view the baseline is the Default filter
+     * snapshot; for a saved one it is the matching saved-filter entry's
+     * `body.filter` (when that entry is known).
+     *
+     * Does NOT recompute the dirty flag - the next filter auto-persist
+     * tick does that against the updated baseline.
+     */
+    _reconcileBaselineForActiveFilterView() {
+        const active = this._viewState.activeView('filter');
+        if (active.kind === 'default') {
+            if (this._defaultFilterSnapshot !== undefined) {
+                this._filterBaseline = this._defaultFilterSnapshot;
+            }
+            return;
+        }
+        const match = this._viewState.savedViews('filter').find((view) => view.id === active.id);
+        if (match && match.body.kind === 'filter') {
+            this._filterBaseline = match.body.filter;
+        }
+    }
+    /**
+     * Persist the current filter `{ active, dirty }` selection as a
+     * `JSONActiveView` envelope into the `active-filter-view` slot.
+     * Called (debounced) from the filter auto-persist `$effect` alongside
+     * the working-copy filter write. The filter counterpart of
+     * `_persistActiveView`.
+     */
+    _persistActiveFilterView() {
+        const envelope = {
+            active: this._viewState.activeView('filter'),
+            dirty: this._viewState.isDirty('filter'),
+        };
+        this._preferences.persistActiveFilterView(envelope);
+    }
+    // #endregion FPM 403 A3
+    /**
+     * Apply a saved `DatatableView` to the live table and mark it as the
+     * active view of its kind. Branches on `view.body.kind`:
+     *
+     * - `'layout'`: apply `view.body.layout` via `_applyLayout`, set the
+     *   *layout* active view to `{ kind:'saved', id, name }`, re-point the
+     *   *layout* baseline at that layout, clear the *layout* dirty flag.
+     *   The filter state, columns' filter values and the filter dirty
+     *   flag are left untouched.
+     * - `'filter'`: apply `view.body.filter` via `_applyFilter`, set the
+     *   *filter* active view, re-point the *filter* baseline at that
+     *   filter, clear the *filter* dirty flag. The column layout and the
+     *   layout dirty flag are left untouched.
+     *
+     * Applying one kind never mutates the other kind's state - the layout
+     * and filter view machines are fully independent.
+     *
+     * Bound as a class property so the toolbar view-picker (built later)
+     * can pass the reference around without re-binding `this`.
+     */
+    applyDatatableView = (view) => {
+        const body = view.body;
+        switch (body.kind) {
+            case 'layout':
+                this._applyLayout(body.layout);
+                this._viewState.selectSavedView('layout', { id: view.id, name: view.name });
+                this._viewBaseline = body.layout;
+                this._persistActiveView();
+                return;
+            case 'filter':
+                this._applyFilter(body.filter);
+                this._viewState.selectSavedView('filter', { id: view.id, name: view.name });
+                this._filterBaseline = body.filter;
+                this._persistActiveFilterView();
+                return;
+        }
+    };
+    /**
+     * Reset the live table for `kind` back to its code-defined Default:
+     * apply the captured Default snapshot, set that kind's `activeView`
+     * back to Default, re-point that kind's baseline at the Default
+     * snapshot, and clear that kind's dirty flag.
+     *
+     * - `'layout'`: restores `_defaultLayoutSnapshot` via `_applyLayout`,
+     *   touching only the layout slice;
+     * - `'filter'`: restores `_defaultFilterSnapshot` via `_applyFilter`,
+     *   touching only the filter slice.
+     *
+     * Resetting one kind never mutates the other - it honours the same
+     * layout/filter independence guarantee as `applyDatatableView`.
+     *
+     * `kind` defaults to `'layout'` so the A2/A3 layout call sites that
+     * call `resetToDefault()` with no argument keep working unchanged.
+     *
+     * No-op (with a dev log) when the relevant Default snapshot has not
+     * been captured yet (i.e. before the boot chain completes).
+     *
+     * Bound as a class property so the toolbar view-picker and the Table
+     * Configuration modal can pass the reference around without
+     * re-binding `this`.
+     */
+    resetToDefault = (kind = 'layout') => {
+        if (kind === 'filter') {
+            if (this._defaultFilterSnapshot === undefined) {
+                if (dev) {
+                    console.warn('resetToDefault: default filter snapshot not captured yet');
+                }
+                return;
+            }
+            this._applyFilter(this._defaultFilterSnapshot);
+            this._viewState.selectDefault('filter');
+            this._filterBaseline = this._defaultFilterSnapshot;
+            this._persistActiveFilterView();
+            return;
+        }
+        if (this._defaultLayoutSnapshot === undefined) {
+            if (dev) {
+                console.warn('resetToDefault: default layout snapshot not captured yet');
+            }
+            return;
+        }
+        this._applyLayout(this._defaultLayoutSnapshot);
+        this._viewState.selectDefault('layout');
+        this._viewBaseline = this._defaultLayoutSnapshot;
+        this._persistActiveView();
+    };
+    /**
+     * Save the live state of `kind` as a brand-new saved view through the
+     * injected `remoteLayouts` adapter:
+     *
+     * 1. build a `CreateDatatableViewRequest` whose `body` is, by `kind`,
+     *    either `{ kind:'layout', layout: _captureLayout() }` or
+     *    `{ kind:'filter', filter: _captureFilter() }`, plus the
+     *    host-supplied `datatableUuid` and the owning user;
+     * 2. `await remoteLayouts.createView(...)`;
+     * 3. push the returned `DatatableView` into the matching kind's
+     *    saved-views list;
+     * 4. apply it via `applyDatatableView`, which re-points that kind's
+     *    baseline and clears that kind's dirty flag.
+     *
+     * Only the named kind's state is touched. No-op (dev-logged via
+     * `devCatch`) when remote saved views are disabled (`datatableUuid` /
+     * `remoteLayouts` absent) or no owning user id is available - scoria
+     * stays backend-agnostic, so it never fabricates these. An adapter
+     * rejection is routed to `devCatch` and never breaks the table.
+     */
+    saveCurrentAsNewView = async (name, kind) => {
+        const adapter = this.remoteLayouts;
+        const datatableUuid = this.datatableUuid;
+        const ownerUserId = this.getUserId();
+        if (!adapter || !datatableUuid || ownerUserId === undefined) {
+            if (dev) {
+                console.warn('saveCurrentAsNewView: no adapter / datatableUuid / userId - cannot save remotely');
+            }
+            return;
+        }
+        try {
+            const body = kind === 'filter'
+                ? { kind: 'filter', filter: this._captureFilter() }
+                : { kind: 'layout', layout: this._captureLayout() };
+            const request = {
+                datatableUuid,
+                kind,
+                name,
+                body,
+                ownerUserId,
+            };
+            const created = await adapter.createView(request);
+            this._viewState.setSavedViews(kind, [...this._viewState.savedViews(kind), created]);
+            this.applyDatatableView(created);
+        }
+        catch (e) {
+            devCatch(e);
+        }
+    };
+    /**
+     * Overwrite the currently-active saved view of `kind` with the live
+     * state of that kind through the injected `remoteLayouts` adapter:
+     *
+     * 1. require that kind's `activeView` to be `kind: 'saved'` (Default
+     *    cannot be saved over - the caller uses `saveCurrentAsNewView`
+     *    instead);
+     * 2. build an `UpdateDatatableViewRequest` whose `body` is the
+     *    captured live layout or filter, by `kind`;
+     * 3. `await remoteLayouts.updateView(...)`;
+     * 4. refresh the matching entry in that kind's saved-views list,
+     *    re-select it, re-point that kind's baseline, clear that kind's
+     *    dirty flag.
+     *
+     * Only the named kind's state is touched. No-op (dev-logged) when
+     * that kind's active view is Default or remote saved views are
+     * disabled. An adapter rejection is routed to `devCatch`.
+     */
+    saveActiveView = async (kind) => {
+        const active = this._viewState.activeView(kind);
+        if (active.kind !== 'saved') {
+            if (dev) {
+                console.warn('saveActiveView: active view is Default - use saveCurrentAsNewView');
+            }
+            return;
+        }
+        const adapter = this.remoteLayouts;
+        if (!adapter) {
+            if (dev) {
+                console.warn('saveActiveView: no adapter - cannot save remotely');
+            }
+            return;
+        }
+        try {
+            if (kind === 'filter') {
+                const filter = this._captureFilter();
+                const request = {
+                    id: active.id,
+                    body: { kind: 'filter', filter },
+                };
+                const updated = await adapter.updateView(request);
+                this._viewState.setSavedViews('filter', this._viewState
+                    .savedViews('filter')
+                    .map((view) => (view.id === updated.id ? updated : view)));
+                this._viewState.selectSavedView('filter', { id: updated.id, name: updated.name });
+                this._filterBaseline = updated.body.kind === 'filter' ? updated.body.filter : filter;
+                this._persistActiveFilterView();
+                return;
+            }
+            const layout = this._captureLayout();
+            const request = {
+                id: active.id,
+                body: { kind: 'layout', layout },
+            };
+            const updated = await adapter.updateView(request);
+            this._viewState.setSavedViews('layout', this._viewState
+                .savedViews('layout')
+                .map((view) => (view.id === updated.id ? updated : view)));
+            this._viewState.selectSavedView('layout', { id: updated.id, name: updated.name });
+            this._viewBaseline = updated.body.kind === 'layout' ? updated.body.layout : layout;
+            this._persistActiveView();
+        }
+        catch (e) {
+            devCatch(e);
+        }
+    };
+    /**
+     * Fetch the saved views for this datatable through the injected
+     * `remoteLayouts` adapter and publish them into `_viewState`, split by
+     * `kind`: `kind: 'layout'` views into the layout saved-views list and
+     * `kind: 'filter'` views into the filter saved-views list. After the
+     * lists land, reconcile both `_viewBaseline` and `_filterBaseline`
+     * against the now-known body of any persisted saved-view ref.
+     *
+     * No-op when remote saved views are disabled (`datatableUuid` /
+     * `remoteLayouts` absent). An adapter rejection is routed to
+     * `devCatch` and never breaks the table.
+     */
+    refreshSavedViews = async () => {
+        const adapter = this.remoteLayouts;
+        const datatableUuid = this.datatableUuid;
+        if (!adapter || !datatableUuid) {
+            return;
+        }
+        try {
+            const views = await adapter.listViews(datatableUuid);
+            this._viewState.setSavedViews('layout', views.filter((view) => view.kind === 'layout'));
+            this._viewState.setSavedViews('filter', views.filter((view) => view.kind === 'filter'));
+            // A persisted saved-view ref restored at boot may have had an
+            // unknown body until now; reconcile both baselines against it.
+            this._reconcileBaselineForActiveView();
+            this._reconcileBaselineForActiveFilterView();
+        }
+        catch (e) {
+            devCatch(e);
+        }
+    };
     /**
      * Drop the persisted live-layout snapshot for this table. The next
      * mount falls back to the default column layout. Exposed so a host
@@ -2021,6 +2560,22 @@ export class TableContext {
             return def;
         });
         this.columnDefs = adjustedDefs;
+        // Seed the Default column visibility from each def's `defaultHidden`
+        // flag (and hide `FilterOnly` columns, which never render a body
+        // cell). Only fills ids the caller did not already pin via
+        // `initialState.columnVisibility`; an explicit entry always wins.
+        // This is the factory-Default visibility the boot chain captures as
+        // the `_defaultLayoutSnapshot` baseline.
+        const seededVisibility = { ...this.columnVisibility };
+        for (const def of adjustedDefs) {
+            if (def.id in seededVisibility) {
+                continue;
+            }
+            if (def.defaultHidden || def.columnType === ColumnType.FilterOnly) {
+                seededVisibility[def.id] = false;
+            }
+        }
+        this.columnVisibility = seededVisibility;
         return adjustedDefs;
     }
     /**
@@ -2083,63 +2638,8 @@ export class TableContext {
             return newState;
         });
     };
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async reassignDefsToPresets(presets) {
-        const adjustedDefs = this.columnDefs;
-        const asMap = columnDefsToMap(adjustedDefs);
-        console.log('reassigning presets');
-        return presets.map((preset) => {
-            return {
-                ...preset,
-                columnPinningState: adaptJSONPinningState(preset.columnPinningState),
-                columnDefs: preset.columnDefs.map((def) => {
-                    const realDef = def.columnType == ColumnType.RowSelect || def.columnType == ColumnType.Actions
-                        ? adjustedDefs.find((it) => it.columnType === def.columnType)
-                        : asMap.get(def.id);
-                    if (!realDef) {
-                        throw new Error('Could not find equivalent column def:', { cause: def });
-                    }
-                    return realDef;
-                }),
-            };
-        });
-    }
 }
 // #region static functions
-function areDefsEquivalent(newColumnDefs, oldColumnDefs) {
-    const defKeys = newColumnDefs.map((def) => def.id);
-    const presetKeys = oldColumnDefs.map((def) => def.id);
-    if (defKeys.length !== presetKeys.length) {
-        return false;
-    }
-    return newColumnDefs.every((newDef) => {
-        if (newDef.columnType == ColumnType.RowSelect || newDef.columnType == ColumnType.Actions) {
-            return true;
-        }
-        const oldDef = oldColumnDefs.find((d) => d.id === newDef.id);
-        if (oldDef === undefined ||
-            newDef.header !== oldDef.header ||
-            newDef.columnType !== oldDef.columnType ||
-            newDef.filterValueType !== oldDef.filterValueType
-        // ||
-        // newDef.defaultHidden !== oldDef.defaultHidden ||
-        // newDef.enableHiding !== oldDef.enableHiding ||
-        // newDef.enablePinning !== oldDef.enablePinning ||
-        // newDef.enableResizing !== oldDef.enableResizing
-        ) {
-            return false;
-        }
-        return true;
-    });
-}
-function columnDefsToMap(defs) {
-    // eslint-disable-next-line svelte/prefer-svelte-reactivity
-    const map = new Map();
-    defs.forEach((def) => {
-        map.set(def.id, def);
-    });
-    return map;
-}
 function targetIsLI(target) {
     return target.id.includes('-column-settings-');
 }