@svgrid/enterprise 3.1.0 → 3.1.2

package/dist/wc/{svelte-virtualizer.svelte-CXtQy2TQ.js → svelte-virtualizer.svelte-Du4tjrIP.js}

@@ -441,11 +441,14 @@ function D(e) {
 	}
 	return {
 		setOptions(e) {
-			let n = {
+			let r = {
 				...t,
 				...e
-			};
-			b(t, n) || (t = n, s());
+			}, i = typeof e.estimateSize == "function";
+			!i && b(t, r) || (t = r, i && (n = null), s());
+		},
+		measure() {
+			n = null, s();
 		},
 		setScrollOffset(e) {
 			(t.scrollOffset ?? 0) !== e && (t = {
@@ -516,6 +519,7 @@ function O(r) {
 			return e(a);
 		},
 		setOptions: i.setOptions,
+		measure: i.measure,
 		setScrollOffset: i.setScrollOffset,
 		setViewportHeight: i.setViewportHeight,
 		scrollToIndex: i.scrollToIndex,

package/dist/wc/{validate-BqDthkNr.js → validate-JAuMsk6Z.js}

@@ -8,69 +8,69 @@ function t(t) {
 }
 //#endregion
 //#region ../grid/dist/validate.js
-var n = 10, 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);
+var n = 10, r = 1e3, i = "https://svgrid.com/docs/getting-started/3-data-and-columns/";
+function a(e, t = []) {
+	for (let n of e) n.columns?.length ? a(n.columns, t) : t.push(n);
 	return t;
 }
-function a(e) {
-	let a = [], s = i(e.columns ?? []), c = [];
-	for (let r of e.data ?? []) {
-		if (c.length >= n) break;
-		t(r) || c.push(r);
+function o(e) {
+	let o = [], c = a(e.columns ?? []), l = [], u = e.data ?? [], d = Math.min(u.length, r);
+	for (let e = 0; e < d && l.length < n; e += 1) {
+		let n = u[e];
+		t(n) || l.push(n);
 	}
-	if (c.length && !e.serverGroup) {
+	if (l.length && !e.serverGroup) {
 		let e = /* @__PURE__ */ new Set();
-		for (let t of c) if (t && typeof t == "object") for (let n of Object.keys(t)) e.add(n);
-		for (let t of s) {
+		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]);
-			a.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 r = s(n, [...e]);
+			o.push(`[svgrid] Column field "${n}" does not exist on your row data, so that column renders empty.${r ? ` Did you mean "${r}"?` : ""} Available keys: ${[...e].slice(0, 12).join(", ")}. See ${i}`);
 		}
 	}
-	let l = /* @__PURE__ */ new Map();
-	for (let e of s) {
+	let f = /* @__PURE__ */ new Map();
+	for (let e of c) {
 		let t = e.id ?? e.field;
-		t && l.set(t, (l.get(t) ?? 0) + 1);
+		t && f.set(t, (f.get(t) ?? 0) + 1);
 	}
-	for (let [e, t] of l) t > 1 && a.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 u = e.pageable === void 0 && e.showPagination === void 0;
-	e.pageSize !== void 0 && u && a.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."), !(e.sortable === !0 || e.features?.rowSortingFeature) && s.some((e) => e.sortable === !0) && a.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 d = /* @__PURE__ */ new Set();
-	for (let e of s) {
+	for (let [e, t] of f) t > 1 && o.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 ${i}`);
+	let p = e.pageable === void 0 && e.showPagination === void 0;
+	e.pageSize !== void 0 && p && o.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."), !(e.sortable === !0 || e.features?.rowSortingFeature) && c.some((e) => e.sortable === !0) && o.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 = /* @__PURE__ */ new Set();
+	for (let e of c) {
 		let t = e.id ?? e.field;
-		t && d.add(t);
+		t && m.add(t);
 	}
 	for (let t of e.groupBy ?? []) {
-		if (d.has(t)) continue;
-		let e = o(t, [...d]);
-		a.push(`[svgrid] \`groupBy\` refers to column "${t}", which does not exist, so that grouping level is ignored.${e ? ` Did you mean "${e}"?` : ""} Column ids: ${[...d].slice(0, 12).join(", ")}`);
+		if (m.has(t)) continue;
+		let e = s(t, [...m]);
+		o.push(`[svgrid] \`groupBy\` refers to column "${t}", which does not exist, so that grouping level is ignored.${e ? ` Did you mean "${e}"?` : ""} Column ids: ${[...m].slice(0, 12).join(", ")}`);
 	}
-	let f = e.treeData?.column;
-	if (f && !d.has(f) && a.push(`[svgrid] \`treeData.column\` refers to column "${f}", which does not exist, so the expander falls back to the first visible column.`), c.length && e.treeData) {
+	let h = e.treeData?.column;
+	if (h && !m.has(h) && o.push(`[svgrid] \`treeData.column\` refers to column "${h}", which does not exist, so the expander falls back to the first visible column.`), l.length && e.treeData) {
 		let t = /* @__PURE__ */ new Set();
-		for (let e of c) if (e && typeof e == "object") for (let n of Object.keys(e)) t.add(n);
+		for (let e of l) if (e && typeof e == "object") for (let n of Object.keys(e)) t.add(n);
 		let n = e.treeData.parentField;
 		if (n && !t.has(n)) {
-			let e = o(n, [...t]);
-			a.push(`[svgrid] \`treeData.parentField\` is "${n}", which is not on your row data, so every row becomes a root and no hierarchy appears.${e ? ` Did you mean "${e}"?` : ""}`);
+			let e = s(n, [...t]);
+			o.push(`[svgrid] \`treeData.parentField\` is "${n}", which is not on your row data, so every row becomes a root and no hierarchy appears.${e ? ` Did you mean "${e}"?` : ""}`);
 		}
 		let r = e.treeData.idField;
-		r && !t.has(r) && a.push(`[svgrid] \`treeData.idField\` is "${r}", which is not on your row data, so parent lookups cannot match and the tree stays flat.`);
+		r && !t.has(r) && o.push(`[svgrid] \`treeData.idField\` is "${r}", which is not on your row data, so parent lookups cannot match and the tree stays flat.`);
 	}
-	return e.gantt && e.treeData && a.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."), (e.initialColumnPinning?.left?.length ?? 0) + (e.initialColumnPinning?.right?.length ?? 0) > 0 && e.columnVirtualization !== !1 && a.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}`."), e.externalPagination === !0 && e.rowCount === void 0 && a.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`."), e.externalSort === !0 && !e.onSortingChange && a.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."), e.externalFilter === !0 && !e.onFiltersChange && a.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."), a;
+	return e.gantt && e.treeData && o.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."), (e.initialColumnPinning?.left?.length ?? 0) + (e.initialColumnPinning?.right?.length ?? 0) > 0 && e.columnVirtualization !== !1 && o.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}`."), e.externalPagination === !0 && e.rowCount === void 0 && o.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`."), e.externalSort === !0 && !e.onSortingChange && o.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."), e.externalFilter === !0 && !e.onFiltersChange && o.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."), o;
 }
-function o(e, t) {
+function s(e, t) {
 	let n, r = Infinity;
 	for (let i of t) {
-		let t = s(e.toLowerCase(), i.toLowerCase());
+		let t = c(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) {
+function c(e, t) {
 	if (e === t) return 0;
 	let n = Array(t.length + 1);
 	for (let e = 0; e <= t.length; e++) n[e] = e;
@@ -85,4 +85,4 @@ function s(e, t) {
 	return n[t.length];
 }
 //#endregion
-export { a as validateGridConfig };
+export { o as validateGridConfig };

package/dist/worker/columnar.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The query engine behind `serveWorkerDataSource`: the in-memory reference
+ * source's answers, computed over columns instead of row objects.
+ *
+ * Each field becomes a dictionary - its distinct values, and one integer code
+ * per row - built once, in the background, while the worker is idle. Then:
+ *
+ * - A filter is decided once per DISTINCT value, with the reference's own
+ *   `matchesPredicate`, and a row passes when its code does. Searching a
+ *   million rows of 80 customers tests 80 strings.
+ * - A sort ranks the distinct values once (numerically, or with the same
+ *   collator the reference uses) and orders rows with a stable counting sort
+ *   over the ranks: integer work, linear in the row count, no string compares.
+ * - A grouping buckets rows by code and accumulates aggregates in row order,
+ *   so sums come out bit-for-bit what the reference adds up.
+ *
+ * Exact equivalence is the contract, not a goal: anything this engine does
+ * not accelerate goes to the reference source holding the same rows - the
+ * advanced filter expression, pivot, and a sort on a column that mixes
+ * numbers with other values (where the reference's comparison is not a
+ * total order, so there is no ranking to reproduce). Writes go through the
+ * reference too, and the columns are rebuilt from its rows.
+ */
+import type { RowData, ServerDataSource } from '@svgrid/grid';
+import type { EntitySchema } from '../schema.js';
+import type { AggregateBucket, AggregateRequest } from '../sources/aggregate.js';
+export type ColumnarDataSource<TData extends RowData> = Required<Pick<ServerDataSource<TData>, 'getRows' | 'createRow' | 'updateRow' | 'deleteRow' | 'updateWhere'>> & {
+    getAggregate(request: AggregateRequest): Promise<AggregateBucket[]>;
+    rows(): ReadonlyArray<TData>;
+    /**
+     * Build one more column's dictionary and ranks. Returns false once every
+     * schema field is built. `serveWorkerDataSource` calls it between requests,
+     * so the first sort on any column finds its work already done.
+     */
+    warm(): boolean;
+    /** How many requests this engine answered, and how many it handed to the reference. */
+    stats(): {
+        columnar: number;
+        reference: number;
+    };
+};
+export declare function createColumnarDataSource<TData extends RowData>(initial: ReadonlyArray<TData>, schema: EntitySchema<TData>): ColumnarDataSource<TData>;

package/dist/worker/columnar.js

@@ -0,0 +1,410 @@
+import { planQuery } from '../sveltekit/query-plan.js';
+import { asString, createInMemoryDataSource, matchesPredicate, sortRows } from '../sveltekit/in-memory.js';
+const RESULT_CACHE_SIZE = 8;
+const collator = new Intl.Collator();
+export function createColumnarDataSource(initial, schema) {
+    const reference = createInMemoryDataSource(initial, schema, { cacheResults: true });
+    let store = reference.rows();
+    let columns = new Map();
+    const cache = new Map();
+    const fields = schema.fields.map((f) => f.field);
+    // Index of the next schema field `warm()` builds.
+    let warmed = 0;
+    function invalidate() {
+        store = reference.rows();
+        columns = new Map();
+        cache.clear();
+        warmed = 0;
+    }
+    // ---- columns ------------------------------------------------------------
+    function column(field) {
+        let col = columns.get(field);
+        if (col)
+            return col;
+        const n = store.length;
+        const codes = new Uint32Array(n);
+        const values = [];
+        const index = new Map();
+        for (let i = 0; i < n; i += 1) {
+            const v = store[i][field];
+            let code = index.get(v);
+            if (code === undefined) {
+                code = values.length;
+                index.set(v, code);
+                values.push(v);
+            }
+            codes[i] = code;
+        }
+        col = { codes, values };
+        columns.set(field, col);
+        return col;
+    }
+    function ranked(col) {
+        if (col.ranks !== undefined)
+            return col.ranks;
+        const { values } = col;
+        let numbers = 0;
+        let finite = 0;
+        for (const v of values) {
+            if (typeof v === 'number') {
+                numbers += 1;
+                if (Number.isFinite(v))
+                    finite += 1;
+            }
+        }
+        // The reference compares two numbers by subtraction and anything else as
+        // text. All finite numbers, or no numbers at all, is a total order a
+        // ranking can reproduce; a mix (or NaN / Infinity) is not.
+        if (numbers > 0 && (finite !== values.length)) {
+            col.ranks = null;
+            return null;
+        }
+        const byValue = values.map((_, code) => code);
+        const text = numbers === 0 ? values.map(asString) : null;
+        const cmp = text
+            ? (a, b) => collator.compare(text[a], text[b])
+            : (a, b) => values[a] - values[b];
+        byValue.sort(cmp);
+        const ranks = new Uint32Array(values.length);
+        let rank = 0;
+        for (let i = 0; i < byValue.length; i += 1) {
+            // Values the comparison calls equal share a rank, so the stable sort
+            // keeps them in row order, as the reference's index tiebreak does.
+            if (i > 0 && cmp(byValue[i - 1], byValue[i]) !== 0)
+                rank += 1;
+            ranks[byValue[i]] = rank;
+        }
+        col.ranks = ranks;
+        col.rankCount = values.length ? rank + 1 : 0;
+        return ranks;
+    }
+    function keyed(col) {
+        if (!col.keyOf) {
+            const keyOf = new Uint32Array(col.values.length);
+            const keys = [];
+            const index = new Map();
+            col.values.forEach((v, code) => {
+                const key = asString(v);
+                let k = index.get(key);
+                if (k === undefined) {
+                    k = keys.length;
+                    index.set(key, k);
+                    keys.push(key);
+                }
+                keyOf[code] = k;
+            });
+            col.keyOf = keyOf;
+            col.keys = keys;
+        }
+        return { keyOf: col.keyOf, keys: col.keys };
+    }
+    function numbers(col) {
+        if (!col.nums) {
+            const nums = new Float64Array(col.values.length);
+            col.values.forEach((v, code) => {
+                const n = Number(v);
+                nums[code] = Number.isFinite(n) ? n : NaN;
+            });
+            col.nums = nums;
+        }
+        return col.nums;
+    }
+    // ---- filtering ----------------------------------------------------------
+    /** Row indexes passing `where` and the search, in store order. */
+    function select(where, search) {
+        const n = store.length;
+        const tests = [];
+        for (const p of where) {
+            const col = column(p.field);
+            const pass = new Uint8Array(col.values.length);
+            col.values.forEach((v, code) => {
+                pass[code] = matchesPredicate({ [p.field]: v }, p) ? 1 : 0;
+            });
+            tests.push({ codes: col.codes, pass });
+        }
+        const searched = [];
+        if (search) {
+            const term = search.term.toLowerCase();
+            for (const field of search.fields) {
+                const col = column(field);
+                const pass = new Uint8Array(col.values.length);
+                col.values.forEach((v, code) => {
+                    pass[code] = asString(v).toLowerCase().includes(term) ? 1 : 0;
+                });
+                searched.push({ codes: col.codes, pass });
+            }
+        }
+        if (tests.length === 0 && !search) {
+            const all = new Uint32Array(n);
+            for (let i = 0; i < n; i += 1)
+                all[i] = i;
+            return all;
+        }
+        const out = new Uint32Array(n);
+        let m = 0;
+        rows: for (let i = 0; i < n; i += 1) {
+            if (search) {
+                let hit = false;
+                for (const s of searched) {
+                    if (s.pass[s.codes[i]]) {
+                        hit = true;
+                        break;
+                    }
+                }
+                if (!hit)
+                    continue;
+            }
+            for (const t of tests)
+                if (!t.pass[t.codes[i]])
+                    continue rows;
+            out[m++] = i;
+        }
+        return out.slice(0, m);
+    }
+    // ---- sorting ------------------------------------------------------------
+    /** Stable counting sort of `idx` by one column; LSD over several keys. */
+    function sortIndexes(idx, orderBy) {
+        const keys = [];
+        for (const o of orderBy) {
+            const col = column(o.field);
+            const ranks = ranked(col);
+            if (!ranks)
+                return null;
+            keys.push({ codes: col.codes, ranks, count: col.rankCount, desc: o.desc });
+        }
+        let cur = idx;
+        let next = new Uint32Array(idx.length);
+        // Least significant key first: each pass is stable, so earlier keys win.
+        for (let k = keys.length - 1; k >= 0; k -= 1) {
+            const { codes, ranks, count, desc } = keys[k];
+            const counts = new Uint32Array(count + 1);
+            for (let i = 0; i < cur.length; i += 1) {
+                const r = ranks[codes[cur[i]]];
+                counts[(desc ? count - 1 - r : r) + 1] += 1;
+            }
+            for (let r = 1; r <= count; r += 1)
+                counts[r] += counts[r - 1];
+            for (let i = 0; i < cur.length; i += 1) {
+                const row = cur[i];
+                const r = ranks[codes[row]];
+                next[counts[desc ? count - 1 - r : r]++] = row;
+            }
+            const swap = cur === idx ? new Uint32Array(idx.length) : cur;
+            cur = next;
+            next = swap;
+        }
+        return cur;
+    }
+    function accumulate(idx, 
+    /** The group of the i-th row of `idx`, or null for one group. */
+    rowGroup, groupCount, aggregations) {
+        const out = new Map();
+        for (const agg of aggregations) {
+            if (out.has(agg.field))
+                continue;
+            const col = column(agg.field);
+            const codes = col.codes;
+            const nums = numbers(col);
+            const acc = {
+                count: new Float64Array(groupCount),
+                sum: new Float64Array(groupCount),
+                min: new Float64Array(groupCount).fill(Infinity),
+                max: new Float64Array(groupCount).fill(-Infinity),
+                n: new Float64Array(groupCount),
+            };
+            for (let i = 0; i < idx.length; i += 1) {
+                const row = idx[i];
+                const g = rowGroup ? rowGroup[i] : 0;
+                acc.count[g] += 1;
+                const v = nums[codes[row]];
+                if (v !== v)
+                    continue; // NaN: not a finite number
+                acc.n[g] += 1;
+                acc.sum[g] += v;
+                if (v < acc.min[g])
+                    acc.min[g] = v;
+                if (v > acc.max[g])
+                    acc.max[g] = v;
+            }
+            out.set(agg.field, acc);
+        }
+        return out;
+    }
+    /** The reference's `aggregate`, read off the accumulators. */
+    function valueOf(acc, g, fn) {
+        if (fn === 'count')
+            return acc.count[g];
+        if (acc.n[g] === 0)
+            return null;
+        switch (fn) {
+            case 'sum':
+                return acc.sum[g];
+            case 'avg':
+                return acc.sum[g] / acc.n[g];
+            case 'min':
+                return acc.min[g];
+            case 'max':
+                return acc.max[g];
+            default:
+                return null;
+        }
+    }
+    function totals(idx, plan) {
+        const aggs = plan.aggregations ?? [];
+        const acc = accumulate(idx, null, 1, aggs);
+        const out = {};
+        for (const agg of aggs)
+            out[agg.field] = valueOf(acc.get(agg.field), 0, agg.fn);
+        return out;
+    }
+    // ---- answering ----------------------------------------------------------
+    function supported(plan) {
+        return !plan.expression && !plan.pivotBy?.length;
+    }
+    function prepare(plan) {
+        const key = JSON.stringify({ ...plan, limit: 0, offset: 0 });
+        const hit = cache.get(key);
+        if (hit) {
+            cache.delete(key);
+            cache.set(key, hit);
+            return hit;
+        }
+        const prepared = run(plan);
+        if (!prepared)
+            return null;
+        cache.set(key, prepared);
+        if (cache.size > RESULT_CACHE_SIZE)
+            cache.delete(cache.keys().next().value);
+        return prepared;
+    }
+    function run(plan) {
+        const idx = select(plan.where, plan.search);
+        const out = {};
+        if (plan.grandTotal) {
+            const filtersOnly = plan.where.slice(0, plan.where.length - (plan.pathPredicates ?? 0));
+            const all = filtersOnly.length === plan.where.length ? idx : select(filtersOnly, plan.search);
+            out.grandTotal = totals(all, plan);
+        }
+        if (!plan.groupBy) {
+            const order = plan.orderBy.length ? sortIndexes(idx, plan.orderBy) : idx;
+            if (!order)
+                return null;
+            out.order = order;
+            return out;
+        }
+        // Groups in order of first appearance, as the reference's Map buckets are.
+        const groupField = plan.groupBy;
+        const gcol = column(groupField);
+        const { keyOf, keys } = keyed(gcol);
+        const slot = new Int32Array(keys.length).fill(-1);
+        const groupKeys = [];
+        const gcodes = gcol.codes;
+        const rowGroup = new Uint32Array(idx.length);
+        for (let i = 0; i < idx.length; i += 1) {
+            const k = keyOf[gcodes[idx[i]]];
+            let g = slot[k];
+            if (g < 0) {
+                g = groupKeys.length;
+                slot[k] = g;
+                groupKeys.push(k);
+            }
+            rowGroup[i] = g;
+        }
+        const groupCount = groupKeys.length;
+        const acc = accumulate(idx, rowGroup, groupCount, plan.aggregations ?? []);
+        const childCounts = new Float64Array(groupCount);
+        if (plan.childGroupBy) {
+            const ccol = column(plan.childGroupBy);
+            const { keyOf: childKeyOf, keys: childKeys } = keyed(ccol);
+            const seen = new Set();
+            for (let i = 0; i < idx.length; i += 1) {
+                const g = rowGroup[i];
+                const c = childKeyOf[ccol.codes[idx[i]]];
+                const pair = g * childKeys.length + c;
+                if (!seen.has(pair)) {
+                    seen.add(pair);
+                    childCounts[g] += 1;
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < idx.length; i += 1)
+                childCounts[rowGroup[i]] += 1;
+        }
+        const groups = groupKeys.map((k, g) => {
+            const row = { [groupField]: keys[k] };
+            for (const agg of plan.aggregations ?? [])
+                row[agg.field] = valueOf(acc.get(agg.field), g, agg.fn);
+            row.childCount = childCounts[g];
+            return row;
+        });
+        const produced = new Set([groupField, ...(plan.aggregations ?? []).map((a) => a.field)]);
+        const groupOrder = plan.orderBy.filter((o) => produced.has(o.field));
+        out.groups = groupOrder.length
+            ? sortRows(groups, groupOrder)
+            : sortRows(groups, [{ field: groupField, desc: false }]);
+        return out;
+    }
+    const counts = { columnar: 0, reference: 0 };
+    return {
+        async getRows(request) {
+            const plan = planQuery(schema, request);
+            const prepared = supported(plan) ? prepare(plan) : null;
+            if (!prepared) {
+                counts.reference += 1;
+                return reference.getRows(request);
+            }
+            counts.columnar += 1;
+            const from = plan.offset;
+            const to = plan.offset + plan.limit;
+            const total = prepared.groups ? prepared.groups.length : prepared.order.length;
+            const rows = prepared.groups
+                ? prepared.groups.slice(from, to)
+                : Array.from(prepared.order.subarray(from, Math.min(to, total)), (i) => store[i]);
+            return {
+                rows,
+                rowCount: total,
+                appliedExpression: false,
+                ...(prepared.grandTotal !== undefined ? { grandTotal: prepared.grandTotal } : {}),
+            };
+        },
+        async createRow(input) {
+            const row = await reference.createRow(input);
+            invalidate();
+            return row;
+        },
+        async updateRow(id, patch) {
+            const row = await reference.updateRow(id, patch);
+            invalidate();
+            return row;
+        },
+        async deleteRow(id) {
+            await reference.deleteRow(id);
+            invalidate();
+        },
+        async updateWhere(filterModel, patch, selection) {
+            const changed = await reference.updateWhere(filterModel, patch, selection);
+            invalidate();
+            return changed;
+        },
+        getAggregate: (request) => reference.getAggregate(request),
+        rows: () => store,
+        stats: () => ({ ...counts }),
+        warm() {
+            while (warmed < fields.length) {
+                const field = fields[warmed++];
+                const existing = columns.get(field);
+                if (existing?.ranks !== undefined && existing.keyOf && existing.nums)
+                    continue;
+                // Everything a sort, a grouping and an aggregate read, so none of
+                // them pays for it on the first click.
+                const col = column(field);
+                ranked(col);
+                keyed(col);
+                numbers(col);
+                return true;
+            }
+            return false;
+        },
+    };
+}

package/dist/worker/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `@svgrid/enterprise/worker` - what runs INSIDE the worker behind
+ * `createWorkerDataSource`. Import it from your worker file and nowhere else:
+ * it has no Svelte and no DOM in its import graph, so the worker bundle stays
+ * the in-memory source and little more.
+ *
+ * The main-thread half, `createWorkerDataSource`, is on the package root and
+ * on `@svgrid/enterprise/server`.
+ */
+export { serveWorkerDataSource, type ServeWorkerDataSourceOptions, type WorkerScopeLike, } from './serve.js';
+export { inferSchemaFromRows, type InferSchemaOptions } from './infer-schema.js';
+export { createColumnarDataSource, type ColumnarDataSource } from './columnar.js';

package/dist/worker/index.js

@@ -0,0 +1,12 @@
+/**
+ * `@svgrid/enterprise/worker` - what runs INSIDE the worker behind
+ * `createWorkerDataSource`. Import it from your worker file and nowhere else:
+ * it has no Svelte and no DOM in its import graph, so the worker bundle stays
+ * the in-memory source and little more.
+ *
+ * The main-thread half, `createWorkerDataSource`, is on the package root and
+ * on `@svgrid/enterprise/server`.
+ */
+export { serveWorkerDataSource, } from './serve.js';
+export { inferSchemaFromRows } from './infer-schema.js';
+export { createColumnarDataSource } from './columnar.js';

package/dist/worker/infer-schema.d.ts

@@ -0,0 +1,21 @@
+/**
+ * An `EntitySchema` read off the rows themselves, for a worker data source
+ * that was handed plain objects. The in-memory source only filters, sorts and
+ * groups on fields its schema declares, and the type decides how a request's
+ * string values are compared: `'35'` is a number for a number field and text
+ * for a text one.
+ */
+import type { RowData } from '@svgrid/grid';
+import type { EntitySchema } from '../schema.js';
+export type InferSchemaOptions = {
+    /** The row id field. Default: `id` when the rows have one, else the first field. */
+    idField?: string;
+    /** The schema's name. Default `rows`. */
+    name?: string;
+};
+/**
+ * A field is `number` or `boolean` when every non-empty sampled value is one,
+ * and `text` otherwise. Dates come out as `text`: send them as ISO strings,
+ * which sort and compare correctly as text, or as epoch numbers.
+ */
+export declare function inferSchemaFromRows<TData extends RowData>(rows: ReadonlyArray<TData>, options?: InferSchemaOptions): EntitySchema<TData>;