@svgrid/enterprise 3.1.1 → 3.1.2

package/dist/designer/assets/validate-YxSrBF1H.js

@@ -0,0 +1 @@
+import{n as e}from"./server-block-cache-CXJKkJpy.js";var t=10,n=1e3,r=`https://svgrid.com/docs/getting-started/3-data-and-columns/`;function i(e,t=[]){for(let n of e)n.columns?.length?i(n.columns,t):t.push(n);return t}function a(a){let s=[],c=i(a.columns??[]),l=[],u=a.data??[],d=Math.min(u.length,n);for(let n=0;n<d&&l.length<t;n+=1){let t=u[n];e(t)||l.push(t)}if(l.length&&!a.serverGroup){let e=new Set;for(let t of l)if(t&&typeof t==`object`)for(let n of Object.keys(t))e.add(n);for(let t of c){let n=t.field;if(!n||t.fieldFn||e.has(n))continue;let i=o(n,[...e]);s.push(`[svgrid] Column field "${n}" does not exist on your row data, so that column renders empty.${i?` Did you mean "${i}"?`:``} Available keys: ${[...e].slice(0,12).join(`, `)}. See ${r}`)}}let f=new Map;for(let e of c){let t=e.id??e.field;t&&f.set(t,(f.get(t)??0)+1)}for(let[e,t]of f)t>1&&s.push(`[svgrid] ${t} columns share the id "${e}". Column state (sorting, filtering, pinning, width) is keyed by id, so they will act as one. Give each an explicit \`id\`. See ${r}`);let p=a.pageable===void 0&&a.showPagination===void 0;a.pageSize!==void 0&&p&&s.push("[svgrid] `pageSize` is set but pagination was never turned on, so it has no effect and every row renders. Add `pageable` to switch the pager on."),!(a.sortable===!0||a.features?.rowSortingFeature)&&c.some(e=>e.sortable===!0)&&s.push("[svgrid] A column sets `sortable: true`, but sorting is not enabled on the grid, so its header does nothing. Add `sortable` to <SvGrid> (it registers the sorting feature for you).");let m=new Set;for(let e of c){let t=e.id??e.field;t&&m.add(t)}for(let e of a.groupBy??[]){if(m.has(e))continue;let t=o(e,[...m]);s.push(`[svgrid] \`groupBy\` refers to column "${e}", which does not exist, so that grouping level is ignored.${t?` Did you mean "${t}"?`:``} Column ids: ${[...m].slice(0,12).join(`, `)}`)}let h=a.treeData?.column;if(h&&!m.has(h)&&s.push(`[svgrid] \`treeData.column\` refers to column "${h}", which does not exist, so the expander falls back to the first visible column.`),l.length&&a.treeData){let e=new Set;for(let t of l)if(t&&typeof t==`object`)for(let n of Object.keys(t))e.add(n);let t=a.treeData.parentField;if(t&&!e.has(t)){let n=o(t,[...e]);s.push(`[svgrid] \`treeData.parentField\` is "${t}", which is not on your row data, so every row becomes a root and no hierarchy appears.${n?` Did you mean "${n}"?`:``}`)}let n=a.treeData.idField;n&&!e.has(n)&&s.push(`[svgrid] \`treeData.idField\` is "${n}", which is not on your row data, so parent lookups cannot match and the tree stays flat.`)}return a.gantt&&a.treeData&&s.push("[svgrid] `gantt` and `treeData` are both set. The Gantt builds its own work-breakdown tree from `gantt.parentField` and needs every descendant row, but `treeData` hides collapsed children from the view, so summary bars will under-report. Remove `treeData` and set `gantt.parentField` instead."),(a.initialColumnPinning?.left?.length??0)+(a.initialColumnPinning?.right?.length??0)>0&&a.columnVirtualization!==!1&&s.push("[svgrid] `initialColumnPinning` is set while column virtualization is on (its default), so the pinned columns will not stick - the virtualizer recycles column nodes. Add `columnVirtualization={false}`."),a.externalPagination===!0&&a.rowCount===void 0&&s.push("[svgrid] `externalPagination` is on but `rowCount` is not set, so the pager cannot know how many pages exist. Pass the server total as `rowCount`."),a.externalSort===!0&&!a.onSortingChange&&s.push("[svgrid] `externalSort` is on but there is no `onSortingChange` handler, so clicking a header changes nothing - the grid stopped sorting and nobody is listening. Add `onSortingChange` and re-fetch in your handler."),a.externalFilter===!0&&!a.onFiltersChange&&s.push("[svgrid] `externalFilter` is on but there is no `onFiltersChange` handler, so filtering the grid changes nothing. Add `onFiltersChange` and re-fetch in your handler."),s}function o(e,t){let n,r=1/0;for(let i of t){let t=s(e.toLowerCase(),i.toLowerCase());t<r&&(r=t,n=i)}let i=Math.min(3,Math.floor(e.length/3)+1);return r<=i?n:void 0}function s(e,t){if(e===t)return 0;let n=Array(t.length+1);for(let e=0;e<=t.length;e++)n[e]=e;for(let r=1;r<=e.length;r++){let i=n[0];n[0]=r;for(let a=1;a<=t.length;a++){let o=Math.min(n[a]+1,n[a-1]+1,i+(e[r-1]===t[a-1]?0:1));i=n[a],n[a]=o}}return n[t.length]}export{a as validateGridConfig};

package/dist/designer/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>SvGrid Studio - Designer</title>
-    <script type="module" crossorigin src="./assets/index-DkhD2kIe.js"></script>
+    <script type="module" crossorigin src="./assets/index-V_cMXdxt.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/rolldown-runtime-Dd_uD5pT.js">
     <link rel="modulepreload" crossorigin href="./assets/disclose-version-CIm4S9xS.js">
     <link rel="modulepreload" crossorigin href="./assets/cell-formatting-BWrW_O0n.js">

package/dist/index.d.ts

@@ -122,8 +122,8 @@ export { dismissUnlicensedNudge } from './watermark.js';
 export { showUpgradePrompt, dismissUpgradePrompt, type EnterpriseFeatureLabel, } from './upgrade-prompt.js';
 export { createPivotModel, pivotAggregators, filterCollapsedPivotRows, type PivotAggregator, type PivotAggregatorId, type PivotConfig, type PivotResult, type PivotRow, type PivotRowKind, type PivotValueConfig, } from './pivot.js';
 export { titleCase, resolveIdField, schemaToColumns, schemaToFormFields, isFieldHidden, validateField, applyComputed, validateEntity, type EntitySchema, type EntityField, type EntityFieldType, type EntityHooks, type FormFieldDescriptor, type FormLayout, type FormSection, type StudioEditorType, type StandardSchemaV1, type StandardSchemaResult, type ValidationOp, type ValidationRuleSpec, } from './schema.js';
-export { planQuery, coerce, createInMemoryDataSource, createKitDataSource, createKitHandlers, createSqlDataSource, planToSql, BUILTIN_AGGREGATORS, type QueryPlan, type PlanPredicate, type PlanOp, type PlanAggregate, type PlanOptions, type KitDataSourceOptions, type KitHandlerOptions, type KitScope, type KitHandlers, type KitMessage, type SqlDialect, type SqlPlan, type SqlExecutor, type SqlDataSourceConfig, type WritableDataSource, } from './sveltekit/index.js';
-export { createServerRowModel, serverRowModelRows, serverRowModelNav, serverGroupText, defaultServerGroupMessages, resolveServerGroupMessages, type ServerGroupMessages, GRAND_TOTAL_ROW_ID, GROUP_TOTAL_ROW_ID_PREFIX, type ServerRowModel, type ServerRowModelOptions, type ServerRowModelState, type ServerRowModelGridRow, type ServerRowModelDisplayRow, type ServerLevelParams, type ServerLevelState, type RefreshOptions, type ServerTransaction, type ServerTransactionResult, type ServerTransactionStatus, type ServerRowModelPaginationOptions, type ServerRowModelPagination, createServerSelectionModel, buildPivotResultColumns, type PivotResultColumnOptions, adaptCallbackDatasource, toCallbackDatasource, fromCallbackRequest, toCallbackRequest, fromCallbackFilterModel, toCallbackFilterModel, fromCallbackSelectionState, toCallbackSelectionState, isCallbackSelectionState, type CallbackSelectionState, type CallbackGroupSelectionState, type SelectionStateMapping, type CallbackServerRequest, type CallbackColumnFilter, type CallbackGetRowsParams, type CallbackDatasource, type ServerSelectionModel, type ServerSelectionModelOptions, type ServerSelectionState, type ServerGroupSelectionNode, type ServerSelectionGroupMode, createServerGroupModel, serverGroupRows, serverGroupNav, enableServerRowModel, SvGroupCell, SvRowGroupPanel, type ServerGroupController, type ServerGroupControllerOptions, type ServerGroupState, type ServerGroupGridRow, } from './server/index.js';
+export { planQuery, coerce, createInMemoryDataSource, createKitDataSource, createKitHandlers, createSqlDataSource, planToSql, BUILTIN_AGGREGATORS, type QueryPlan, type PlanPredicate, type PlanOp, type PlanAggregate, type PlanOptions, type KitDataSourceOptions, type KitHandlerOptions, type KitScope, type KitHandlers, type KitMessage, type SqlDialect, type SqlPlan, type SqlExecutor, type SqlDataSourceConfig, type WritableDataSource, type InMemoryDataSourceOptions, } from './sveltekit/index.js';
+export { createServerRowModel, serverRowModelRows, serverRowModelNav, serverGroupText, defaultServerGroupMessages, resolveServerGroupMessages, type ServerGroupMessages, GRAND_TOTAL_ROW_ID, GROUP_TOTAL_ROW_ID_PREFIX, type ServerRowModel, type ServerRowModelOptions, type ServerRowModelState, type ServerRowModelGridRow, type ServerRowModelDisplayRow, type ServerLevelParams, type ServerLevelState, type RefreshOptions, type ServerTransaction, type ServerTransactionResult, type ServerTransactionStatus, type ServerRowModelPaginationOptions, type ServerRowModelPagination, createServerSelectionModel, buildPivotResultColumns, type PivotResultColumnOptions, adaptCallbackDatasource, toCallbackDatasource, fromCallbackRequest, toCallbackRequest, fromCallbackFilterModel, toCallbackFilterModel, fromCallbackSelectionState, toCallbackSelectionState, isCallbackSelectionState, type CallbackSelectionState, type CallbackGroupSelectionState, type SelectionStateMapping, type CallbackServerRequest, type CallbackColumnFilter, type CallbackGetRowsParams, type CallbackDatasource, type ServerSelectionModel, type ServerSelectionModelOptions, type ServerSelectionState, type ServerGroupSelectionNode, type ServerSelectionGroupMode, createServerGroupModel, serverGroupRows, serverGroupNav, createWorkerDataSource, type WorkerDataSource, type WorkerDataSourceOptions, type WorkerLike, enableServerRowModel, SvGroupCell, SvRowGroupPanel, type ServerGroupController, type ServerGroupControllerOptions, type ServerGroupState, type ServerGroupGridRow, } from './server/index.js';
 export { createSupabaseDataSource, createRestDataSource, offsetLimitAdapter, dummyJsonAdapter, jsonServerAdapter, introspectSupabaseTable, listSupabaseTables, createSupabaseRealtime, createRelationLookup, createSupabaseAuth, aggregateRows, chartFieldsFromSchema, normalizeFilters, buildEntitySchema, pickLabelField, linkRelationLabels, type SupabaseDataSourceConfig, type SupabaseClientLike, type RestDataSourceConfig, type RestAdapter, type OffsetLimitOptions, type IntrospectSupabaseOptions, type IntrospectedColumn, type ColumnReference, type NormalizedFilter, type NormalizedPredicate, type SupabaseRealtimeConfig, type SupabaseRealtimeClientLike, type SupabaseRealtimeHandle, type RealtimeChannelLike, type RealtimeChange, type RelationLookup, type RelationLookupConfig, type RelationOption, type SupabaseAuthConfig, type SupabaseAuthController, type SupabaseAuthClientLike, type AuthState, type AuthUser, withEntityRules, withRelationLabels, reduceValue, kpiSeries, sparklinePoints, seriesDelta, formatKpiValue, dashboardFromSchema, type AggregateReduce, type AggregateRequest, type AggregateBucket, type AggregateSource, type DashboardSpec, type DashboardWidget, type KpiWidget, type ChartWidget, type RelationLabelConfig, } from './sources/index.js';
 export { buildInitialValues, controlKind, editMode, evalValidationRules, fieldState, sectionVisible, hasFieldConditions, rowId, stripHiddenValues, toSubmitValues, validateAll, visibleFormFields, type EditMode, type ControlKind, type FieldState, } from './edit-panel.js';
 export { default as SvGridEditPanel } from './SvGridEditPanel.svelte';

package/dist/index.js

@@ -151,7 +151,7 @@ export { titleCase, resolveIdField, schemaToColumns, schemaToFormFields, isField
 export { planQuery, coerce, createInMemoryDataSource, createKitDataSource, createKitHandlers, createSqlDataSource, planToSql, BUILTIN_AGGREGATORS, } from './sveltekit/index.js';
 // Server-Side Row Model: lazy server-side grouping and tree data over the
 // free grid's datasource contract. Also available as '@svgrid/enterprise/server'.
-export { createServerRowModel, serverRowModelRows, serverRowModelNav, serverGroupText, defaultServerGroupMessages, resolveServerGroupMessages, GRAND_TOTAL_ROW_ID, GROUP_TOTAL_ROW_ID_PREFIX, createServerSelectionModel, buildPivotResultColumns, adaptCallbackDatasource, toCallbackDatasource, fromCallbackRequest, toCallbackRequest, fromCallbackFilterModel, toCallbackFilterModel, fromCallbackSelectionState, toCallbackSelectionState, isCallbackSelectionState, createServerGroupModel, serverGroupRows, serverGroupNav, enableServerRowModel, SvGroupCell, SvRowGroupPanel, } from './server/index.js';
+export { createServerRowModel, serverRowModelRows, serverRowModelNav, serverGroupText, defaultServerGroupMessages, resolveServerGroupMessages, GRAND_TOTAL_ROW_ID, GROUP_TOTAL_ROW_ID_PREFIX, createServerSelectionModel, buildPivotResultColumns, adaptCallbackDatasource, toCallbackDatasource, fromCallbackRequest, toCallbackRequest, fromCallbackFilterModel, toCallbackFilterModel, fromCallbackSelectionState, toCallbackSelectionState, isCallbackSelectionState, createServerGroupModel, serverGroupRows, serverGroupNav, createWorkerDataSource, enableServerRowModel, SvGroupCell, SvRowGroupPanel, } from './server/index.js';
 export { createSupabaseDataSource, createRestDataSource, offsetLimitAdapter, dummyJsonAdapter, jsonServerAdapter, introspectSupabaseTable, listSupabaseTables, createSupabaseRealtime, createRelationLookup, createSupabaseAuth, aggregateRows, chartFieldsFromSchema, normalizeFilters, buildEntitySchema, pickLabelField, linkRelationLabels, withEntityRules, withRelationLabels, reduceValue, kpiSeries, sparklinePoints, seriesDelta, formatKpiValue, dashboardFromSchema, } from './sources/index.js';
 export { buildInitialValues, controlKind, editMode, evalValidationRules, fieldState, sectionVisible, hasFieldConditions, rowId, stripHiddenValues, toSubmitValues, validateAll, visibleFormFields, } from './edit-panel.js';
 export { default as SvGridEditPanel } from './SvGridEditPanel.svelte';

package/dist/node/studio.js

@@ -16045,7 +16045,20 @@ function hasFieldConditions(schema) {
 *
 * `version.test.ts` asserts this matches `package.json`, so the two cannot drift.
 */
-var SVGRID_VERSION = "3.1.1";
+var SVGRID_VERSION = "3.1.2";
+/**
+* The version of `@svgrid/grid`, which releases on its own line: enterprise is
+* on 3.1.x while the grid is on 3.0.x.
+*
+* A scaffolded app depends on BOTH packages, and pinning the grid to this
+* package's version asked npm for `@svgrid/grid@^3.1.1`, which has never been
+* published. Every `svgrid-studio init` therefore produced an app whose very
+* next step, `npm install`, failed with ERESOLVE. Found 2026-10-05 by
+* scaffolding one and running the install.
+*
+* `version.test.ts` asserts this matches packages/grid/package.json.
+*/
+var GRID_VERSION = "3.0.8";
 //#endregion
 //#region src/studio/emit-project.ts
 var has = (blocks, kind) => blocks.some((b) => b.config.kind === kind);
@@ -20902,10 +20915,9 @@ function svelteConfig(plan) {
 /** The runtime npm deps the generated source imports, keyed by package -> range.
 *  One source of truth for package.json AND the fragment-mode dependency report. */
 function runtimeDeps(project, allSource) {
-	const svgrid = `^${SVGRID_VERSION}`;
 	const dependencies = {
-		"@svgrid/grid": svgrid,
-		"@svgrid/enterprise": svgrid
+		"@svgrid/grid": `^${GRID_VERSION}`,
+		"@svgrid/enterprise": `^${SVGRID_VERSION}`
 	};
 	if (allSource.includes("from '@supabase/supabase-js'")) dependencies["@supabase/supabase-js"] = "^2.45.0";
 	if (allSource.includes("import pg from 'pg'")) dependencies["pg"] = "^8.11.0";

package/dist/server/index.d.ts

@@ -16,6 +16,7 @@ export { adaptCallbackDatasource, toCallbackDatasource, fromCallbackRequest, toC
 export { createServerGroupModel, serverGroupRows, serverGroupNav, type ServerGroupController, type ServerGroupControllerOptions, type ServerGroupState, type ServerGroupGridRow, } from './server-group-model.js';
 export { createServerSelectionModel, type ServerSelectionModel, type ServerSelectionModelOptions, type ServerSelectionState, type ServerGroupSelectionNode, type ServerSelectionGroupMode, } from './server-selection.js';
 export { buildPivotResultColumns, type PivotResultColumnOptions, } from './server-pivot.js';
+export { createWorkerDataSource, type WorkerDataSource, type WorkerDataSourceOptions, type WorkerLike, } from './worker-data-source.js';
 export { enableServerRowModel } from './enable.js';
 export { defaultServerGroupMessages, resolveServerGroupMessages, type ServerGroupMessages, } from './messages.js';
 export { default as SvGroupCell } from './SvGroupCell.svelte';

package/dist/server/index.js

@@ -18,6 +18,7 @@ export { adaptCallbackDatasource, toCallbackDatasource, fromCallbackRequest, toC
 export { createServerGroupModel, serverGroupRows, serverGroupNav, } from './server-group-model.js';
 export { createServerSelectionModel, } from './server-selection.js';
 export { buildPivotResultColumns, } from './server-pivot.js';
+export { createWorkerDataSource, } from './worker-data-source.js';
 export { enableServerRowModel } from './enable.js';
 export { defaultServerGroupMessages, resolveServerGroupMessages, } from './messages.js';
 export { default as SvGroupCell } from './SvGroupCell.svelte';

package/dist/server/server-row-model.d.ts

@@ -169,6 +169,15 @@ export type ServerRowModelOptions<TData> = {
      * grid's pinned rows so it stays in view.
      */
     grandTotalRow?: 'top' | 'bottom' | 'pinnedTop' | 'pinnedBottom';
+    /**
+     * Milliseconds to keep the rows on screen after a sort, a filter or a
+     * regroup while the new answer loads. If its first block lands in that
+     * time, the grid goes straight from the old rows to the new ones: no
+     * frame of skeletons between them, and one update instead of two. A fast
+     * source (a worker, a local database) never shows a skeleton; a slow one
+     * shows them once the time is up. Default 0: skeletons at once.
+     */
+    keepRowsWhileLoading?: number;
     /** Drop a group's cached children when it is collapsed. Default false. */
     purgeClosedGroups?: boolean;
     /**

package/dist/server/server-row-model.js

@@ -368,10 +368,53 @@ export function createServerRowModel(source, options) {
             }
         }
     }
-    // ---------------------------------------------------------- flatten
+    const leafRuns = new WeakMap();
+    function leafRun(store, rows) {
+        if (openDetails.size)
+            return null;
+        const prev = leafRuns.get(store);
+        if (prev && prev.rows === rows)
+            return prev;
+        const n = rows.length;
+        // Same length (a block landed, a row was patched): update the kept
+        // arrays in place. The flatten only ever copies out of them.
+        const inPlace = !!prev && prev.rows.length === n;
+        const display = inPlace ? prev.display : new Array(n);
+        const grid = inPlace ? prev.grid : new Array(n);
+        const old = prev?.rows;
+        const oldLength = old ? old.length : 0;
+        for (let i = 0; i < n; i += 1) {
+            const child = rows[i];
+            if (i < oldLength && old[i] === child) {
+                if (!inPlace) {
+                    display[i] = prev.display[i];
+                    grid[i] = prev.grid[i];
+                }
+                continue;
+            }
+            const ph = rowPlaceholderState(child);
+            if (ph) {
+                const d = ph === 'failed' ? FAILED_ROW : LOADING_ROW;
+                display[i] = d;
+                grid[i] = toGridRow(d);
+                continue;
+            }
+            if (child.kind !== 'leaf') {
+                // Written in place up to here, so the kept run is no longer whole.
+                leafRuns.delete(store);
+                return null;
+            }
+            const d = { kind: 'leaf', id: child.id, level: store.level, route: store.route, data: child.data };
+            display[i] = d;
+            grid[i] = toGridRow(d, child.data);
+        }
+        const run = { rows, display, grid };
+        leafRuns.set(store, run);
+        return run;
+    }
     function flatten() {
-        const display = [];
-        const grid = [];
+        let display = [];
+        let grid = [];
         segments = [];
         const pushRow = (d, data) => {
             display.push(d);
@@ -392,6 +435,28 @@ export function createServerRowModel(source, options) {
         };
         const walk = (store, from = 0, to = Number.POSITIVE_INFINITY) => {
             const rows = store.cache.rows();
+            const run = store.loadMore ? null : leafRun(store, rows);
+            if (run) {
+                // A level of leaves maps one to one: copy the range out of the run.
+                const end = Math.min(rows.length, to);
+                if (end > from) {
+                    segments.push({ store, displayStart: display.length, storeStart: from, length: end - from });
+                    const { display: d, grid: g } = run;
+                    if (display.length === 0) {
+                        // The common flat case: the whole list is this run. A slice is a
+                        // block copy; a push per row was the rest of the flatten's cost.
+                        display = d.slice(from, end);
+                        grid = g.slice(from, end);
+                    }
+                    else {
+                        for (let i = from; i < end; i += 1) {
+                            display.push(d[i]);
+                            grid.push(g[i]);
+                        }
+                    }
+                }
+                return;
+            }
             const end = Math.min(rows.length, to, store.loadMore ? loadedPrefix(rows) : Number.POSITIVE_INFINITY);
             let segStart = from;
             let dispStart = display.length;
@@ -606,6 +671,34 @@ export function createServerRowModel(source, options) {
             pagination: pagination(),
         };
     }
+    // `keepRowsWhileLoading`: after a sort, a filter or a regroup, the rows on
+    // screen stay until the new answer's first block lands or the time runs
+    // out. `holdUntil` is that deadline, 0 when nothing is held.
+    let holdUntil = 0;
+    let holdTimer = null;
+    let held = false;
+    function holdRows() {
+        const ms = options.keepRowsWhileLoading ?? 0;
+        if (ms > 0 && current.displayRows.length > 0)
+            holdUntil = Date.now() + ms;
+    }
+    /** Whether the rows on screen should stay a little longer. */
+    function holding() {
+        if (!holdUntil)
+            return false;
+        const root = stores.get(routeKey([]));
+        // A failed block ends the hold too: its Retry is the answer to show.
+        const rootAnswered = !!root && root.cache.getCacheState().some((b) => b.status !== 'loading');
+        let pending = false;
+        for (const s of stores.values())
+            if (s.refreshPending)
+                pending = true;
+        if (Date.now() >= holdUntil || rootError || (rootAnswered && !pending)) {
+            holdUntil = 0;
+            return false;
+        }
+        return true;
+    }
     function scheduleEmit() {
         if (disposed || emitScheduled)
             return;
@@ -614,7 +707,25 @@ export function createServerRowModel(source, options) {
             emitScheduled = false;
             if (disposed)
                 return;
+            if (holding()) {
+                held = true;
+                holdTimer ?? (holdTimer = setTimeout(() => {
+                    holdTimer = null;
+                    scheduleEmit();
+                }, Math.max(0, holdUntil - Date.now())));
+                return;
+            }
+            if (holdTimer) {
+                clearTimeout(holdTimer);
+                holdTimer = null;
+            }
             current = buildState();
+            // While rows were held the grid kept reporting positions in the old
+            // list, mapped through the old segments; map them through the new.
+            if (held) {
+                held = false;
+                applyViewport();
+            }
             options.onChange?.(current);
             for (const notify of subscribers)
                 notify();
@@ -749,6 +860,7 @@ export function createServerRowModel(source, options) {
     }
     function setSort(next) {
         sortModel = next;
+        holdRows();
         for (const store of storesAffectedBySort(next)) {
             if (options.clientSideSort && sortLocally(store))
                 continue;
@@ -759,6 +871,7 @@ export function createServerRowModel(source, options) {
     }
     function setFilter(next) {
         const previous = filterModel;
+        holdRows();
         filterModel = Array.isArray(next.columns)
             ? { global: next.global, columns: toServerFilterColumns(next) }
             : next;
@@ -1212,6 +1325,7 @@ export function createServerRowModel(source, options) {
                 expanded.clear();
                 seenGroups.clear();
             }
+            holdRows();
             rebuild();
         },
         toggleGroup(row) {
@@ -1439,6 +1553,9 @@ export function createServerRowModel(source, options) {
             if (asyncTimer)
                 clearTimeout(asyncTimer);
             asyncTimer = null;
+            if (holdTimer)
+                clearTimeout(holdTimer);
+            holdTimer = null;
             asyncQueue.length = 0;
             for (const s of stores.values())
                 s.cache.dispose();

package/dist/server/worker-data-source.d.ts

@@ -0,0 +1,62 @@
+/**
+ * A `ServerDataSource` whose rows live in a Web Worker.
+ *
+ * Sorting, filtering, grouping and aggregating a few hundred thousand rows
+ * takes long enough on the main thread that scrolling and typing stop while
+ * it runs. This moves that work into a worker and lets the grid treat the
+ * worker as a server: `createServerRowModel` (or the free
+ * `createServerDataSource`) asks for one block of rows at a time, the worker
+ * answers with just that block, and the full array never crosses back.
+ *
+ * Inside the worker the requests run through `createInMemoryDataSource`, the
+ * reference implementation of the datasource contract, so the answers are the
+ * ones every other backend is tested against.
+ *
+ * ```ts
+ * // grid.worker.ts
+ * import { serveWorkerDataSource } from '@svgrid/enterprise/worker'
+ * serveWorkerDataSource({ rows: () => fetch('/orders.json').then((r) => r.json()) })
+ *
+ * // App.svelte
+ * const worker = new Worker(new URL('./grid.worker.ts', import.meta.url), { type: 'module' })
+ * const ctl = createServerRowModel(createWorkerDataSource(worker), { groupBy: ['region'] })
+ * ```
+ *
+ * What it cannot do: run your functions. A worker receives data, not code,
+ * so a column's `valueGetter`, `comparator` or custom filter function never
+ * reaches it. Sorting and filtering go by field value, as with any server.
+ */
+import type { RowData } from '@svgrid/grid';
+import type { ServerDataSource } from '@svgrid/grid/server';
+import type { EntitySchema } from '../schema.js';
+import type { AggregateBucket, AggregateRequest } from '../sources/aggregate.js';
+/** What `createWorkerDataSource` needs from a `Worker`. A `MessagePort` fits too. */
+export type WorkerLike = {
+    postMessage(message: unknown): void;
+    addEventListener(type: string, listener: (event: MessageEvent) => void): void;
+    removeEventListener(type: string, listener: (event: MessageEvent) => void): void;
+    terminate?(): void;
+};
+export type WorkerDataSourceOptions<TData extends RowData> = {
+    /**
+     * Rows to copy into the worker. Copying is structured cloning on the main
+     * thread, so for a large dataset prefer loading it inside the worker
+     * (`serveWorkerDataSource({ rows })`) and leave this out.
+     */
+    rows?: ReadonlyArray<TData>;
+    /** Sent with `rows`. Default: the worker's own, or one read off the rows. */
+    schema?: EntitySchema<TData>;
+    /** The row id field, when the schema is inferred. */
+    idField?: string;
+};
+export type WorkerDataSource<TData extends RowData> = Required<Pick<ServerDataSource<TData>, 'getRows' | 'createRow' | 'updateRow' | 'deleteRow' | 'updateWhere'>> & {
+    /** Group and reduce in the worker, for `SvSchemaChart` and dashboards. */
+    getAggregate(request: AggregateRequest): Promise<AggregateBucket[]>;
+    /** Settles once the worker holds rows: with the row count, or the loader's error. */
+    readonly ready: Promise<number>;
+    /** Replace the worker's rows. Resolves with the new count. */
+    setRows(rows: ReadonlyArray<TData>, schema?: EntitySchema<TData>): Promise<number>;
+    /** Reject what is pending and terminate the worker. The row model's `dispose()` calls it. */
+    destroy(): void;
+};
+export declare function createWorkerDataSource<TData extends RowData>(worker: WorkerLike, options?: WorkerDataSourceOptions<TData>): WorkerDataSource<TData>;

package/dist/server/worker-data-source.js

@@ -0,0 +1,133 @@
+import { CHANNEL, fromWorkerError, isChannelMessage, } from '../worker/protocol.js';
+import { nudgeServerRowModel } from './enable.js';
+function abortReason(signal) {
+    return signal.reason ?? new DOMException('The request was aborted.', 'AbortError');
+}
+export function createWorkerDataSource(worker, options = {}) {
+    nudgeServerRowModel();
+    let nextId = 1;
+    let destroyed = false;
+    // Set once the worker cannot answer any more: it failed to start, its
+    // loader threw, or `destroy()` ran. Every later call rejects with it.
+    let failure = null;
+    const pending = new Map();
+    let resolveReady;
+    let rejectReady;
+    const ready = new Promise((resolve, reject) => {
+        resolveReady = resolve;
+        rejectReady = reject;
+    });
+    // A source nobody awaited `ready` on must not raise an unhandled rejection.
+    ready.catch(() => { });
+    function failAll(error) {
+        failure ?? (failure = error);
+        rejectReady(error);
+        for (const p of pending.values())
+            p.reject(error);
+        pending.clear();
+    }
+    function onMessage(event) {
+        const message = event.data;
+        if (!isChannelMessage(message))
+            return;
+        switch (message.kind) {
+            case 'ready':
+                resolveReady(message.rowCount);
+                break;
+            case 'failed':
+                failAll(fromWorkerError(message.error));
+                break;
+            case 'result': {
+                const p = pending.get(message.id);
+                if (!p)
+                    return; // cancelled, or answered after destroy
+                pending.delete(message.id);
+                if (message.ok)
+                    p.resolve(message.value);
+                else
+                    p.reject(fromWorkerError(message.error));
+                break;
+            }
+        }
+    }
+    // The worker script failed to load or threw at the top level. Without this
+    // every request would wait forever on a worker that is not there.
+    function onError(event) {
+        const message = event.message || 'The data source worker failed to start.';
+        failAll(new Error(message));
+    }
+    worker.addEventListener('message', onMessage);
+    worker.addEventListener('error', onError);
+    worker.start?.();
+    function send(message) {
+        worker.postMessage(message);
+    }
+    function request(message, signal) {
+        if (failure)
+            return Promise.reject(failure);
+        if (signal?.aborted)
+            return Promise.reject(abortReason(signal));
+        const id = nextId++;
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                if (!pending.delete(id))
+                    return;
+                send({ channel: CHANNEL, kind: 'cancel', id });
+                reject(abortReason(signal));
+            };
+            pending.set(id, {
+                resolve: (value) => {
+                    signal?.removeEventListener('abort', onAbort);
+                    resolve(value);
+                },
+                reject: (error) => {
+                    signal?.removeEventListener('abort', onAbort);
+                    reject(error);
+                },
+            });
+            signal?.addEventListener('abort', onAbort, { once: true });
+            send(message(id));
+        });
+    }
+    function call(method, args, signal) {
+        return request((id) => ({ channel: CHANNEL, kind: 'call', id, method, args }), signal);
+    }
+    function load(rows, schema) {
+        return request((id) => ({
+            channel: CHANNEL,
+            kind: 'load',
+            id,
+            rows,
+            ...(schema ? { schema: schema } : {}),
+            ...(options.idField ? { idField: options.idField } : {}),
+        }));
+    }
+    if (options.rows)
+        void load(options.rows, options.schema).catch(failAll);
+    return {
+        getRows(req) {
+            // The signal cannot be cloned, and `parentRow` / `context` are app
+            // objects the in-memory source never reads; sending them would only
+            // risk a DataCloneError.
+            const { signal, parentRow: _parentRow, context: _context, ...plain } = req;
+            return call('getRows', [plain], signal);
+        },
+        createRow: (input) => call('createRow', [input]),
+        updateRow: (id, patch) => call('updateRow', [id, patch]),
+        deleteRow: (id) => call('deleteRow', [id]),
+        updateWhere: (filterModel, patch, selection) => call('updateWhere', [filterModel, patch, selection]),
+        getAggregate: (req) => call('getAggregate', [req]),
+        ready,
+        setRows: (rows, schema) => load(rows, schema ?? options.schema),
+        destroy() {
+            if (destroyed)
+                return;
+            destroyed = true;
+            failure = new Error('createWorkerDataSource: the source was destroyed');
+            failAll(failure);
+            worker.removeEventListener('message', onMessage);
+            worker.removeEventListener('error', onError);
+            worker.terminate?.();
+        },
+    };
+}

package/dist/studio/emit-project.js

@@ -3,7 +3,7 @@ import { blockColumns, blockStyleCss, blockClassName, sanitizeClassName, compone
 import { uiComponentSpec, gridApiSettableProps, STANDARD_UI_EVENTS } from './ui-components.js';
 import { isDarkTheme, themeTokenCss } from './themes.js';
 import { hasFieldConditions } from '../edit-panel.js';
-import { SVGRID_VERSION } from '../version.js';
+import { SVGRID_VERSION, GRID_VERSION } from '../version.js';
 import { emitEntityModules, homeFile, layoutFile, lookupVar, namesFor, prepareEntities, relationDisplayFields, sqlDdlFiles } from './emit-schema.js';
 const has = (blocks, kind) => blocks.some((b) => b.config.kind === kind);
 /** Per-Tabs-block active-tab state var + a stable tab id. */
@@ -5231,8 +5231,13 @@ export function runtimeDeps(project, allSource) {
     // APIs of the SvGrid it was written by, so the app must install a runtime at
     // least that new. `latest` also made a scaffold non-reproducible - an app could
     // resolve a different runtime tomorrow, or break on an unrelated publish.
-    const svgrid = `^${SVGRID_VERSION}`;
-    const dependencies = { '@svgrid/grid': svgrid, '@svgrid/enterprise': svgrid };
+    // The two packages release on separate lines, so they need separate ranges.
+    // Using this package's version for BOTH asked for `@svgrid/grid@^3.1.1`,
+    // which does not exist, and `npm install` failed on every scaffolded app.
+    const dependencies = {
+        '@svgrid/grid': `^${GRID_VERSION}`,
+        '@svgrid/enterprise': `^${SVGRID_VERSION}`,
+    };
     if (allSource.includes("from '@supabase/supabase-js'"))
         dependencies['@supabase/supabase-js'] = '^2.45.0';
     if (allSource.includes("import pg from 'pg'"))

package/dist/sveltekit/in-memory.d.ts

@@ -7,8 +7,28 @@
  */
 import type { RowData, ServerDataSource } from '@svgrid/grid';
 import { type EntitySchema } from '../schema.js';
+import { type PlanPredicate, type QueryPlan } from './query-plan.js';
 import type { WritableDataSource } from './types.js';
 import { type AggregateSource } from '../sources/aggregate.js';
-export declare function createInMemoryDataSource<TData extends RowData>(initial: ReadonlyArray<TData>, schema: EntitySchema<TData>): WritableDataSource<TData> & Required<Pick<ServerDataSource<TData>, 'updateWhere'>> & AggregateSource & {
+export declare function asString(v: unknown): string;
+export declare function matchesPredicate(row: RowData, p: PlanPredicate): boolean;
+export declare function sortRows<T extends RowData>(rows: T[], orderBy: QueryPlan['orderBy']): T[];
+export type InMemoryDataSourceOptions = {
+    /**
+     * Keep the last few filtered, sorted (and grouped) results and answer a
+     * request that differs only in its row range by slicing one, instead of
+     * filtering and sorting the whole array again. Scrolling a block-loading
+     * row model asks for the same query once per block, so on a large array
+     * this is the difference between one sort and one sort per block.
+     *
+     * Off by default because a cached result does not see a row object that
+     * was changed in place, only changes made through this source's own
+     * `createRow` / `updateRow` / `deleteRow` / `updateWhere`, which drop the
+     * cache. `createWorkerDataSource` turns it on: there the rows live in the
+     * worker and nothing else can reach them.
+     */
+    cacheResults?: boolean;
+};
+export declare function createInMemoryDataSource<TData extends RowData>(initial: ReadonlyArray<TData>, schema: EntitySchema<TData>, options?: InMemoryDataSourceOptions): WritableDataSource<TData> & Required<Pick<ServerDataSource<TData>, 'updateWhere'>> & AggregateSource & {
     rows(): ReadonlyArray<TData>;
 };