@lavalogic/scoria 0.38.13 → 0.38.15

package/dist/Components/AppointmentCalendar/AppointmentCalendar.svelte

@@ -229,12 +229,7 @@
 	let dragStartSlotIndex: number | null = $state(null);
 	let dragEndSlotIndex: number | null = $state(null);
 
-	function onSlotMouseDown(doorId: number, slotIndex: number, e: MouseEvent): void {
-		// Only start a drag-create on the primary (left) button. Otherwise a
-		// middle-click (autoscroll) or right-click would open the create modal.
-		if (e.button !== 0) {
-			return;
-		}
+	function onSlotMouseDown(doorId: number, slotIndex: number): void {
 		if (!ondragcreate || appointmentDragStarted) {
 			return;
 		}
@@ -376,11 +371,6 @@
 	let moveTargetSlotIndex: number | null = $state(null);
 
 	function onAppointmentMouseDown(apt: CalendarAppointment, e: MouseEvent): void {
-		// Only react to the primary (left) button so middle/right clicks don't
-		// start a move or register as an appointment click.
-		if (e.button !== 0) {
-			return;
-		}
 		if (!onappointmentmove) {
 			return;
 		}
@@ -674,8 +664,8 @@
 						class:drag-selected={isSlotInDragRange(door.id, slotIdx)}
 						class:move-target={isSlotInMoveTarget(door.id, slotIdx)}
 						class:row-hover={hoveredSlotIndex === slotIdx}
-						onmousedown={(e) => {
-							onSlotMouseDown(door.id, slotIdx, e);
+						onmousedown={() => {
+							onSlotMouseDown(door.id, slotIdx);
 						}}
 						onmouseenter={() => {
 							hoveredSlotIndex = slotIdx;

package/dist/Components/Table/Misc/TableFooter.svelte

@@ -115,20 +115,34 @@
 		}
 		const current = tableContext.paginationRepo.paginationState.pageIndex + 1;
 		const last = tableContext.lastPage;
+		// Empty / no-results case: render a single "1" button rather than
+		// a "0" button. `lastPage` is a 1-indexed count, never 0; a
+		// misbehaving data repo that returns 0 would otherwise leak
+		// through to a "Previous 0 1 Next" strip (see the page-0
+		// regression captured in image 2 of the bug report).
+		if (last < 1) {
+			pageButtons = [1];
+			return;
+		}
 		// `pages` accumulates the dedup'd, sorted button set. The minimum
 		// the user always sees between the Previous and Next arrows is the
 		// current page, the next page (when one exists), and the last
 		// page. On top of that we still surface a small window around the
-		// current page for visual context.
+		// current page for visual context. Every value pushed is clamped
+		// to `[1, last]` defensively so an out-of-range current page (e.g.
+		// a stale `pageIndex` waiting for the next remote reload to
+		// settle) cannot resurface a page-0 button.
 		// eslint-disable-next-line svelte/prefer-svelte-reactivity
 		const pages = new Set<number>();
 		const windowStart = Math.max(1, Math.min(current - 2, last - 4));
 		for (let i = windowStart; i < windowStart + 5 && i <= last; i++) {
 			pages.add(i);
 		}
-		pages.add(current);
-		if (current + 1 <= last) {
-			pages.add(current + 1);
+		if (current >= 1 && current <= last) {
+			pages.add(current);
+			if (current + 1 <= last) {
+				pages.add(current + 1);
+			}
 		}
 		pages.add(last);
 		pageButtons = [...pages].sort((a, b) => a - b);

package/dist/Components/Table/Types/Columns/JSONTableLayout.d.ts

@@ -30,6 +30,13 @@ export interface JSONTableLayout {
      * `userResized` so the grid renders the fixed track.
      */
     sizing: ColumnSizingState;
+    /**
+     * Records-per-page selection that was active when the layout was
+     * captured. Optional for backwards compatibility - older snapshots
+     * predate this field and `_applyLayout` simply leaves the live
+     * pagination unchanged when it is absent.
+     */
+    pageSize?: number;
 }
 /**
  * Schema version for the persisted `JSONTableLayout` envelope. Bump when

package/dist/Components/Table/Types/Columns/JSONTableLayout.js

@@ -30,6 +30,12 @@ export function isJSONTableLayout(raw) {
     if (!isPrimitiveRecord(candidate.sizing, (v) => typeof v === 'number')) {
         return false;
     }
+    if (candidate.pageSize !== undefined &&
+        (typeof candidate.pageSize !== 'number' ||
+            !Number.isFinite(candidate.pageSize) ||
+            candidate.pageSize <= 0)) {
+        return false;
+    }
     return isJSONPinningState(candidate.pinning);
 }
 /** Validates a plain (non-array) object whose values all satisfy `valueGuard`. */

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

@@ -313,14 +313,12 @@ export class SelectionState {
             : Math.min(pageEndIndexRaw, sortedDataLength);
         return { pageStartIndex, pageEndIndexExclusive };
     }
-    allSelectedBySelectableMethod(pageStartIndex, pageEndIndexExclusive, selectableMethod) {
-        const sortedData = this._deps.getSortedData();
+    allSelectedBySelectableMethod(pageItems, selectableMethod) {
         const emptyPromise = new Promise(() => undefined);
         if (selectableMethod) {
             const pending = [];
-            for (let i = pageStartIndex; i < pageEndIndexExclusive; i++) {
-                const item = sortedData[i];
-                const relIdx = i - pageStartIndex;
+            for (let relIdx = 0; relIdx < pageItems.length; relIdx++) {
+                const item = pageItems[relIdx];
                 const raw = this.cachedKey(item);
                 const checkUnselected = (key) => {
                     const selectable = selectableMethod(item, relIdx);
@@ -349,8 +347,8 @@ export class SelectionState {
         }
         else {
             const pending = [];
-            for (let i = pageStartIndex; i < pageEndIndexExclusive; i++) {
-                const raw = this.cachedKey(sortedData[i]);
+            for (let i = 0; i < pageItems.length; i++) {
+                const raw = this.cachedKey(pageItems[i]);
                 if (raw instanceof Promise) {
                     pending.push(raw.then((key) => !this._selectedItems.has(key)));
                 }
@@ -378,17 +376,22 @@ export class SelectionState {
         if (this._selectedItems.size === 0) {
             return false;
         }
-        // Subscribe to sortedData + pagination window so the derived
-        // recomputes when the page shifts (mirrors the pre-extraction
-        // `void this.paginationRepo?.pageStartIndex` reads).
-        void this._deps.getSortedData();
-        void this._deps.getPageStartIndex();
-        void this._deps.getPageEndIndexExclusive();
-        const { pageStartIndex, pageEndIndexExclusive } = this.getPageWindow();
+        // Subscribe to currentPageData so the derived recomputes when the
+        // page shifts. `currentPageData` already accounts for the active
+        // pagination mode: for Local pagination it's the sortedData slice
+        // for the current page; for Remote pagination it's the
+        // repository's data array (which IS only the current page).
+        // Iterating it directly avoids the page-2+ remote-pagination bug
+        // where absolute `pageStartIndex` indices read undefined entries
+        // from the page-sized `sortedData` array.
+        const pageItems = this._deps.getCurrentPageData();
+        if (pageItems.length === 0) {
+            return false;
+        }
         const selectableMethod = this._deps
             .getColumnDefs()
             .find((it) => it instanceof RowSelectionDef)?.isSelectable;
-        const result = this.allSelectedBySelectableMethod(pageStartIndex, pageEndIndexExclusive, selectableMethod);
+        const result = this.allSelectedBySelectableMethod(pageItems, selectableMethod);
         if (result instanceof Promise) {
             result
                 .then((flag) => {
@@ -406,9 +409,14 @@ export class SelectionState {
      * `isSelectable` guard is added to the selection map.
      */
     selectAllInCurrentPage = async () => {
-        void this._deps.getPageStartIndex();
-        const sortedData = this._deps.getSortedData();
-        const { pageStartIndex, pageEndIndexExclusive } = this.getPageWindow();
+        // Use `currentPageData` rather than absolute indices into
+        // `sortedData`: for Remote pagination `sortedData` only contains
+        // the current page's rows but `pageStartIndex` is still the
+        // absolute index (e.g. 20 for page 2), so iterating from
+        // `pageStartIndex` would read undefined entries and silently no-op
+        // for page 2 onwards. `currentPageData` is always the visible
+        // page, regardless of pagination mode.
+        const pageItems = this._deps.getCurrentPageData();
         // Mutate in place to preserve SvelteMap per-key reactivity AND
         // to honour `setSelectionMap()` - if the consumer replaced the
         // slot wholesale, we mutate THAT map rather than allocating a
@@ -416,8 +424,8 @@ export class SelectionState {
         const sel = this._selectedItems;
         const pending = [];
         if (this.allSelectedInCurrentPage) {
-            for (let i = pageStartIndex; i < pageEndIndexExclusive; i++) {
-                const raw = this.cachedKey(sortedData[i]);
+            for (let i = 0; i < pageItems.length; i++) {
+                const raw = this.cachedKey(pageItems[i]);
                 if (raw instanceof Promise) {
                     pending.push(raw.then((key) => {
                         sel.delete(key);
@@ -433,9 +441,8 @@ export class SelectionState {
                 .getColumnDefs()
                 .find((it) => it instanceof RowSelectionDef)?.isSelectable;
             if (selectableMethod) {
-                for (let i = pageStartIndex; i < pageEndIndexExclusive; i++) {
-                    const item = sortedData[i];
-                    const relIdx = i - pageStartIndex;
+                for (let relIdx = 0; relIdx < pageItems.length; relIdx++) {
+                    const item = pageItems[relIdx];
                     const s = selectableMethod(item, relIdx);
                     const doSet = (ok) => {
                         if (!ok) {
@@ -456,8 +463,8 @@ export class SelectionState {
                 }
             }
             else {
-                for (let i = pageStartIndex; i < pageEndIndexExclusive; i++) {
-                    const item = sortedData[i];
+                for (let i = 0; i < pageItems.length; i++) {
+                    const item = pageItems[i];
                     const raw = this.cachedKey(item);
                     if (raw instanceof Promise) {
                         pending.push(raw.then((key) => {
@@ -484,14 +491,16 @@ export class SelectionState {
         if (this._selectedItems.size === 0) {
             return;
         }
-        const sortedData = this._deps.getSortedData();
-        const { pageStartIndex, pageEndIndexExclusive } = this.getPageWindow();
+        // Use `currentPageData` for the same reason as
+        // `selectAllInCurrentPage`: it is always the visible page
+        // regardless of pagination mode.
+        const pageItems = this._deps.getCurrentPageData();
         // Build key -> item map for the current page (O(page_size) extractions)
         // eslint-disable-next-line svelte/prefer-svelte-reactivity
         const pageKeyMap = new Map();
         const pending = [];
-        for (let i = pageStartIndex; i < pageEndIndexExclusive; i++) {
-            const item = sortedData[i];
+        for (let i = 0; i < pageItems.length; i++) {
+            const item = pageItems[i];
             const raw = this.cachedKey(item);
             if (raw instanceof Promise) {
                 pending.push(raw.then((key) => {

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

@@ -116,10 +116,11 @@ export declare class TableContext<T extends object, RowIdType extends Primitive>
      */
     private _layoutPersistTimer;
     /**
-     * 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`.
+     * Pending debounce timer for the filter dirty-tracking pass. Filters
+     * do NOT persist across page refresh (see the boot chain) so the
+     * trailing callback only updates the in-memory `viewState` dirty
+     * flag; no localStorage write happens here. Name retained for parity
+     * with `_layoutPersistTimer`.
      */
     private _filterPersistTimer;
     private _paginationRepo;
@@ -812,24 +813,6 @@ export declare class TableContext<T extends object, RowIdType extends Primitive>
      * corresponding step rather than crashing.
      */
     private _applyFilter;
-    /**
-     * 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`.
-     */
-    private _hydrateFilter;
-    /**
-     * 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.
-     */
-    private _hydrateActiveFilterView;
     /**
      * Re-point `_filterBaseline` at the active filter view's saved
      * filter. The filter counterpart of `_reconcileBaselineForActiveView`:

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

@@ -449,20 +449,17 @@ export class TableContext {
                 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.
+        // Track FILTER dirtiness against the active-filter-view baseline
+        // without persisting anything. Filters are intentionally
+        // session-scoped: they reset on page navigation / refresh so the
+        // user always starts from the Default filter view and an empty
+        // quick-filter row, matching the user's mental model of "filters
+        // are an in-page action". Only the dirty-flag is updated so the
+        // view-picker chip still surfaces an unsaved active filter.
         //
-        // 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.
+        // (We deliberately do NOT call `persistFilter` /
+        // `persistActiveFilterView` here; layouts persist, filters do
+        // not.)
         $effect(() => {
             const snapshot = this._captureFilter();
             if (!this._layoutHydrated) {
@@ -473,7 +470,6 @@ export class TableContext {
             }
             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. The baseline can be a
                 // filter parsed from a backend JSON column (arbitrary key
@@ -483,7 +479,6 @@ export class TableContext {
                 const differs = this._filterBaseline !== undefined &&
                     stableStringify(snapshot) !== stableStringify(this._filterBaseline);
                 this._viewState.markDirty('filter', differs);
-                this._persistActiveFilterView();
             }, FILTER_PERSIST_DEBOUNCE_MS);
         });
         if (browser) {
@@ -520,10 +515,15 @@ export class TableContext {
                 // 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();
+                // Filters intentionally do NOT survive page refresh /
+                // navigation - the live working copy is reset to the
+                // Default filter view on every mount. Drop any
+                // stale persisted slot left by older builds so an
+                // older deploy never resurfaces filters the user
+                // thought were cleared. Layout persistence is
+                // untouched.
+                this._preferences.clearFilter();
+                this._preferences.clearActiveFilterView();
                 // 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
@@ -531,9 +531,6 @@ export class TableContext {
                 // 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
@@ -566,10 +563,11 @@ export class TableContext {
      */
     _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`.
+     * Pending debounce timer for the filter dirty-tracking pass. Filters
+     * do NOT persist across page refresh (see the boot chain) so the
+     * trailing callback only updates the in-memory `viewState` dirty
+     * flag; no localStorage write happens here. Name retained for parity
+     * with `_layoutPersistTimer`.
      */
     _filterPersistTimer = undefined;
     _paginationRepo = $state();
@@ -1964,11 +1962,20 @@ export class TableContext {
                 sizing[def.id] = def.width;
             }
         }
+        // Capture the current records-per-page selection so applying a
+        // saved layout also restores its page size, and so a drag-resize
+        // or visibility change auto-persists a layout that still reflects
+        // the user's current page size. Reading `paginationState.pageSize`
+        // also subscribes the auto-persist effect to page-size changes -
+        // without it the new size would only land in localStorage on the
+        // next layout mutation.
+        const pageSize = this.paginationRepo?.paginationState.pageSize;
         return {
             columnOrder,
             visibility: { ...this.columnVisibility },
             pinning,
             sizing,
+            ...(pageSize !== undefined ? { pageSize } : {}),
         };
     }
     /**
@@ -2038,6 +2045,18 @@ export class TableContext {
             }
         }
         this.columnPinning = adaptJSONPinningState(layout.pinning);
+        // Restore the saved records-per-page selection. Optional in the
+        // snapshot for backwards compatibility - older saves predate the
+        // field; leave the live pagination untouched in that case.
+        // Guarded against a no-op set (the setter is idempotent but
+        // the localStorage write-through inside `paginationState =` would
+        // still fire) so a hydration that matches the live value stays
+        // silent.
+        if (layout.pageSize !== undefined &&
+            this.paginationRepo &&
+            this.paginationRepo.paginationState.pageSize !== layout.pageSize) {
+            this.paginationRepo.setPageSize(layout.pageSize);
+        }
     }
     /**
      * Boot-time hydration. Reads the auto-saved live-layout snapshot and
@@ -2235,39 +2254,13 @@ export class TableContext {
             }
         }
     }
-    /**
-     * 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);
-    }
+    // Boot-time filter hydration helpers used to live here as
+    // `_hydrateFilter` / `_hydrateActiveFilterView`. Filters now reset to
+    // the Default view on every mount (see the boot chain in the
+    // constructor, which calls `clearFilter` / `clearActiveFilterView`),
+    // so neither helper is called anymore. The reconcile/apply machinery
+    // below is still used by `applyDatatableView` and `resetToDefault`,
+    // which run during a live session - they have not been removed.
     /**
      * Re-point `_filterBaseline` at the active filter view's saved
      * filter. The filter counterpart of `_reconcileBaselineForActiveView`:

package/dist/Components/Table/Types/DataRepository/BuiltInRemoteRepository.svelte.d.ts

@@ -68,6 +68,13 @@ export declare class BuiltInRemoteRepository<TRow extends object> extends TableD
     readonly setFilterMode: (id: string, mode: FilterMode | undefined) => void;
     readonly filterBy: (id: string, value: unknown) => void;
     readonly resetFilters: () => void;
+    /**
+     * Reset the current page to page 1 without touching `pageSize`. Used
+     * by every filter-mutation entrypoint so a fresh filter never leaves
+     * the user stranded on a page index that no longer exists once the
+     * remote re-query returns a smaller result set.
+     */
+    private resetToFirstPage;
     /** Jumps to the given 1-based page number, clamped at >= 1. */
     readonly setPage: (page: number) => void;
     /** Advances to the next page. */

package/dist/Components/Table/Types/DataRepository/BuiltInRemoteRepository.svelte.js

@@ -74,17 +74,14 @@ export class BuiltInRemoteRepository extends TableDataRepository {
     constructor(_options) {
         super(_options.tableName, _options.getUserId);
         this._options = _options;
-        // Restore persisted page size if present.
-        if (browser) {
-            const userId = this.getUserId() ?? 'anon';
-            const saved = localStorage.getItem(`scoria-table:${userId}:${_options.tableName}:page-size`);
-            if (saved !== null) {
-                const parsed = Number.parseInt(saved, 10);
-                if (Number.isFinite(parsed) && parsed > 0) {
-                    this.paginationState = { pageIndex: 0, pageSize: parsed };
-                }
-            }
-            else if (_options.pageSize) {
+        // The base-class constructor already restores the persisted
+        // records-per-page selection. Apply the caller-supplied default
+        // ONLY when nothing is persisted; otherwise an explicit
+        // `pageSize` option would silently overwrite the user's saved
+        // choice on every mount.
+        if (browser && _options.pageSize) {
+            const saved = localStorage.getItem(`scoria-table:${this.getUserId() ?? 'anon'}:${_options.tableName}:page-size`);
+            if (saved === null) {
                 this.paginationState = { pageIndex: 0, pageSize: _options.pageSize };
             }
         }
@@ -101,6 +98,7 @@ export class BuiltInRemoteRepository extends TableDataRepository {
         else {
             this._filterModes.set(id, mode);
         }
+        this.resetToFirstPage();
         this.scheduleReload();
     };
     filterBy = (id, value) => {
@@ -121,12 +119,32 @@ export class BuiltInRemoteRepository extends TableDataRepository {
             }
         }
         this._filtering = next;
+        // Any filter change should drop the user back on page 1; otherwise
+        // when typing in a filter while on page 2+ the new (smaller) result
+        // set leaves the pagination on an out-of-range page index and the
+        // table renders empty until the user manually navigates back.
+        this.resetToFirstPage();
         this.scheduleReload();
     };
     resetFilters = () => {
         this._filtering = [];
+        this.resetToFirstPage();
         this.scheduleReload();
     };
+    /**
+     * Reset the current page to page 1 without touching `pageSize`. Used
+     * by every filter-mutation entrypoint so a fresh filter never leaves
+     * the user stranded on a page index that no longer exists once the
+     * remote re-query returns a smaller result set.
+     */
+    resetToFirstPage() {
+        if (this.paginationState.pageIndex !== 0) {
+            this.paginationState = {
+                ...this.paginationState,
+                pageIndex: 0,
+            };
+        }
+    }
     /** Jumps to the given 1-based page number, clamped at >= 1. */
     setPage = (page) => {
         this.paginationState = {
@@ -217,7 +235,7 @@ export class BuiltInRemoteRepository extends TableDataRepository {
             const transformed = this._applyResponseTransform(raw);
             this._data = [...transformed.rows];
             this._totalRows = transformed.totalRows;
-            this._lastPage = Math.max(0, Math.ceil(transformed.totalRows / this.paginationState.pageSize) - 1);
+            this._lastPage = Math.max(1, Math.ceil(transformed.totalRows / this.paginationState.pageSize));
         }
         catch (e) {
             if (e.name === 'AbortError') {
@@ -472,7 +490,7 @@ export class CustomRemoteRepository extends TableDataRepository {
             }
             this._data = [...response.rows];
             this._totalRows = response.totalRows;
-            this._lastPage = Math.max(0, Math.ceil(response.totalRows / this.paginationState.pageSize) - 1);
+            this._lastPage = Math.max(1, Math.ceil(response.totalRows / this.paginationState.pageSize));
         }
         catch (e) {
             if (e.name === 'AbortError') {

package/dist/Components/Table/Types/DataRepository/LocalTableDataRepository.svelte.d.ts

@@ -76,6 +76,12 @@ export declare class LocalTableDataRepository<T extends object> extends TableDat
      * `filterByDebounced` helper here.
      */
     readonly filterBy: (id: string, value: unknown) => void;
+    /**
+     * Reset the current page to page 1 without touching `pageSize`. Used
+     * by every filter-mutation entrypoint so a fresh filter never leaves
+     * the user stranded on a page that no longer exists.
+     */
+    private resetToFirstPage;
     private _pageStartIndex;
     /** Index of the first row on the current page. */
     get pageStartIndex(): number;
@@ -85,9 +91,15 @@ export declare class LocalTableDataRepository<T extends object> extends TableDat
     /** Clears every active filter value (keeps filter modes intact). */
     readonly resetFilters: () => void;
     /**
-     * Sets the page size and clamps the current page index so the new
-     * page count covers the current view. Accepts a string so a raw
-     * `<select>` value can be passed through without parsing first.
+     * Sets the page size and resets the page index to 0 (page 1). A
+     * page-size change is a "show me the start of the list at this
+     * density" action; clamping the previous page index forward instead
+     * (e.g. page 5 of size 20 -> page 5 of size 100) leaves the user on
+     * an arbitrary window of the new page-sized result, which does not
+     * match the user's mental model.
+     *
+     * Accepts a string so a raw `<select>` value can be passed through
+     * without parsing first.
      */
     setPageSize: (size: number | string) => void;
     /** Jumps to the given 1-based page number, clamped to the last page. */

package/dist/Components/Table/Types/DataRepository/LocalTableDataRepository.svelte.js

@@ -133,6 +133,10 @@ export class LocalTableDataRepository extends TableDataRepository {
             }
             this._filterModes.delete(id);
         }
+        // Changing the active filter mode can change which rows are
+        // included; reset to page 1 so the user is not stranded on a
+        // now-empty page.
+        this.resetToFirstPage();
     };
     /**
      * Sets or updates the filter value for a column. Empty values are
@@ -180,7 +184,25 @@ export class LocalTableDataRepository extends TableDataRepository {
             }
         }
         this.filtering = newFiltering;
+        // Any filter change should drop the user back on page 1; otherwise
+        // when typing in a filter while on page 2+ the new (smaller) result
+        // set leaves the pagination on an out-of-range page index and the
+        // table renders empty until the user manually navigates back.
+        this.resetToFirstPage();
     };
+    /**
+     * Reset the current page to page 1 without touching `pageSize`. Used
+     * by every filter-mutation entrypoint so a fresh filter never leaves
+     * the user stranded on a page that no longer exists.
+     */
+    resetToFirstPage() {
+        if (this.paginationState.pageIndex !== 0) {
+            this.paginationState = {
+                ...this.paginationState,
+                pageIndex: 0,
+            };
+        }
+    }
     _pageStartIndex = $derived(this.paginationState.pageIndex * this.paginationState.pageSize);
     /** Index of the first row on the current page. */
     get pageStartIndex() {
@@ -194,11 +216,18 @@ export class LocalTableDataRepository extends TableDataRepository {
     /** Clears every active filter value (keeps filter modes intact). */
     resetFilters = () => {
         this.filtering = [];
+        this.resetToFirstPage();
     };
     /**
-     * Sets the page size and clamps the current page index so the new
-     * page count covers the current view. Accepts a string so a raw
-     * `<select>` value can be passed through without parsing first.
+     * Sets the page size and resets the page index to 0 (page 1). A
+     * page-size change is a "show me the start of the list at this
+     * density" action; clamping the previous page index forward instead
+     * (e.g. page 5 of size 20 -> page 5 of size 100) leaves the user on
+     * an arbitrary window of the new page-sized result, which does not
+     * match the user's mental model.
+     *
+     * Accepts a string so a raw `<select>` value can be passed through
+     * without parsing first.
      */
     setPageSize = (size) => {
         if (typeof size === 'string') {
@@ -208,10 +237,9 @@ export class LocalTableDataRepository extends TableDataRepository {
             console.warn('page size is nan');
             return;
         }
-        const lastIndex = Math.ceil(this._dataRef.value.length / size) - 1;
         this.paginationState = {
             pageSize: size,
-            pageIndex: Math.max(0, Math.min(this.paginationState.pageIndex, lastIndex)),
+            pageIndex: 0,
         };
     };
     /** Jumps to the given 1-based page number, clamped to the last page. */

package/dist/Components/Table/Types/DataRepository/TableDataRepository.svelte.js

@@ -13,6 +13,22 @@ export class TableDataRepository {
     constructor(tableName, getUserId) {
         this.tableName = tableName;
         this.getUserId = getUserId;
+        // Restore the persisted records-per-page selection. The setter
+        // writes through to localStorage on every change, but without this
+        // load the next mount would always snap back to the hardcoded 20
+        // default. Done in the base class so every concrete repository
+        // (local + every remote variant) gets the same behaviour for free.
+        // Browser-only: SSR has no localStorage and the setter's
+        // write-through is similarly guarded.
+        if (browser) {
+            const saved = localStorage.getItem(`scoria-table:${this.getUserId() ?? 'anon'}:${this.tableName}:page-size`);
+            if (saved !== null) {
+                const parsed = Number.parseInt(saved, 10);
+                if (Number.isFinite(parsed) && parsed > 0) {
+                    this._paginationState = { pageIndex: 0, pageSize: parsed };
+                }
+            }
+        }
     }
     _paginationState = $state({
         pageIndex: 0,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lavalogic/scoria",
   "description": "Svelte components used for the FloWMS Web Frontend",
-  "version": "0.38.13",
+  "version": "0.38.15",
   "publishConfig": {
     "access": "restricted"
   },