@tanstack/table-core 9.0.0-beta.5 → 9.0.0-beta.51

package/dist/worker/initTableWorker.d.ts

@@ -0,0 +1,33 @@
+import { RowData } from "../types/type-utils.js";
+import { TableOptions } from "../types/TableOptions.js";
+import { TableFeatures } from "../types/TableFeatures.js";
+
+//#region src/worker/initTableWorker.d.ts
+type TableWorkerConfig<TFeatures extends TableFeatures, TData extends RowData> = Omit<TableOptions<TFeatures, TData>, 'data'>;
+/**
+ * Runs a headless "shadow table" inside a dedicated Web Worker.
+ *
+ * Call this from a user-authored worker entry file, passing the same columns
+ * and processing features used on the main thread. The shadow table runs the
+ * real table-core row model pipeline (real fns, real Row objects) off the
+ * main thread and posts back one payload per stage the main thread requested:
+ * a transferable index permutation for flat results, a serialized row tree
+ * (with eagerly computed aggregates) when grouping produces synthetic rows.
+ *
+ * Everything passed here must be thread-portable: `accessorKey` columns or
+ * accessors defined in a shared module, and fns from registries or shared
+ * modules (no closures over app state).
+ *
+ * @example
+ * ```ts
+ * // table.worker.ts
+ * import { initTableWorker } from '@tanstack/table-core/experimental-worker-plugin'
+ * import { columns, sharedFeatures } from './tableConfig'
+ *
+ * initTableWorker({ features: sharedFeatures, columns })
+ * ```
+ */
+declare function initTableWorker<TFeatures extends TableFeatures, TData extends RowData>(config: TableWorkerConfig<TFeatures, TData>): void;
+//#endregion
+export { TableWorkerConfig, initTableWorker };
+//# sourceMappingURL=initTableWorker.d.ts.map

package/dist/worker/initTableWorker.js

@@ -0,0 +1,100 @@
+import { makeObjectMap } from "../utils.js";
+import { constructTable } from "../core/table/constructTable.js";
+import { storeReactivityBindings } from "../store-reactivity-bindings.js";
+import { serializeRowModel } from "./serializeRowModel.js";
+
+//#region src/worker/initTableWorker.ts
+function capitalize(stage) {
+	return stage.charAt(0).toUpperCase() + stage.slice(1);
+}
+/** Flatten column-group defs to leaf defs (mirrors core's id resolution). */
+function flattenColumnDefs(defs) {
+	return defs.flatMap((def) => def.columns ? flattenColumnDefs(def.columns) : [def]);
+}
+/**
+* Runs a headless "shadow table" inside a dedicated Web Worker.
+*
+* Call this from a user-authored worker entry file, passing the same columns
+* and processing features used on the main thread. The shadow table runs the
+* real table-core row model pipeline (real fns, real Row objects) off the
+* main thread and posts back one payload per stage the main thread requested:
+* a transferable index permutation for flat results, a serialized row tree
+* (with eagerly computed aggregates) when grouping produces synthetic rows.
+*
+* Everything passed here must be thread-portable: `accessorKey` columns or
+* accessors defined in a shared module, and fns from registries or shared
+* modules (no closures over app state).
+*
+* @example
+* ```ts
+* // table.worker.ts
+* import { initTableWorker } from '@tanstack/table-core/experimental-worker-plugin'
+* import { columns, sharedFeatures } from './tableConfig'
+*
+* initTableWorker({ features: sharedFeatures, columns })
+* ```
+*/
+function initTableWorker(config) {
+	let table;
+	let dataVersion = 0;
+	let coreIndexById = makeObjectMap();
+	let aggregateColumnIds = [];
+	let lastSentModels = {};
+	self.onmessage = (event) => {
+		const message = event.data;
+		if (message.type === "data") {
+			dataVersion = message.dataVersion;
+			lastSentModels = {};
+			if (!table) {
+				table = constructTable({
+					...config,
+					features: {
+						coreReactivityFeature: storeReactivityBindings(),
+						...config.features
+					},
+					data: message.data
+				});
+				aggregateColumnIds = flattenColumnDefs(config.columns).filter((def) => def.aggregationFn != null || def.aggregatedCell != null).map((def) => def.id ?? (typeof def.accessorKey === "string" ? def.accessorKey.replaceAll(".", "_") : void 0)).filter((id) => id != null);
+			} else table.setOptions((prev) => ({
+				...prev,
+				data: message.data
+			}));
+			const coreFlatRows = table.getCoreRowModel().flatRows;
+			coreIndexById = makeObjectMap();
+			for (let i = 0; i < coreFlatRows.length; i++) coreIndexById[coreFlatRows[i].id] = i;
+			return;
+		}
+		if (!table) return;
+		const start = performance.now();
+		table._reactivity.batch(() => {
+			for (const [key, value] of Object.entries(message.state)) {
+				const baseAtom = table.baseAtoms[key];
+				if (baseAtom && value !== void 0) baseAtom.set(value);
+			}
+		});
+		const stages = {};
+		const transfer = [];
+		for (const stage of message.stages) {
+			if (!config.features[`${stage}RowModel`]) continue;
+			const model = table[`get${capitalize(stage)}RowModel`]();
+			if (lastSentModels[stage] === model) {
+				stages[stage] = { kind: "unchanged" };
+				continue;
+			}
+			lastSentModels[stage] = model;
+			stages[stage] = serializeRowModel(model, coreIndexById, aggregateColumnIds, transfer);
+		}
+		const response = {
+			type: "result",
+			requestId: message.requestId,
+			dataVersion,
+			stages,
+			computeMs: performance.now() - start
+		};
+		postMessage(response, { transfer });
+	};
+}
+
+//#endregion
+export { initTableWorker };
+//# sourceMappingURL=initTableWorker.js.map

package/dist/worker/initTableWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initTableWorker.js","names":[],"sources":["../../src/worker/initTableWorker.ts"],"sourcesContent":["import { constructTable } from '../core/table/constructTable'\nimport { storeReactivityBindings } from '../store-reactivity-bindings'\nimport { makeObjectMap } from '../utils'\nimport { serializeRowModel } from './serializeRowModel'\nimport type { RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { TableOptions } from '../types/TableOptions'\nimport type { Table_Internal } from '../types/Table'\nimport type {\n  TableWorkerRequest,\n  TableWorkerResult,\n  TableWorkerStage,\n  TableWorkerStagePayload,\n} from './tableWorkerProtocol'\n\nexport type TableWorkerConfig<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> = Omit<TableOptions<TFeatures, TData>, 'data'>\n\nfunction capitalize(stage: string) {\n  return stage.charAt(0).toUpperCase() + stage.slice(1)\n}\n\n/** Flatten column-group defs to leaf defs (mirrors core's id resolution). */\nfunction flattenColumnDefs(defs: Array<any>): Array<any> {\n  return defs.flatMap((def) =>\n    def.columns ? flattenColumnDefs(def.columns) : [def],\n  )\n}\n\n/**\n * Runs a headless \"shadow table\" inside a dedicated Web Worker.\n *\n * Call this from a user-authored worker entry file, passing the same columns\n * and processing features used on the main thread. The shadow table runs the\n * real table-core row model pipeline (real fns, real Row objects) off the\n * main thread and posts back one payload per stage the main thread requested:\n * a transferable index permutation for flat results, a serialized row tree\n * (with eagerly computed aggregates) when grouping produces synthetic rows.\n *\n * Everything passed here must be thread-portable: `accessorKey` columns or\n * accessors defined in a shared module, and fns from registries or shared\n * modules (no closures over app state).\n *\n * @example\n * ```ts\n * // table.worker.ts\n * import { initTableWorker } from '@tanstack/table-core/experimental-worker-plugin'\n * import { columns, sharedFeatures } from './tableConfig'\n *\n * initTableWorker({ features: sharedFeatures, columns })\n * ```\n */\nexport function initTableWorker<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(config: TableWorkerConfig<TFeatures, TData>): void {\n  let table: Table_Internal<TFeatures, TData> | undefined\n  let dataVersion = 0\n  let coreIndexById: Record<string, number> = makeObjectMap()\n  let aggregateColumnIds: Array<string> = []\n  // Last-sent model identity per stage: the memoized getters return stable\n  // objects when their inputs did not change, so identity equality is exactly\n  // \"this stage's result is unchanged\".\n  let lastSentModels: { [K in TableWorkerStage]?: unknown } = {}\n\n  self.onmessage = (event: MessageEvent<TableWorkerRequest<TData>>) => {\n    const message = event.data\n\n    if (message.type === 'data') {\n      dataVersion = message.dataVersion\n      lastSentModels = {}\n      if (!table) {\n        table = constructTable<TFeatures, TData>({\n          ...(config as TableOptions<TFeatures, TData>),\n          features: {\n            coreReactivityFeature: storeReactivityBindings(),\n            ...config.features,\n          },\n          data: message.data,\n        })\n        // Only columns with an explicit aggregation get eagerly aggregated\n        // per group. Sync tables aggregate lazily (visible cells only), so\n        // auto-aggregating every column would explode on high-cardinality\n        // grouping for values nothing renders. Read the RAW column defs:\n        // rowAggregationFeature injects default aggregatedCell/aggregationFn\n        // into every resolved columnDef, so the resolved defs can't tell\n        // explicit from default.\n        aggregateColumnIds = flattenColumnDefs(config.columns as Array<any>)\n          .filter(\n            (def) => def.aggregationFn != null || def.aggregatedCell != null,\n          )\n          .map(\n            (def) =>\n              def.id ??\n              (typeof def.accessorKey === 'string'\n                ? def.accessorKey.replaceAll('.', '_')\n                : undefined),\n          )\n          .filter((id): id is string => id != null)\n      } else {\n        table.setOptions((prev) => ({ ...prev, data: message.data }))\n      }\n      // Map row ids to data positions once per dataset; serialization uses it\n      // to express every stage result in terms of core row positions.\n      const coreFlatRows = table.getCoreRowModel().flatRows\n      coreIndexById = makeObjectMap()\n      for (let i = 0; i < coreFlatRows.length; i++) {\n        coreIndexById[coreFlatRows[i]!.id] = i\n      }\n      return\n    }\n\n    if (!table) return\n\n    const start = performance.now()\n\n    // Apply the serializable state slices to the shadow table's base atoms.\n    table._reactivity.batch(() => {\n      for (const [key, value] of Object.entries(message.state)) {\n        const baseAtom = (table!.baseAtoms as Record<string, any>)[key]\n        if (baseAtom && value !== undefined) {\n          baseAtom.set(value)\n        }\n      }\n    })\n\n    // Compute exactly the stages the main thread requested, skipping any this\n    // shadow table has no row model factory for (the main thread warns).\n    const stages: { [K in TableWorkerStage]?: TableWorkerStagePayload } = {}\n    const transfer: Array<Transferable> = []\n\n    for (const stage of message.stages) {\n      if (!(config.features as Record<string, unknown>)[`${stage}RowModel`]) {\n        continue\n      }\n      const model = (table as any)[`get${capitalize(stage)}RowModel`]()\n      // Memoized getters return the same object when inputs are unchanged;\n      // skip re-serializing (and the main thread skips rebuilding). Safe under\n      // single-flight: results are never dropped within a dataVersion.\n      if (lastSentModels[stage] === model) {\n        stages[stage] = { kind: 'unchanged' }\n        continue\n      }\n      lastSentModels[stage] = model\n      stages[stage] = serializeRowModel(\n        model,\n        coreIndexById,\n        aggregateColumnIds,\n        transfer,\n      )\n    }\n\n    const response: TableWorkerResult = {\n      type: 'result',\n      requestId: message.requestId,\n      dataVersion,\n      stages,\n      computeMs: performance.now() - start,\n    }\n    postMessage(response, { transfer })\n  }\n}\n"],"mappings":";;;;;;AAoBA,SAAS,WAAW,OAAe;CACjC,OAAO,MAAM,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,MAAM,MAAM,CAAC;AACtD;;AAGA,SAAS,kBAAkB,MAA8B;CACvD,OAAO,KAAK,SAAS,QACnB,IAAI,UAAU,kBAAkB,IAAI,OAAO,IAAI,CAAC,GAAG,CACrD;AACF;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,gBAGd,QAAmD;CACnD,IAAI;CACJ,IAAI,cAAc;CAClB,IAAI,gBAAwC,cAAc;CAC1D,IAAI,qBAAoC,CAAC;CAIzC,IAAI,iBAAwD,CAAC;CAE7D,KAAK,aAAa,UAAmD;EACnE,MAAM,UAAU,MAAM;EAEtB,IAAI,QAAQ,SAAS,QAAQ;GAC3B,cAAc,QAAQ;GACtB,iBAAiB,CAAC;GAClB,IAAI,CAAC,OAAO;IACV,QAAQ,eAAiC;KACvC,GAAI;KACJ,UAAU;MACR,uBAAuB,wBAAwB;MAC/C,GAAG,OAAO;KACZ;KACA,MAAM,QAAQ;IAChB,CAAC;IAQD,qBAAqB,kBAAkB,OAAO,OAAqB,CAAC,CACjE,QACE,QAAQ,IAAI,iBAAiB,QAAQ,IAAI,kBAAkB,IAC9D,CAAC,CACA,KACE,QACC,IAAI,OACH,OAAO,IAAI,gBAAgB,WACxB,IAAI,YAAY,WAAW,KAAK,GAAG,IACnC,OACR,CAAC,CACA,QAAQ,OAAqB,MAAM,IAAI;GAC5C,OACE,MAAM,YAAY,UAAU;IAAE,GAAG;IAAM,MAAM,QAAQ;GAAK,EAAE;GAI9D,MAAM,eAAe,MAAM,gBAAgB,CAAC,CAAC;GAC7C,gBAAgB,cAAc;GAC9B,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KACvC,cAAc,aAAa,EAAE,CAAE,MAAM;GAEvC;EACF;EAEA,IAAI,CAAC,OAAO;EAEZ,MAAM,QAAQ,YAAY,IAAI;EAG9B,MAAM,YAAY,YAAY;GAC5B,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,KAAK,GAAG;IACxD,MAAM,WAAY,MAAO,UAAkC;IAC3D,IAAI,YAAY,UAAU,QACxB,SAAS,IAAI,KAAK;GAEtB;EACF,CAAC;EAID,MAAM,SAAgE,CAAC;EACvE,MAAM,WAAgC,CAAC;EAEvC,KAAK,MAAM,SAAS,QAAQ,QAAQ;GAClC,IAAI,CAAE,OAAO,SAAqC,GAAG,MAAM,YACzD;GAEF,MAAM,QAAS,MAAc,MAAM,WAAW,KAAK,EAAE,UAAU,CAAC;GAIhE,IAAI,eAAe,WAAW,OAAO;IACnC,OAAO,SAAS,EAAE,MAAM,YAAY;IACpC;GACF;GACA,eAAe,SAAS;GACxB,OAAO,SAAS,kBACd,OACA,eACA,oBACA,QACF;EACF;EAEA,MAAM,WAA8B;GAClC,MAAM;GACN,WAAW,QAAQ;GACnB;GACA;GACA,WAAW,YAAY,IAAI,IAAI;EACjC;EACA,YAAY,UAAU,EAAE,SAAS,CAAC;CACpC;AACF"}

package/dist/worker/rebuildRowModel.cjs

@@ -0,0 +1,72 @@
+const require_utils = require('../utils.cjs');
+const require_constructRow = require('../core/rows/constructRow.cjs');
+
+//#region src/worker/rebuildRowModel.ts
+function collectLeafRows(subRows, out) {
+	for (let i = 0; i < subRows.length; i++) {
+		const row = subRows[i];
+		if (row.groupingColumnId == null) out.push(row);
+		else collectLeafRows(row.subRows, out);
+	}
+}
+function rebuildRowModel(table, payload, resetDepths) {
+	const core = table.getCoreRowModel();
+	if (payload.kind === "flat") {
+		const { indices } = payload;
+		const rows = new Array(indices.length);
+		for (let i = 0; i < indices.length; i++) {
+			const row = core.flatRows[indices[i]];
+			if (resetDepths) {
+				row.depth = 0;
+				row.parentId = void 0;
+			}
+			rows[i] = row;
+		}
+		return {
+			rows,
+			flatRows: rows,
+			rowsById: core.rowsById
+		};
+	}
+	const flatRows = [];
+	const rowsById = Object.create(core.rowsById);
+	const rebuildRows = (nodes, depth, parentId) => {
+		const rows = new Array(nodes.length);
+		for (let i = 0; i < nodes.length; i++) {
+			const node = nodes[i];
+			if (typeof node === "number") {
+				const row = core.flatRows[node];
+				row.depth = depth;
+				row.parentId = parentId;
+				flatRows.push(row);
+				rows[i] = row;
+				continue;
+			}
+			const subRows = rebuildRows(node.children, depth + 1, node.id);
+			const leafRows = [];
+			collectLeafRows(subRows, leafRows);
+			const row = require_constructRow.constructRow(table, node.id, leafRows[0]?.original, node.index, depth, void 0, parentId);
+			const aggregates = node.aggregates;
+			Object.assign(row, {
+				groupingColumnId: node.groupingColumnId,
+				groupingValue: node.groupingValue,
+				subRows,
+				leafRows,
+				getValue: (columnId) => require_utils.hasOwn(aggregates, columnId) ? aggregates[columnId] : void 0
+			});
+			flatRows.push(row);
+			rowsById[node.id] = row;
+			rows[i] = row;
+		}
+		return rows;
+	};
+	return {
+		rows: rebuildRows(payload.children, 0, void 0),
+		flatRows,
+		rowsById
+	};
+}
+
+//#endregion
+exports.rebuildRowModel = rebuildRowModel;
+//# sourceMappingURL=rebuildRowModel.cjs.map

package/dist/worker/rebuildRowModel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebuildRowModel.cjs","names":["constructRow","hasOwn"],"sources":["../../src/worker/rebuildRowModel.ts"],"sourcesContent":["import { constructRow } from '../core/rows/constructRow'\nimport { hasOwn } from '../utils'\nimport type { RowModel } from '../core/row-models/coreRowModelsFeature.types'\nimport type { Table_Internal } from '../types/Table'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { RowData } from '../types/type-utils'\nimport type {\n  TableWorkerRowNode,\n  TableWorkerStagePayload,\n} from './tableWorkerProtocol'\n\n/** Payloads that carry data; `unchanged` never reaches the rebuilder. */\nexport type TableWorkerDataPayload = Exclude<\n  TableWorkerStagePayload,\n  { kind: 'unchanged' }\n>\n\n// Main-thread side: payload + this table's core rows -> RowModel. Mirrors how\n// the sync row models treat rows: data rows are reused (with depth/parentId\n// rewritten, exactly like createGroupedRowModel does), synthetic group rows\n// are reconstructed via constructRow with their worker-computed aggregates\n// pre-seeded so no aggregation ever runs on the main thread.\n\nfunction collectLeafRows(subRows: Array<any>, out: Array<any>) {\n  for (let i = 0; i < subRows.length; i++) {\n    const row = subRows[i]\n    if (row.groupingColumnId == null) {\n      out.push(row)\n    } else {\n      collectLeafRows(row.subRows, out)\n    }\n  }\n}\n\nexport function rebuildRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  payload: TableWorkerDataPayload,\n  /**\n   * Whether a flat payload should rewrite row depth/parentId. Mirrors core:\n   * the grouped model's passthrough resets them, the filtered model never\n   * touches them. Without this distinction a filtered rebuild could zero the\n   * depths a grouped/sorted tree rebuild just assigned to shared row objects.\n   */\n  resetDepths: boolean,\n): RowModel<TFeatures, TData> {\n  const core = table.getCoreRowModel()\n\n  if (payload.kind === 'flat') {\n    const { indices } = payload\n    const rows = new Array(indices.length)\n    for (let i = 0; i < indices.length; i++) {\n      const row: any = core.flatRows[indices[i]!]!\n      if (resetDepths) {\n        row.depth = 0\n        row.parentId = undefined\n      }\n      rows[i] = row\n    }\n    return { rows, flatRows: rows, rowsById: core.rowsById }\n  }\n\n  const flatRows: Array<any> = []\n  // Data rows resolve through the prototype chain to the core map; only\n  // synthetic group rows are added on top.\n  const rowsById: Record<string, any> = Object.create(core.rowsById)\n\n  const rebuildRows = (\n    nodes: Array<TableWorkerRowNode>,\n    depth: number,\n    parentId: string | undefined,\n  ): Array<any> => {\n    const rows = new Array(nodes.length)\n    for (let i = 0; i < nodes.length; i++) {\n      const node = nodes[i]!\n      if (typeof node === 'number') {\n        const row: any = core.flatRows[node]!\n        row.depth = depth\n        row.parentId = parentId\n        flatRows.push(row)\n        rows[i] = row\n        continue\n      }\n\n      const subRows = rebuildRows(node.children, depth + 1, node.id)\n      const leafRows: Array<any> = []\n      collectLeafRows(subRows, leafRows)\n\n      const row: any = constructRow(\n        table,\n        node.id,\n        leafRows[0]?.original,\n        node.index,\n        depth,\n        undefined,\n        parentId,\n      )\n      const aggregates = node.aggregates\n      Object.assign(row, {\n        groupingColumnId: node.groupingColumnId,\n        groupingValue: node.groupingValue,\n        subRows,\n        leafRows,\n        getValue: (columnId: string) =>\n          hasOwn(aggregates, columnId) ? aggregates[columnId] : undefined,\n      })\n\n      flatRows.push(row)\n      rowsById[node.id] = row\n      rows[i] = row\n    }\n    return rows\n  }\n\n  const rows = rebuildRows(payload.children, 0, undefined)\n\n  return { rows, flatRows, rowsById }\n}\n"],"mappings":";;;;AAuBA,SAAS,gBAAgB,SAAqB,KAAiB;CAC7D,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;EACvC,MAAM,MAAM,QAAQ;EACpB,IAAI,IAAI,oBAAoB,MAC1B,IAAI,KAAK,GAAG;OAEZ,gBAAgB,IAAI,SAAS,GAAG;CAEpC;AACF;AAEA,SAAgB,gBAId,OACA,SAOA,aAC4B;CAC5B,MAAM,OAAO,MAAM,gBAAgB;CAEnC,IAAI,QAAQ,SAAS,QAAQ;EAC3B,MAAM,EAAE,YAAY;EACpB,MAAM,OAAO,IAAI,MAAM,QAAQ,MAAM;EACrC,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;GACvC,MAAM,MAAW,KAAK,SAAS,QAAQ;GACvC,IAAI,aAAa;IACf,IAAI,QAAQ;IACZ,IAAI,WAAW;GACjB;GACA,KAAK,KAAK;EACZ;EACA,OAAO;GAAE;GAAM,UAAU;GAAM,UAAU,KAAK;EAAS;CACzD;CAEA,MAAM,WAAuB,CAAC;CAG9B,MAAM,WAAgC,OAAO,OAAO,KAAK,QAAQ;CAEjE,MAAM,eACJ,OACA,OACA,aACe;EACf,MAAM,OAAO,IAAI,MAAM,MAAM,MAAM;EACnC,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,OAAO,MAAM;GACnB,IAAI,OAAO,SAAS,UAAU;IAC5B,MAAM,MAAW,KAAK,SAAS;IAC/B,IAAI,QAAQ;IACZ,IAAI,WAAW;IACf,SAAS,KAAK,GAAG;IACjB,KAAK,KAAK;IACV;GACF;GAEA,MAAM,UAAU,YAAY,KAAK,UAAU,QAAQ,GAAG,KAAK,EAAE;GAC7D,MAAM,WAAuB,CAAC;GAC9B,gBAAgB,SAAS,QAAQ;GAEjC,MAAM,MAAWA,kCACf,OACA,KAAK,IACL,SAAS,EAAE,EAAE,UACb,KAAK,OACL,OACA,QACA,QACF;GACA,MAAM,aAAa,KAAK;GACxB,OAAO,OAAO,KAAK;IACjB,kBAAkB,KAAK;IACvB,eAAe,KAAK;IACpB;IACA;IACA,WAAW,aACTC,qBAAO,YAAY,QAAQ,IAAI,WAAW,YAAY;GAC1D,CAAC;GAED,SAAS,KAAK,GAAG;GACjB,SAAS,KAAK,MAAM;GACpB,KAAK,KAAK;EACZ;EACA,OAAO;CACT;CAIA,OAAO;EAAE,MAFI,YAAY,QAAQ,UAAU,GAAG,MAElC;EAAG;EAAU;CAAS;AACpC"}

package/dist/worker/rebuildRowModel.d.cts

@@ -0,0 +1,9 @@
+import { TableWorkerStagePayload } from "./tableWorkerProtocol.cjs";
+//#region src/worker/rebuildRowModel.d.ts
+/** Payloads that carry data; `unchanged` never reaches the rebuilder. */
+type TableWorkerDataPayload = Exclude<TableWorkerStagePayload, {
+  kind: 'unchanged';
+}>;
+//#endregion
+export { TableWorkerDataPayload };
+//# sourceMappingURL=rebuildRowModel.d.cts.map

package/dist/worker/rebuildRowModel.d.ts

@@ -0,0 +1,9 @@
+import { TableWorkerStagePayload } from "./tableWorkerProtocol.js";
+//#region src/worker/rebuildRowModel.d.ts
+/** Payloads that carry data; `unchanged` never reaches the rebuilder. */
+type TableWorkerDataPayload = Exclude<TableWorkerStagePayload, {
+  kind: 'unchanged';
+}>;
+//#endregion
+export { TableWorkerDataPayload };
+//# sourceMappingURL=rebuildRowModel.d.ts.map

package/dist/worker/rebuildRowModel.js

@@ -0,0 +1,72 @@
+import { hasOwn } from "../utils.js";
+import { constructRow } from "../core/rows/constructRow.js";
+
+//#region src/worker/rebuildRowModel.ts
+function collectLeafRows(subRows, out) {
+	for (let i = 0; i < subRows.length; i++) {
+		const row = subRows[i];
+		if (row.groupingColumnId == null) out.push(row);
+		else collectLeafRows(row.subRows, out);
+	}
+}
+function rebuildRowModel(table, payload, resetDepths) {
+	const core = table.getCoreRowModel();
+	if (payload.kind === "flat") {
+		const { indices } = payload;
+		const rows = new Array(indices.length);
+		for (let i = 0; i < indices.length; i++) {
+			const row = core.flatRows[indices[i]];
+			if (resetDepths) {
+				row.depth = 0;
+				row.parentId = void 0;
+			}
+			rows[i] = row;
+		}
+		return {
+			rows,
+			flatRows: rows,
+			rowsById: core.rowsById
+		};
+	}
+	const flatRows = [];
+	const rowsById = Object.create(core.rowsById);
+	const rebuildRows = (nodes, depth, parentId) => {
+		const rows = new Array(nodes.length);
+		for (let i = 0; i < nodes.length; i++) {
+			const node = nodes[i];
+			if (typeof node === "number") {
+				const row = core.flatRows[node];
+				row.depth = depth;
+				row.parentId = parentId;
+				flatRows.push(row);
+				rows[i] = row;
+				continue;
+			}
+			const subRows = rebuildRows(node.children, depth + 1, node.id);
+			const leafRows = [];
+			collectLeafRows(subRows, leafRows);
+			const row = constructRow(table, node.id, leafRows[0]?.original, node.index, depth, void 0, parentId);
+			const aggregates = node.aggregates;
+			Object.assign(row, {
+				groupingColumnId: node.groupingColumnId,
+				groupingValue: node.groupingValue,
+				subRows,
+				leafRows,
+				getValue: (columnId) => hasOwn(aggregates, columnId) ? aggregates[columnId] : void 0
+			});
+			flatRows.push(row);
+			rowsById[node.id] = row;
+			rows[i] = row;
+		}
+		return rows;
+	};
+	return {
+		rows: rebuildRows(payload.children, 0, void 0),
+		flatRows,
+		rowsById
+	};
+}
+
+//#endregion
+export { rebuildRowModel };
+//# sourceMappingURL=rebuildRowModel.js.map

package/dist/worker/rebuildRowModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebuildRowModel.js","names":[],"sources":["../../src/worker/rebuildRowModel.ts"],"sourcesContent":["import { constructRow } from '../core/rows/constructRow'\nimport { hasOwn } from '../utils'\nimport type { RowModel } from '../core/row-models/coreRowModelsFeature.types'\nimport type { Table_Internal } from '../types/Table'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { RowData } from '../types/type-utils'\nimport type {\n  TableWorkerRowNode,\n  TableWorkerStagePayload,\n} from './tableWorkerProtocol'\n\n/** Payloads that carry data; `unchanged` never reaches the rebuilder. */\nexport type TableWorkerDataPayload = Exclude<\n  TableWorkerStagePayload,\n  { kind: 'unchanged' }\n>\n\n// Main-thread side: payload + this table's core rows -> RowModel. Mirrors how\n// the sync row models treat rows: data rows are reused (with depth/parentId\n// rewritten, exactly like createGroupedRowModel does), synthetic group rows\n// are reconstructed via constructRow with their worker-computed aggregates\n// pre-seeded so no aggregation ever runs on the main thread.\n\nfunction collectLeafRows(subRows: Array<any>, out: Array<any>) {\n  for (let i = 0; i < subRows.length; i++) {\n    const row = subRows[i]\n    if (row.groupingColumnId == null) {\n      out.push(row)\n    } else {\n      collectLeafRows(row.subRows, out)\n    }\n  }\n}\n\nexport function rebuildRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  payload: TableWorkerDataPayload,\n  /**\n   * Whether a flat payload should rewrite row depth/parentId. Mirrors core:\n   * the grouped model's passthrough resets them, the filtered model never\n   * touches them. Without this distinction a filtered rebuild could zero the\n   * depths a grouped/sorted tree rebuild just assigned to shared row objects.\n   */\n  resetDepths: boolean,\n): RowModel<TFeatures, TData> {\n  const core = table.getCoreRowModel()\n\n  if (payload.kind === 'flat') {\n    const { indices } = payload\n    const rows = new Array(indices.length)\n    for (let i = 0; i < indices.length; i++) {\n      const row: any = core.flatRows[indices[i]!]!\n      if (resetDepths) {\n        row.depth = 0\n        row.parentId = undefined\n      }\n      rows[i] = row\n    }\n    return { rows, flatRows: rows, rowsById: core.rowsById }\n  }\n\n  const flatRows: Array<any> = []\n  // Data rows resolve through the prototype chain to the core map; only\n  // synthetic group rows are added on top.\n  const rowsById: Record<string, any> = Object.create(core.rowsById)\n\n  const rebuildRows = (\n    nodes: Array<TableWorkerRowNode>,\n    depth: number,\n    parentId: string | undefined,\n  ): Array<any> => {\n    const rows = new Array(nodes.length)\n    for (let i = 0; i < nodes.length; i++) {\n      const node = nodes[i]!\n      if (typeof node === 'number') {\n        const row: any = core.flatRows[node]!\n        row.depth = depth\n        row.parentId = parentId\n        flatRows.push(row)\n        rows[i] = row\n        continue\n      }\n\n      const subRows = rebuildRows(node.children, depth + 1, node.id)\n      const leafRows: Array<any> = []\n      collectLeafRows(subRows, leafRows)\n\n      const row: any = constructRow(\n        table,\n        node.id,\n        leafRows[0]?.original,\n        node.index,\n        depth,\n        undefined,\n        parentId,\n      )\n      const aggregates = node.aggregates\n      Object.assign(row, {\n        groupingColumnId: node.groupingColumnId,\n        groupingValue: node.groupingValue,\n        subRows,\n        leafRows,\n        getValue: (columnId: string) =>\n          hasOwn(aggregates, columnId) ? aggregates[columnId] : undefined,\n      })\n\n      flatRows.push(row)\n      rowsById[node.id] = row\n      rows[i] = row\n    }\n    return rows\n  }\n\n  const rows = rebuildRows(payload.children, 0, undefined)\n\n  return { rows, flatRows, rowsById }\n}\n"],"mappings":";;;;AAuBA,SAAS,gBAAgB,SAAqB,KAAiB;CAC7D,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;EACvC,MAAM,MAAM,QAAQ;EACpB,IAAI,IAAI,oBAAoB,MAC1B,IAAI,KAAK,GAAG;OAEZ,gBAAgB,IAAI,SAAS,GAAG;CAEpC;AACF;AAEA,SAAgB,gBAId,OACA,SAOA,aAC4B;CAC5B,MAAM,OAAO,MAAM,gBAAgB;CAEnC,IAAI,QAAQ,SAAS,QAAQ;EAC3B,MAAM,EAAE,YAAY;EACpB,MAAM,OAAO,IAAI,MAAM,QAAQ,MAAM;EACrC,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;GACvC,MAAM,MAAW,KAAK,SAAS,QAAQ;GACvC,IAAI,aAAa;IACf,IAAI,QAAQ;IACZ,IAAI,WAAW;GACjB;GACA,KAAK,KAAK;EACZ;EACA,OAAO;GAAE;GAAM,UAAU;GAAM,UAAU,KAAK;EAAS;CACzD;CAEA,MAAM,WAAuB,CAAC;CAG9B,MAAM,WAAgC,OAAO,OAAO,KAAK,QAAQ;CAEjE,MAAM,eACJ,OACA,OACA,aACe;EACf,MAAM,OAAO,IAAI,MAAM,MAAM,MAAM;EACnC,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,OAAO,MAAM;GACnB,IAAI,OAAO,SAAS,UAAU;IAC5B,MAAM,MAAW,KAAK,SAAS;IAC/B,IAAI,QAAQ;IACZ,IAAI,WAAW;IACf,SAAS,KAAK,GAAG;IACjB,KAAK,KAAK;IACV;GACF;GAEA,MAAM,UAAU,YAAY,KAAK,UAAU,QAAQ,GAAG,KAAK,EAAE;GAC7D,MAAM,WAAuB,CAAC;GAC9B,gBAAgB,SAAS,QAAQ;GAEjC,MAAM,MAAW,aACf,OACA,KAAK,IACL,SAAS,EAAE,EAAE,UACb,KAAK,OACL,OACA,QACA,QACF;GACA,MAAM,aAAa,KAAK;GACxB,OAAO,OAAO,KAAK;IACjB,kBAAkB,KAAK;IACvB,eAAe,KAAK;IACpB;IACA;IACA,WAAW,aACT,OAAO,YAAY,QAAQ,IAAI,WAAW,YAAY;GAC1D,CAAC;GAED,SAAS,KAAK,GAAG;GACjB,SAAS,KAAK,MAAM;GACpB,KAAK,KAAK;EACZ;EACA,OAAO;CACT;CAIA,OAAO;EAAE,MAFI,YAAY,QAAQ,UAAU,GAAG,MAElC;EAAG;EAAU;CAAS;AACpC"}

package/dist/worker/serializeRowModel.cjs

@@ -0,0 +1,53 @@
+
+//#region src/worker/serializeRowModel.ts
+function isCloneSafe(value) {
+	return typeof value !== "function" && typeof value !== "symbol";
+}
+function serializeRows(rows, coreIndexById, aggregateColumnIds) {
+	const nodes = new Array(rows.length);
+	for (let i = 0; i < rows.length; i++) {
+		const row = rows[i];
+		if (row.groupingColumnId == null) {
+			nodes[i] = coreIndexById[row.id];
+			continue;
+		}
+		const aggregates = {};
+		for (let c = 0; c < aggregateColumnIds.length; c++) {
+			const columnId = aggregateColumnIds[c];
+			const value = row.getValue(columnId);
+			if (value !== void 0 && isCloneSafe(value)) aggregates[columnId] = value;
+		}
+		if (!(row.groupingColumnId in aggregates)) {
+			const value = row.getValue(row.groupingColumnId);
+			if (value !== void 0 && isCloneSafe(value)) aggregates[row.groupingColumnId] = value;
+		}
+		nodes[i] = {
+			id: row.id,
+			groupingColumnId: row.groupingColumnId,
+			groupingValue: row.groupingValue,
+			index: row.index,
+			aggregates,
+			children: serializeRows(row.subRows, coreIndexById, aggregateColumnIds)
+		};
+	}
+	return nodes;
+}
+function serializeRowModel(model, coreIndexById, aggregateColumnIds, transfer) {
+	if (model.flatRows.length === model.rows.length) {
+		const indices = new Uint32Array(model.rows.length);
+		for (let i = 0; i < indices.length; i++) indices[i] = coreIndexById[model.rows[i].id];
+		transfer.push(indices.buffer);
+		return {
+			kind: "flat",
+			indices
+		};
+	}
+	return {
+		kind: "tree",
+		children: serializeRows(model.rows, coreIndexById, aggregateColumnIds)
+	};
+}
+
+//#endregion
+exports.serializeRowModel = serializeRowModel;
+//# sourceMappingURL=serializeRowModel.cjs.map

package/dist/worker/serializeRowModel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeRowModel.cjs","names":[],"sources":["../../src/worker/serializeRowModel.ts"],"sourcesContent":["import type { RowModel } from '../core/row-models/coreRowModelsFeature.types'\nimport type {\n  TableWorkerRowNode,\n  TableWorkerStagePayload,\n} from './tableWorkerProtocol'\n\n// Worker-side: RowModel -> transferable payload. Stage-agnostic; the payload\n// kind is chosen from the model's shape (synthetic rows present or not).\n\nfunction isCloneSafe(value: unknown): boolean {\n  return typeof value !== 'function' && typeof value !== 'symbol'\n}\n\nfunction serializeRows(\n  rows: Array<any>,\n  coreIndexById: Record<string, number>,\n  aggregateColumnIds: Array<string>,\n): Array<TableWorkerRowNode> {\n  const nodes = new Array<TableWorkerRowNode>(rows.length)\n  for (let i = 0; i < rows.length; i++) {\n    const row = rows[i]\n    if (row.groupingColumnId == null) {\n      // Data row: its position in `options.data` is all the main thread needs.\n      nodes[i] = coreIndexById[row.id]!\n      continue\n    }\n    // Synthetic group row: compute aggregates eagerly (the expensive per-group\n    // work we want off the main thread), but only for columns with an explicit\n    // aggregation; sync tables aggregate lazily, so eagerly auto-aggregating\n    // every column would explode on high-cardinality grouping.\n    const aggregates: Record<string, unknown> = {}\n    for (let c = 0; c < aggregateColumnIds.length; c++) {\n      const columnId = aggregateColumnIds[c]!\n      const value = row.getValue(columnId)\n      if (value !== undefined && isCloneSafe(value)) {\n        aggregates[columnId] = value\n      }\n    }\n    // The group's own column always serializes its display value (the first\n    // leaf's value) so grouped cells render.\n    if (!(row.groupingColumnId in aggregates)) {\n      const value = row.getValue(row.groupingColumnId)\n      if (value !== undefined && isCloneSafe(value)) {\n        aggregates[row.groupingColumnId] = value\n      }\n    }\n    nodes[i] = {\n      id: row.id,\n      groupingColumnId: row.groupingColumnId,\n      groupingValue: row.groupingValue,\n      index: row.index,\n      aggregates,\n      children: serializeRows(row.subRows, coreIndexById, aggregateColumnIds),\n    }\n  }\n  return nodes\n}\n\nexport function serializeRowModel(\n  model: RowModel<any, any>,\n  coreIndexById: Record<string, number>,\n  aggregateColumnIds: Array<string>,\n  transfer: Array<Transferable>,\n): TableWorkerStagePayload {\n  // Flat fast path: no synthetic rows anywhere (flatRows === rows for flat\n  // data). A Uint32Array permutation transfers at zero-copy cost.\n  if (model.flatRows.length === model.rows.length) {\n    const indices = new Uint32Array(model.rows.length)\n    for (let i = 0; i < indices.length; i++) {\n      indices[i] = coreIndexById[model.rows[i]!.id]!\n    }\n    transfer.push(indices.buffer)\n    return { kind: 'flat', indices }\n  }\n\n  return {\n    kind: 'tree',\n    children: serializeRows(model.rows, coreIndexById, aggregateColumnIds),\n  }\n}\n"],"mappings":";;AASA,SAAS,YAAY,OAAyB;CAC5C,OAAO,OAAO,UAAU,cAAc,OAAO,UAAU;AACzD;AAEA,SAAS,cACP,MACA,eACA,oBAC2B;CAC3B,MAAM,QAAQ,IAAI,MAA0B,KAAK,MAAM;CACvD,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,MAAM,KAAK;EACjB,IAAI,IAAI,oBAAoB,MAAM;GAEhC,MAAM,KAAK,cAAc,IAAI;GAC7B;EACF;EAKA,MAAM,aAAsC,CAAC;EAC7C,KAAK,IAAI,IAAI,GAAG,IAAI,mBAAmB,QAAQ,KAAK;GAClD,MAAM,WAAW,mBAAmB;GACpC,MAAM,QAAQ,IAAI,SAAS,QAAQ;GACnC,IAAI,UAAU,UAAa,YAAY,KAAK,GAC1C,WAAW,YAAY;EAE3B;EAGA,IAAI,EAAE,IAAI,oBAAoB,aAAa;GACzC,MAAM,QAAQ,IAAI,SAAS,IAAI,gBAAgB;GAC/C,IAAI,UAAU,UAAa,YAAY,KAAK,GAC1C,WAAW,IAAI,oBAAoB;EAEvC;EACA,MAAM,KAAK;GACT,IAAI,IAAI;GACR,kBAAkB,IAAI;GACtB,eAAe,IAAI;GACnB,OAAO,IAAI;GACX;GACA,UAAU,cAAc,IAAI,SAAS,eAAe,kBAAkB;EACxE;CACF;CACA,OAAO;AACT;AAEA,SAAgB,kBACd,OACA,eACA,oBACA,UACyB;CAGzB,IAAI,MAAM,SAAS,WAAW,MAAM,KAAK,QAAQ;EAC/C,MAAM,UAAU,IAAI,YAAY,MAAM,KAAK,MAAM;EACjD,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAClC,QAAQ,KAAK,cAAc,MAAM,KAAK,EAAE,CAAE;EAE5C,SAAS,KAAK,QAAQ,MAAM;EAC5B,OAAO;GAAE,MAAM;GAAQ;EAAQ;CACjC;CAEA,OAAO;EACL,MAAM;EACN,UAAU,cAAc,MAAM,MAAM,eAAe,kBAAkB;CACvE;AACF"}

package/dist/worker/serializeRowModel.js

@@ -0,0 +1,52 @@
+//#region src/worker/serializeRowModel.ts
+function isCloneSafe(value) {
+	return typeof value !== "function" && typeof value !== "symbol";
+}
+function serializeRows(rows, coreIndexById, aggregateColumnIds) {
+	const nodes = new Array(rows.length);
+	for (let i = 0; i < rows.length; i++) {
+		const row = rows[i];
+		if (row.groupingColumnId == null) {
+			nodes[i] = coreIndexById[row.id];
+			continue;
+		}
+		const aggregates = {};
+		for (let c = 0; c < aggregateColumnIds.length; c++) {
+			const columnId = aggregateColumnIds[c];
+			const value = row.getValue(columnId);
+			if (value !== void 0 && isCloneSafe(value)) aggregates[columnId] = value;
+		}
+		if (!(row.groupingColumnId in aggregates)) {
+			const value = row.getValue(row.groupingColumnId);
+			if (value !== void 0 && isCloneSafe(value)) aggregates[row.groupingColumnId] = value;
+		}
+		nodes[i] = {
+			id: row.id,
+			groupingColumnId: row.groupingColumnId,
+			groupingValue: row.groupingValue,
+			index: row.index,
+			aggregates,
+			children: serializeRows(row.subRows, coreIndexById, aggregateColumnIds)
+		};
+	}
+	return nodes;
+}
+function serializeRowModel(model, coreIndexById, aggregateColumnIds, transfer) {
+	if (model.flatRows.length === model.rows.length) {
+		const indices = new Uint32Array(model.rows.length);
+		for (let i = 0; i < indices.length; i++) indices[i] = coreIndexById[model.rows[i].id];
+		transfer.push(indices.buffer);
+		return {
+			kind: "flat",
+			indices
+		};
+	}
+	return {
+		kind: "tree",
+		children: serializeRows(model.rows, coreIndexById, aggregateColumnIds)
+	};
+}
+
+//#endregion
+export { serializeRowModel };
+//# sourceMappingURL=serializeRowModel.js.map

package/dist/worker/serializeRowModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeRowModel.js","names":[],"sources":["../../src/worker/serializeRowModel.ts"],"sourcesContent":["import type { RowModel } from '../core/row-models/coreRowModelsFeature.types'\nimport type {\n  TableWorkerRowNode,\n  TableWorkerStagePayload,\n} from './tableWorkerProtocol'\n\n// Worker-side: RowModel -> transferable payload. Stage-agnostic; the payload\n// kind is chosen from the model's shape (synthetic rows present or not).\n\nfunction isCloneSafe(value: unknown): boolean {\n  return typeof value !== 'function' && typeof value !== 'symbol'\n}\n\nfunction serializeRows(\n  rows: Array<any>,\n  coreIndexById: Record<string, number>,\n  aggregateColumnIds: Array<string>,\n): Array<TableWorkerRowNode> {\n  const nodes = new Array<TableWorkerRowNode>(rows.length)\n  for (let i = 0; i < rows.length; i++) {\n    const row = rows[i]\n    if (row.groupingColumnId == null) {\n      // Data row: its position in `options.data` is all the main thread needs.\n      nodes[i] = coreIndexById[row.id]!\n      continue\n    }\n    // Synthetic group row: compute aggregates eagerly (the expensive per-group\n    // work we want off the main thread), but only for columns with an explicit\n    // aggregation; sync tables aggregate lazily, so eagerly auto-aggregating\n    // every column would explode on high-cardinality grouping.\n    const aggregates: Record<string, unknown> = {}\n    for (let c = 0; c < aggregateColumnIds.length; c++) {\n      const columnId = aggregateColumnIds[c]!\n      const value = row.getValue(columnId)\n      if (value !== undefined && isCloneSafe(value)) {\n        aggregates[columnId] = value\n      }\n    }\n    // The group's own column always serializes its display value (the first\n    // leaf's value) so grouped cells render.\n    if (!(row.groupingColumnId in aggregates)) {\n      const value = row.getValue(row.groupingColumnId)\n      if (value !== undefined && isCloneSafe(value)) {\n        aggregates[row.groupingColumnId] = value\n      }\n    }\n    nodes[i] = {\n      id: row.id,\n      groupingColumnId: row.groupingColumnId,\n      groupingValue: row.groupingValue,\n      index: row.index,\n      aggregates,\n      children: serializeRows(row.subRows, coreIndexById, aggregateColumnIds),\n    }\n  }\n  return nodes\n}\n\nexport function serializeRowModel(\n  model: RowModel<any, any>,\n  coreIndexById: Record<string, number>,\n  aggregateColumnIds: Array<string>,\n  transfer: Array<Transferable>,\n): TableWorkerStagePayload {\n  // Flat fast path: no synthetic rows anywhere (flatRows === rows for flat\n  // data). A Uint32Array permutation transfers at zero-copy cost.\n  if (model.flatRows.length === model.rows.length) {\n    const indices = new Uint32Array(model.rows.length)\n    for (let i = 0; i < indices.length; i++) {\n      indices[i] = coreIndexById[model.rows[i]!.id]!\n    }\n    transfer.push(indices.buffer)\n    return { kind: 'flat', indices }\n  }\n\n  return {\n    kind: 'tree',\n    children: serializeRows(model.rows, coreIndexById, aggregateColumnIds),\n  }\n}\n"],"mappings":";AASA,SAAS,YAAY,OAAyB;CAC5C,OAAO,OAAO,UAAU,cAAc,OAAO,UAAU;AACzD;AAEA,SAAS,cACP,MACA,eACA,oBAC2B;CAC3B,MAAM,QAAQ,IAAI,MAA0B,KAAK,MAAM;CACvD,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,MAAM,KAAK;EACjB,IAAI,IAAI,oBAAoB,MAAM;GAEhC,MAAM,KAAK,cAAc,IAAI;GAC7B;EACF;EAKA,MAAM,aAAsC,CAAC;EAC7C,KAAK,IAAI,IAAI,GAAG,IAAI,mBAAmB,QAAQ,KAAK;GAClD,MAAM,WAAW,mBAAmB;GACpC,MAAM,QAAQ,IAAI,SAAS,QAAQ;GACnC,IAAI,UAAU,UAAa,YAAY,KAAK,GAC1C,WAAW,YAAY;EAE3B;EAGA,IAAI,EAAE,IAAI,oBAAoB,aAAa;GACzC,MAAM,QAAQ,IAAI,SAAS,IAAI,gBAAgB;GAC/C,IAAI,UAAU,UAAa,YAAY,KAAK,GAC1C,WAAW,IAAI,oBAAoB;EAEvC;EACA,MAAM,KAAK;GACT,IAAI,IAAI;GACR,kBAAkB,IAAI;GACtB,eAAe,IAAI;GACnB,OAAO,IAAI;GACX;GACA,UAAU,cAAc,IAAI,SAAS,eAAe,kBAAkB;EACxE;CACF;CACA,OAAO;AACT;AAEA,SAAgB,kBACd,OACA,eACA,oBACA,UACyB;CAGzB,IAAI,MAAM,SAAS,WAAW,MAAM,KAAK,QAAQ;EAC/C,MAAM,UAAU,IAAI,YAAY,MAAM,KAAK,MAAM;EACjD,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAClC,QAAQ,KAAK,cAAc,MAAM,KAAK,EAAE,CAAE;EAE5C,SAAS,KAAK,QAAQ,MAAM;EAC5B,OAAO;GAAE,MAAM;GAAQ;EAAQ;CACjC;CAEA,OAAO;EACL,MAAM;EACN,UAAU,cAAc,MAAM,MAAM,eAAe,kBAAkB;CACvE;AACF"}

package/dist/worker/tableWorkerProtocol.cjs

@@ -0,0 +1,29 @@
+
+//#region src/worker/tableWorkerProtocol.ts
+/**
+* Row model stages that can be offloaded to the worker, in pipeline order.
+* Everything else in this module is derived from this list; adding a stage
+* means adding an entry here and to `tableWorkerStageStateDeps`.
+*/
+const tableWorkerPipeline = [
+	"filtered",
+	"grouped",
+	"sorted",
+	"expanded"
+];
+/**
+* The state slices each stage's computation depends on. The main thread sends
+* the union of deps for its registered stages; a change to any of them
+* triggers one worker round trip.
+*/
+const tableWorkerStageStateDeps = {
+	filtered: ["columnFilters", "globalFilter"],
+	grouped: ["grouping"],
+	sorted: ["sorting"],
+	expanded: ["expanded"]
+};
+
+//#endregion
+exports.tableWorkerPipeline = tableWorkerPipeline;
+exports.tableWorkerStageStateDeps = tableWorkerStageStateDeps;
+//# sourceMappingURL=tableWorkerProtocol.cjs.map

package/dist/worker/tableWorkerProtocol.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableWorkerProtocol.cjs","names":[],"sources":["../../src/worker/tableWorkerProtocol.ts"],"sourcesContent":["import type { RowData } from '../types/type-utils'\n\n/**\n * Row model stages that can be offloaded to the worker, in pipeline order.\n * Everything else in this module is derived from this list; adding a stage\n * means adding an entry here and to `tableWorkerStageStateDeps`.\n */\nexport const tableWorkerPipeline = [\n  'filtered',\n  'grouped',\n  'sorted',\n  'expanded',\n] as const\n\nexport type TableWorkerStage = (typeof tableWorkerPipeline)[number]\n\n/**\n * The state slices each stage's computation depends on. The main thread sends\n * the union of deps for its registered stages; a change to any of them\n * triggers one worker round trip.\n */\nexport const tableWorkerStageStateDeps: Record<\n  TableWorkerStage,\n  Array<string>\n> = {\n  filtered: ['columnFilters', 'globalFilter'],\n  grouped: ['grouping'],\n  sorted: ['sorting'],\n  expanded: ['expanded'],\n}\n\n/**\n * A serialized synthetic (group) row. Leaf rows serialize as their position in\n * `options.data`; group rows carry what `constructRow` + the grouped row model\n * need to rebuild them, plus eagerly computed aggregate values so no\n * aggregation runs on the main thread.\n */\nexport interface TableWorkerGroupNode {\n  id: string\n  groupingColumnId: string\n  groupingValue: unknown\n  index: number\n  aggregates: Record<string, unknown>\n  children: Array<TableWorkerRowNode>\n}\n\nexport type TableWorkerRowNode = number | TableWorkerGroupNode\n\n/**\n * A stage result. Flat models (every row is a data row) travel as a\n * transferable index permutation; models containing synthetic rows (grouping)\n * travel as a tree. The kind is chosen from the model's actual shape at\n * runtime, not from the stage name: a sorted model is flat without grouping\n * and a tree with it.\n *\n * `unchanged` means the stage's model is identical to the last one sent for\n * this dataset (its memoized inputs did not change); the main thread keeps\n * its previous result and skips the rebuild entirely.\n */\nexport type TableWorkerStagePayload =\n  | { kind: 'flat'; indices: Uint32Array }\n  | { kind: 'tree'; children: Array<TableWorkerRowNode> }\n  | { kind: 'unchanged' }\n\nexport type TableWorkerRequest<TData extends RowData = any> =\n  | {\n      type: 'data'\n      dataVersion: number\n      data: Array<TData>\n    }\n  | {\n      type: 'process'\n      requestId: number\n      dataVersion: number\n      /** The stages the main thread has worker-backed row models for. */\n      stages: Array<TableWorkerStage>\n      /** Serializable state slices (union of the stages' deps). */\n      state: Record<string, unknown>\n    }\n\nexport interface TableWorkerResult {\n  type: 'result'\n  requestId: number\n  dataVersion: number\n  stages: { [K in TableWorkerStage]?: TableWorkerStagePayload }\n  computeMs: number\n}\n\nexport type TableWorkerResponse = TableWorkerResult\n\n/**\n * The state slice added by `workerRowModelsFeature`. `version` bumps when a\n * worker result lands (driving re-renders through the normal state path);\n * `isPending` is true while a request is in flight. The timing fields expose\n * the last result's worker compute time and full round trip for devtools and\n * debugging.\n */\nexport interface TableState_WorkerRowModels {\n  workerRowModels: {\n    version: number\n    isPending: boolean\n    lastComputeMs?: number\n    lastRoundTripMs?: number\n  }\n}\n"],"mappings":";;;;;;;AAOA,MAAa,sBAAsB;CACjC;CACA;CACA;CACA;AACF;;;;;;AASA,MAAa,4BAGT;CACF,UAAU,CAAC,iBAAiB,cAAc;CAC1C,SAAS,CAAC,UAAU;CACpB,QAAQ,CAAC,SAAS;CAClB,UAAU,CAAC,UAAU;AACvB"}

package/dist/worker/tableWorkerProtocol.d.cts

@@ -0,0 +1,88 @@
+import { RowData } from "../types/type-utils.cjs";
+
+//#region src/worker/tableWorkerProtocol.d.ts
+/**
+ * Row model stages that can be offloaded to the worker, in pipeline order.
+ * Everything else in this module is derived from this list; adding a stage
+ * means adding an entry here and to `tableWorkerStageStateDeps`.
+ */
+declare const tableWorkerPipeline: readonly ["filtered", "grouped", "sorted", "expanded"];
+type TableWorkerStage = (typeof tableWorkerPipeline)[number];
+/**
+ * The state slices each stage's computation depends on. The main thread sends
+ * the union of deps for its registered stages; a change to any of them
+ * triggers one worker round trip.
+ */
+declare const tableWorkerStageStateDeps: Record<TableWorkerStage, Array<string>>;
+/**
+ * A serialized synthetic (group) row. Leaf rows serialize as their position in
+ * `options.data`; group rows carry what `constructRow` + the grouped row model
+ * need to rebuild them, plus eagerly computed aggregate values so no
+ * aggregation runs on the main thread.
+ */
+interface TableWorkerGroupNode {
+  id: string;
+  groupingColumnId: string;
+  groupingValue: unknown;
+  index: number;
+  aggregates: Record<string, unknown>;
+  children: Array<TableWorkerRowNode>;
+}
+type TableWorkerRowNode = number | TableWorkerGroupNode;
+/**
+ * A stage result. Flat models (every row is a data row) travel as a
+ * transferable index permutation; models containing synthetic rows (grouping)
+ * travel as a tree. The kind is chosen from the model's actual shape at
+ * runtime, not from the stage name: a sorted model is flat without grouping
+ * and a tree with it.
+ *
+ * `unchanged` means the stage's model is identical to the last one sent for
+ * this dataset (its memoized inputs did not change); the main thread keeps
+ * its previous result and skips the rebuild entirely.
+ */
+type TableWorkerStagePayload = {
+  kind: 'flat';
+  indices: Uint32Array;
+} | {
+  kind: 'tree';
+  children: Array<TableWorkerRowNode>;
+} | {
+  kind: 'unchanged';
+};
+type TableWorkerRequest<TData extends RowData = any> = {
+  type: 'data';
+  dataVersion: number;
+  data: Array<TData>;
+} | {
+  type: 'process';
+  requestId: number;
+  dataVersion: number; /** The stages the main thread has worker-backed row models for. */
+  stages: Array<TableWorkerStage>; /** Serializable state slices (union of the stages' deps). */
+  state: Record<string, unknown>;
+};
+interface TableWorkerResult {
+  type: 'result';
+  requestId: number;
+  dataVersion: number;
+  stages: { [K in TableWorkerStage]?: TableWorkerStagePayload };
+  computeMs: number;
+}
+type TableWorkerResponse = TableWorkerResult;
+/**
+ * The state slice added by `workerRowModelsFeature`. `version` bumps when a
+ * worker result lands (driving re-renders through the normal state path);
+ * `isPending` is true while a request is in flight. The timing fields expose
+ * the last result's worker compute time and full round trip for devtools and
+ * debugging.
+ */
+interface TableState_WorkerRowModels {
+  workerRowModels: {
+    version: number;
+    isPending: boolean;
+    lastComputeMs?: number;
+    lastRoundTripMs?: number;
+  };
+}
+//#endregion
+export { TableState_WorkerRowModels, TableWorkerGroupNode, TableWorkerRequest, TableWorkerResponse, TableWorkerResult, TableWorkerRowNode, TableWorkerStage, TableWorkerStagePayload, tableWorkerPipeline, tableWorkerStageStateDeps };
+//# sourceMappingURL=tableWorkerProtocol.d.cts.map