@tanstack/table-core 9.0.0-beta.31 → 9.0.0-beta.34

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 {\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\ntype AnyTable = Table_Internal<any, any>\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  table: AnyTable,\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<any, any> {\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,gBACd,OACA,SAOA,aACoB;CACpB,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 {\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\ntype AnyTable = Table_Internal<any, any>\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  table: AnyTable,\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<any, any> {\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,gBACd,OACA,SAOA,aACoB;CACpB,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

package/dist/worker/tableWorkerProtocol.d.ts

@@ -0,0 +1,88 @@
+import { RowData } from "../types/type-utils.js";
+
+//#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.ts.map

package/dist/worker/tableWorkerProtocol.js

@@ -0,0 +1,27 @@
+//#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
+export { tableWorkerPipeline, tableWorkerStageStateDeps };
+//# sourceMappingURL=tableWorkerProtocol.js.map

package/dist/worker/tableWorkerProtocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableWorkerProtocol.js","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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/table-core",
-  "version": "9.0.0-beta.31",
+  "version": "9.0.0-beta.34",
   "description": "Headless UI for building powerful tables & datagrids for TS/JS.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -35,6 +35,10 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
+    "./experimental-worker-plugin": {
+      "import": "./dist/experimental-worker-plugin.js",
+      "require": "./dist/experimental-worker-plugin.cjs"
+    },
     "./flex-render": {
       "import": "./dist/flex-render.js",
       "require": "./dist/flex-render.cjs"
@@ -55,7 +59,7 @@
   },
   "sideEffects": false,
   "engines": {
-    "node": ">=16"
+    "node": ">=20"
   },
   "files": [
     "dist/",

package/src/core/rows/coreRowsFeature.ts

@@ -29,6 +29,7 @@ export const coreRowsFeature: TableFeature = {
       },
       row_getLeafRows: {
         fn: (row) => row_getLeafRows(row),
+        memoDeps: (row) => [row.subRows],
       },
       row_getParentRow: {
         fn: (row) => row_getParentRow(row),

package/src/experimental-worker-plugin.ts

@@ -0,0 +1,22 @@
+/**
+ * Web Worker row models sub-entry (experimental POC).
+ *
+ * Offloads row model stages to a dedicated worker running a headless "shadow
+ * table" built with the same table-core row model pipeline. The main thread
+ * receives transferable index permutations and rebuilds its row models from
+ * them, stale-while-revalidate style.
+ *
+ * Main thread:
+ * - `createTableWorker` — one shared handle per table worker
+ * - `createWorkerRowModel` — turns any flat row model stage into a
+ *   worker-backed factory for the matching `features` slot
+ * - `workerRowModelsFeature` — registers the `workerRowModels` state slice
+ *
+ * Worker entry (user-authored file):
+ * - `initTableWorker` — runs the shadow table; computes only the stages whose
+ *   row model factories are registered in its config
+ */
+export * from './worker/tableWorkerProtocol'
+export * from './worker/initTableWorker'
+export * from './worker/createTableWorker'
+export * from './worker/createWorkerRowModel'

package/src/features/row-selection/rowSelectionFeature.utils.ts

@@ -1,6 +1,7 @@
 import {
   callMemoOrStaticFn,
   cloneState,
+  copyInstancePropertiesWithoutMemos,
   hasOwn,
   makeObjectMap,
 } from '../../utils'
@@ -738,7 +739,7 @@ export function selectRowsFn<
         if (isSelected) {
           // Preserve prototype chain so methods like getValue() remain accessible
           const cloned = Object.create(Object.getPrototypeOf(row))
-          Object.assign(cloned, row)
+          copyInstancePropertiesWithoutMemos(cloned, row)
           cloned.subRows = newSubRows
           result.push(cloned)
         }