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

package/dist/worker/initTableWorker.d.cts

@@ -1,33 +0,0 @@
-import { RowData } from "../types/type-utils.cjs";
-import { TableOptions } from "../types/TableOptions.cjs";
-import { TableFeatures } from "../types/TableFeatures.cjs";
-
-//#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.cts.map

package/dist/worker/initTableWorker.js.map

@@ -1 +0,0 @@
-{"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

@@ -1,72 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,9 +0,0 @@
-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.js.map

@@ -1 +0,0 @@
-{"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

@@ -1,53 +0,0 @@
-
-//#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

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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

@@ -1,29 +0,0 @@
-
-//#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

@@ -1 +0,0 @@
-{"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

@@ -1,88 +0,0 @@
-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.js.map

@@ -1 +0,0 @@
-{"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/src/core/cells/constructCell.ts

@@ -1,55 +0,0 @@
-import type { Table_Internal } from '../../types/Table'
-import type { CellData, RowData } from '../../types/type-utils'
-import type { TableFeatures } from '../../types/TableFeatures'
-import type { Row } from '../../types/Row'
-import type { Cell } from '../../types/Cell'
-import type { Column } from '../../types/Column'
-import type { Cell_CoreProperties } from './coreCellsFeature.types'
-
-/**
- * Creates or retrieves the cell prototype for a table.
- * The prototype is cached on the table and shared by all cell instances.
- */
-function getCellPrototype<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>): object {
-  if (!table._cellPrototype) {
-    table._cellPrototype = { table }
-    const features = Object.values(table._features)
-    for (let i = 0; i < features.length; i++) {
-      features[i]!.assignCellPrototype?.(table._cellPrototype, table)
-    }
-  }
-  return table._cellPrototype
-}
-
-/**
- * Constructs a cell instance from normalized table internals.
- *
- * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.
- */
-export function constructCell<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue extends CellData = CellData,
->(
-  column: Column<TFeatures, TData, TValue>,
-  row: Row<TFeatures, TData>,
-  table: Table_Internal<TFeatures, TData>,
-): Cell<TFeatures, TData, TValue> {
-  // Create cell with shared prototype for memory efficiency
-  const cellPrototype = getCellPrototype(table)
-  const cell = Object.create(cellPrototype) as Cell_CoreProperties<
-    TFeatures,
-    TData,
-    TValue
-  >
-
-  // Only assign instance-specific properties
-  cell.column = column
-  cell.id = `${row.id}_${column.id}`
-  cell.row = row
-
-  return cell as Cell<TFeatures, TData, TValue>
-}

package/src/core/cells/coreCellsFeature.ts

@@ -1,27 +0,0 @@
-import { assignPrototypeAPIs } from '../../utils'
-import {
-  cell_getContext,
-  cell_getValue,
-  cell_renderValue,
-} from './coreCellsFeature.utils'
-import type { TableFeature } from '../../types/TableFeatures'
-
-/**
- * Core feature that adds cell value, render, and context APIs.
- */
-export const coreCellsFeature: TableFeature = {
-  assignCellPrototype: (prototype, table) => {
-    assignPrototypeAPIs('coreCellsFeature', prototype, table, {
-      cell_getValue: {
-        fn: (cell) => cell_getValue(cell),
-      },
-      cell_renderValue: {
-        fn: (cell) => cell_renderValue(cell),
-      },
-      cell_getContext: {
-        fn: (cell) => cell_getContext(cell),
-        memoDeps: (cell) => [cell],
-      },
-    })
-  },
-}

package/src/core/cells/coreCellsFeature.types.ts

@@ -1,68 +0,0 @@
-import type { CellData, Getter, RowData } from '../../types/type-utils'
-import type { TableFeatures } from '../../types/TableFeatures'
-import type { Table, Table_Internal } from '../../types/Table'
-import type { Row } from '../../types/Row'
-import type { Cell } from '../../types/Cell'
-import type { Column } from '../../types/Column'
-
-export interface CellContext<
-  in out TFeatures extends TableFeatures,
-  in out TData extends RowData,
-  TValue extends CellData = CellData,
-> {
-  cell: Cell<TFeatures, TData, TValue>
-  column: Column<TFeatures, TData, TValue>
-  getValue: Getter<TValue>
-  renderValue: Getter<TValue | null>
-  row: Row<TFeatures, TData>
-  table: Table<TFeatures, TData>
-}
-
-export interface Cell_CoreProperties<
-  in out TFeatures extends TableFeatures,
-  in out TData extends RowData,
-  TValue extends CellData = CellData,
-> {
-  /**
-   * The associated Column object for the cell.
-   */
-  column: Column<TFeatures, TData, TValue>
-  /**
-   * The unique ID for the cell across the entire table.
-   */
-  id: string
-  /**
-   * The associated Row object for the cell.
-   */
-  row: Row<TFeatures, TData>
-  /**
-   * Reference to the parent table instance.
-   */
-  table: Table_Internal<TFeatures, TData>
-}
-
-export interface Cell_Cell<
-  in out TFeatures extends TableFeatures,
-  in out TData extends RowData,
-  TValue extends CellData = CellData,
-> extends Cell_CoreProperties<TFeatures, TData, TValue> {
-  /**
-   * Returns the rendering context (or props) for cell-based components like cells and aggregated cells. Use these props with your framework's `flexRender` utility to render these using the template of your choice:
-   */
-  getContext: () => CellContext<TFeatures, TData, TValue>
-  /**
-   * Returns the value for the cell, accessed via the associated column's accessor key or accessor function.
-   */
-  getValue: CellContext<TFeatures, TData, TValue>['getValue']
-  /**
-   * Renders the value for a cell the same as `getValue`, but will return the `renderFallbackValue` if no value is found.
-   */
-  renderValue: CellContext<TFeatures, TData, TValue>['renderValue']
-}
-
-export interface TableOptions_Cell {
-  /**
-   * Value used when the desired value is not found in the data.
-   */
-  renderFallbackValue?: any
-}

package/src/core/cells/coreCellsFeature.utils.ts

@@ -1,68 +0,0 @@
-import type { CellData, RowData } from '../../types/type-utils'
-import type { TableFeatures } from '../../types/TableFeatures'
-import type { Cell } from '../../types/Cell'
-
-/**
- * Reads this cell's accessor value from its owning row and column.
- *
- * This is the standalone implementation behind `cell.getValue()`, useful when
- * importing static APIs instead of calling methods from the cell prototype.
- *
- * @example
- * ```ts
- * const value = cell_getValue(cell)
- * ```
- */
-export function cell_getValue<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue extends CellData = CellData,
->(cell: Cell<TFeatures, TData, TValue>): TValue {
-  return cell.row.getValue(cell.column.id)
-}
-
-/**
- * Reads the value that should be rendered for this cell.
- *
- * Nullish accessor values are replaced with `table.options.renderFallbackValue`,
- * matching the behavior of `cell.renderValue()`.
- *
- * @example
- * ```ts
- * const rendered = cell_renderValue(cell)
- * ```
- */
-export function cell_renderValue<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue extends CellData = CellData,
->(cell: Cell<TFeatures, TData, TValue>) {
-  return cell.getValue() ?? cell.table.options.renderFallbackValue
-}
-
-/**
- * Builds the render context passed to a column's `cell` template.
- *
- * The returned object includes stable references to the table, row, column, and
- * cell, plus bound `getValue` and `renderValue` helpers for render functions.
- *
- * @example
- * ```ts
- * const context = cell_getContext(cell)
- * ```
- */
-export function cell_getContext<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue extends CellData = CellData,
->(cell: Cell<TFeatures, TData, TValue>) {
-  return {
-    table: cell.table,
-    column: cell.column,
-    row: cell.row,
-    cell: cell,
-    // Wrap in arrow functions to preserve `this` binding (methods are on prototype)
-    getValue: () => cell.getValue(),
-    renderValue: () => cell.renderValue(),
-  }
-}