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

package/dist/worker/createWorkerRowModel.cjs

@@ -0,0 +1,78 @@
+const require_utils = require('../utils.cjs');
+const require_tableWorkerProtocol = require('./tableWorkerProtocol.cjs');
+const require_createTableWorker = require('./createTableWorker.cjs');
+const require_rebuildRowModel = require('./rebuildRowModel.cjs');
+
+//#region src/worker/createWorkerRowModel.ts
+function capitalize(stage) {
+	return stage.charAt(0).toUpperCase() + stage.slice(1);
+}
+/**
+* Turns any row model stage into a worker-backed one. The returned factory
+* plugs into the standard feature slot for that stage, so it composes with
+* the rest of the pipeline exactly like the sync factory it replaces.
+*
+* Register only the stages you want offloaded; each import is independent and
+* tree-shakable. All stages on a table share one worker and one round trip
+* per state change via the `tableWorker` handle. Until a result lands, the
+* stage returns its pre-stage model (stale-while-revalidate).
+*
+* Offloaded stages must form a contiguous prefix of the pipeline
+* (filtered -> grouped -> sorted -> expanded): a stage's worker result encodes
+* everything upstream as computed in the worker, so any upstream stage
+* registered on the main thread must be offloaded too. A dev warning fires on
+* mismatches.
+*
+* @example
+* ```ts
+* const tableWorker = createTableWorker({ createWorker })
+*
+* const features = tableFeatures({
+*   rowSortingFeature,
+*   columnGroupingFeature,
+*   workerRowModelsFeature,
+*   filteredRowModel: createWorkerRowModel(tableWorker, 'filtered'),
+*   groupedRowModel: createWorkerRowModel(tableWorker, 'grouped'),
+*   sortedRowModel: createWorkerRowModel(tableWorker, 'sorted'),
+* })
+* ```
+*/
+function createWorkerRowModel(tableWorker, stage) {
+	return (_table) => {
+		const table = _table;
+		require_createTableWorker.getTableWorkerBridge(tableWorker, table).stages.add(stage);
+		let warned = false;
+		const warnOnce = (message) => {
+			if (process.env.NODE_ENV === "development" && !warned) {
+				warned = true;
+				console.warn(`[table-worker] ${message}`);
+			}
+		};
+		const memoized = require_utils.tableMemo({
+			table,
+			fnName: `table.get${capitalize(stage)}RowModel`,
+			memoDeps: () => [table.getCoreRowModel(), require_createTableWorker.getTableWorkerBridge(tableWorker, table).stageVersions[stage]],
+			fn: () => {
+				const bridge = require_createTableWorker.getTableWorkerBridge(tableWorker, table);
+				const payload = bridge.results[stage];
+				if (!payload) {
+					if (bridge.resultRequestId > 0) warnOnce(`The worker returned no '${stage}' result. Make sure the worker's initTableWorker() config registers a ${stage}RowModel factory.`);
+					return table[`getPre${capitalize(stage)}RowModel`]();
+				}
+				if (bridge.resultRequestId > 0) for (const upstream of require_tableWorkerProtocol.tableWorkerPipeline) {
+					if (upstream === stage) break;
+					if (table.options.features[`${upstream}RowModel`] && !bridge.results[upstream]) warnOnce(`This table has a ${upstream}RowModel, but the worker result for '${stage}' was computed without an offloaded '${upstream}' stage, so it is bypassed. Offload it too with createWorkerRowModel(tableWorker, '${upstream}').`);
+				}
+				return require_rebuildRowModel.rebuildRowModel(table, payload, stage !== "filtered");
+			}
+		});
+		return () => {
+			require_createTableWorker.syncTableWorker(tableWorker, table);
+			return memoized();
+		};
+	};
+}
+
+//#endregion
+exports.createWorkerRowModel = createWorkerRowModel;
+//# sourceMappingURL=createWorkerRowModel.cjs.map

package/dist/worker/createWorkerRowModel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createWorkerRowModel.cjs","names":["tableMemo","getTableWorkerBridge","tableWorkerPipeline","rebuildRowModel"],"sources":["../../src/worker/createWorkerRowModel.ts"],"sourcesContent":["import { tableMemo } from '../utils'\nimport { getTableWorkerBridge, syncTableWorker } from './createTableWorker'\nimport { rebuildRowModel } from './rebuildRowModel'\nimport { tableWorkerPipeline } from './tableWorkerProtocol'\nimport type { RowModel } from '../core/row-models/coreRowModelsFeature.types'\nimport type { Table, Table_Internal } from '../types/Table'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { RowData } from '../types/type-utils'\nimport type { TableWorker } from './createTableWorker'\nimport type { TableWorkerStage } from './tableWorkerProtocol'\n\ntype AnyTable = Table_Internal<any, any>\n\nfunction capitalize(stage: string) {\n  return stage.charAt(0).toUpperCase() + stage.slice(1)\n}\n\n/**\n * Turns any row model stage into a worker-backed one. The returned factory\n * plugs into the standard feature slot for that stage, so it composes with\n * the rest of the pipeline exactly like the sync factory it replaces.\n *\n * Register only the stages you want offloaded; each import is independent and\n * tree-shakable. All stages on a table share one worker and one round trip\n * per state change via the `tableWorker` handle. Until a result lands, the\n * stage returns its pre-stage model (stale-while-revalidate).\n *\n * Offloaded stages must form a contiguous prefix of the pipeline\n * (filtered -> grouped -> sorted -> expanded): a stage's worker result encodes\n * everything upstream as computed in the worker, so any upstream stage\n * registered on the main thread must be offloaded too. A dev warning fires on\n * mismatches.\n *\n * @example\n * ```ts\n * const tableWorker = createTableWorker({ createWorker })\n *\n * const features = tableFeatures({\n *   rowSortingFeature,\n *   columnGroupingFeature,\n *   workerRowModelsFeature,\n *   filteredRowModel: createWorkerRowModel(tableWorker, 'filtered'),\n *   groupedRowModel: createWorkerRowModel(tableWorker, 'grouped'),\n *   sortedRowModel: createWorkerRowModel(tableWorker, 'sorted'),\n * })\n * ```\n */\nexport function createWorkerRowModel(\n  tableWorker: TableWorker,\n  stage: TableWorkerStage,\n) {\n  return <TFeatures extends TableFeatures, TData extends RowData>(\n    _table: Table<TFeatures, TData>,\n  ): (() => RowModel<TFeatures, TData>) => {\n    const table = _table as unknown as AnyTable\n    // Stages register per table as their factories initialize (first read).\n    // The first render may therefore fire one extra coalesced request while\n    // the stage set grows; single-flight makes it a cheap trailing request.\n    getTableWorkerBridge(tableWorker, table).stages.add(stage)\n    let warned = false\n\n    const warnOnce = (message: string) => {\n      if (process.env.NODE_ENV === 'development' && !warned) {\n        warned = true\n        console.warn(`[table-worker] ${message}`)\n      }\n    }\n\n    const memoized = tableMemo({\n      table,\n      fnName: `table.get${capitalize(stage)}RowModel`,\n      // The per-stage version bumps only when this stage's payload actually\n      // changed, so stages the worker reported as `unchanged` skip the O(n)\n      // rebuild entirely (the re-render itself rides the state slice bump).\n      memoDeps: () => [\n        table.getCoreRowModel(),\n        getTableWorkerBridge(tableWorker, table).stageVersions[stage],\n      ],\n      fn: () => {\n        const bridge = getTableWorkerBridge(tableWorker, table)\n        const payload = bridge.results[stage]\n        if (!payload) {\n          if (bridge.resultRequestId > 0) {\n            warnOnce(\n              `The worker returned no '${stage}' result. Make sure the ` +\n                `worker's initTableWorker() config registers a ` +\n                `${stage}RowModel factory.`,\n            )\n          }\n          return (table as any)[`getPre${capitalize(stage)}RowModel`]()\n        }\n        // Contiguous-prefix check: any upstream stage registered on this\n        // table must also have a worker result, or it is silently bypassed.\n        if (bridge.resultRequestId > 0) {\n          for (const upstream of tableWorkerPipeline) {\n            if (upstream === stage) break\n            if (\n              (table.options.features as Record<string, unknown>)[\n                `${upstream}RowModel`\n              ] &&\n              !bridge.results[upstream]\n            ) {\n              warnOnce(\n                `This table has a ${upstream}RowModel, but the worker result ` +\n                  `for '${stage}' was computed without an offloaded ` +\n                  `'${upstream}' stage, so it is bypassed. Offload it too ` +\n                  `with createWorkerRowModel(tableWorker, '${upstream}').`,\n              )\n            }\n          }\n        }\n        return rebuildRowModel(table, payload, stage !== 'filtered')\n      },\n    })\n\n    return () => {\n      syncTableWorker(tableWorker, table)\n      return memoized()\n    }\n  }\n}\n"],"mappings":";;;;;;AAaA,SAAS,WAAW,OAAe;CACjC,OAAO,MAAM,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,MAAM,MAAM,CAAC;AACtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,qBACd,aACA,OACA;CACA,QACE,WACuC;EACvC,MAAM,QAAQ;EAId,+CAAqB,aAAa,KAAK,CAAC,CAAC,OAAO,IAAI,KAAK;EACzD,IAAI,SAAS;EAEb,MAAM,YAAY,YAAoB;GACpC,IAAI,QAAQ,IAAI,aAAa,iBAAiB,CAAC,QAAQ;IACrD,SAAS;IACT,QAAQ,KAAK,kBAAkB,SAAS;GAC1C;EACF;EAEA,MAAM,WAAWA,wBAAU;GACzB;GACA,QAAQ,YAAY,WAAW,KAAK,EAAE;GAItC,gBAAgB,CACd,MAAM,gBAAgB,GACtBC,+CAAqB,aAAa,KAAK,CAAC,CAAC,cAAc,MACzD;GACA,UAAU;IACR,MAAM,SAASA,+CAAqB,aAAa,KAAK;IACtD,MAAM,UAAU,OAAO,QAAQ;IAC/B,IAAI,CAAC,SAAS;KACZ,IAAI,OAAO,kBAAkB,GAC3B,SACE,2BAA2B,MAAM,wEAE5B,MAAM,kBACb;KAEF,OAAQ,MAAc,SAAS,WAAW,KAAK,EAAE,UAAU,CAAC;IAC9D;IAGA,IAAI,OAAO,kBAAkB,GAC3B,KAAK,MAAM,YAAYC,iDAAqB;KAC1C,IAAI,aAAa,OAAO;KACxB,IACG,MAAM,QAAQ,SACb,GAAG,SAAS,cAEd,CAAC,OAAO,QAAQ,WAEhB,SACE,oBAAoB,SAAS,uCACnB,MAAM,uCACV,SAAS,qFAC8B,SAAS,IACxD;IAEJ;IAEF,OAAOC,wCAAgB,OAAO,SAAS,UAAU,UAAU;GAC7D;EACF,CAAC;EAED,aAAa;GACX,0CAAgB,aAAa,KAAK;GAClC,OAAO,SAAS;EAClB;CACF;AACF"}

package/dist/worker/createWorkerRowModel.d.cts

@@ -0,0 +1,42 @@
+import { RowData } from "../types/type-utils.cjs";
+import { TableWorkerStage } from "./tableWorkerProtocol.cjs";
+import { RowModel } from "../core/row-models/coreRowModelsFeature.types.cjs";
+import { Table } from "../types/Table.cjs";
+import { TableFeatures } from "../types/TableFeatures.cjs";
+import { TableWorker } from "./createTableWorker.cjs";
+
+//#region src/worker/createWorkerRowModel.d.ts
+/**
+ * Turns any row model stage into a worker-backed one. The returned factory
+ * plugs into the standard feature slot for that stage, so it composes with
+ * the rest of the pipeline exactly like the sync factory it replaces.
+ *
+ * Register only the stages you want offloaded; each import is independent and
+ * tree-shakable. All stages on a table share one worker and one round trip
+ * per state change via the `tableWorker` handle. Until a result lands, the
+ * stage returns its pre-stage model (stale-while-revalidate).
+ *
+ * Offloaded stages must form a contiguous prefix of the pipeline
+ * (filtered -> grouped -> sorted -> expanded): a stage's worker result encodes
+ * everything upstream as computed in the worker, so any upstream stage
+ * registered on the main thread must be offloaded too. A dev warning fires on
+ * mismatches.
+ *
+ * @example
+ * ```ts
+ * const tableWorker = createTableWorker({ createWorker })
+ *
+ * const features = tableFeatures({
+ *   rowSortingFeature,
+ *   columnGroupingFeature,
+ *   workerRowModelsFeature,
+ *   filteredRowModel: createWorkerRowModel(tableWorker, 'filtered'),
+ *   groupedRowModel: createWorkerRowModel(tableWorker, 'grouped'),
+ *   sortedRowModel: createWorkerRowModel(tableWorker, 'sorted'),
+ * })
+ * ```
+ */
+declare function createWorkerRowModel(tableWorker: TableWorker, stage: TableWorkerStage): <TFeatures extends TableFeatures, TData extends RowData>(_table: Table<TFeatures, TData>) => (() => RowModel<TFeatures, TData>);
+//#endregion
+export { createWorkerRowModel };
+//# sourceMappingURL=createWorkerRowModel.d.cts.map

package/dist/worker/createWorkerRowModel.d.ts

@@ -0,0 +1,42 @@
+import { RowData } from "../types/type-utils.js";
+import { TableWorkerStage } from "./tableWorkerProtocol.js";
+import { RowModel } from "../core/row-models/coreRowModelsFeature.types.js";
+import { Table } from "../types/Table.js";
+import { TableFeatures } from "../types/TableFeatures.js";
+import { TableWorker } from "./createTableWorker.js";
+
+//#region src/worker/createWorkerRowModel.d.ts
+/**
+ * Turns any row model stage into a worker-backed one. The returned factory
+ * plugs into the standard feature slot for that stage, so it composes with
+ * the rest of the pipeline exactly like the sync factory it replaces.
+ *
+ * Register only the stages you want offloaded; each import is independent and
+ * tree-shakable. All stages on a table share one worker and one round trip
+ * per state change via the `tableWorker` handle. Until a result lands, the
+ * stage returns its pre-stage model (stale-while-revalidate).
+ *
+ * Offloaded stages must form a contiguous prefix of the pipeline
+ * (filtered -> grouped -> sorted -> expanded): a stage's worker result encodes
+ * everything upstream as computed in the worker, so any upstream stage
+ * registered on the main thread must be offloaded too. A dev warning fires on
+ * mismatches.
+ *
+ * @example
+ * ```ts
+ * const tableWorker = createTableWorker({ createWorker })
+ *
+ * const features = tableFeatures({
+ *   rowSortingFeature,
+ *   columnGroupingFeature,
+ *   workerRowModelsFeature,
+ *   filteredRowModel: createWorkerRowModel(tableWorker, 'filtered'),
+ *   groupedRowModel: createWorkerRowModel(tableWorker, 'grouped'),
+ *   sortedRowModel: createWorkerRowModel(tableWorker, 'sorted'),
+ * })
+ * ```
+ */
+declare function createWorkerRowModel(tableWorker: TableWorker, stage: TableWorkerStage): <TFeatures extends TableFeatures, TData extends RowData>(_table: Table<TFeatures, TData>) => (() => RowModel<TFeatures, TData>);
+//#endregion
+export { createWorkerRowModel };
+//# sourceMappingURL=createWorkerRowModel.d.ts.map

package/dist/worker/createWorkerRowModel.js

@@ -0,0 +1,78 @@
+import { tableMemo } from "../utils.js";
+import { tableWorkerPipeline } from "./tableWorkerProtocol.js";
+import { getTableWorkerBridge, syncTableWorker } from "./createTableWorker.js";
+import { rebuildRowModel } from "./rebuildRowModel.js";
+
+//#region src/worker/createWorkerRowModel.ts
+function capitalize(stage) {
+	return stage.charAt(0).toUpperCase() + stage.slice(1);
+}
+/**
+* Turns any row model stage into a worker-backed one. The returned factory
+* plugs into the standard feature slot for that stage, so it composes with
+* the rest of the pipeline exactly like the sync factory it replaces.
+*
+* Register only the stages you want offloaded; each import is independent and
+* tree-shakable. All stages on a table share one worker and one round trip
+* per state change via the `tableWorker` handle. Until a result lands, the
+* stage returns its pre-stage model (stale-while-revalidate).
+*
+* Offloaded stages must form a contiguous prefix of the pipeline
+* (filtered -> grouped -> sorted -> expanded): a stage's worker result encodes
+* everything upstream as computed in the worker, so any upstream stage
+* registered on the main thread must be offloaded too. A dev warning fires on
+* mismatches.
+*
+* @example
+* ```ts
+* const tableWorker = createTableWorker({ createWorker })
+*
+* const features = tableFeatures({
+*   rowSortingFeature,
+*   columnGroupingFeature,
+*   workerRowModelsFeature,
+*   filteredRowModel: createWorkerRowModel(tableWorker, 'filtered'),
+*   groupedRowModel: createWorkerRowModel(tableWorker, 'grouped'),
+*   sortedRowModel: createWorkerRowModel(tableWorker, 'sorted'),
+* })
+* ```
+*/
+function createWorkerRowModel(tableWorker, stage) {
+	return (_table) => {
+		const table = _table;
+		getTableWorkerBridge(tableWorker, table).stages.add(stage);
+		let warned = false;
+		const warnOnce = (message) => {
+			if (process.env.NODE_ENV === "development" && !warned) {
+				warned = true;
+				console.warn(`[table-worker] ${message}`);
+			}
+		};
+		const memoized = tableMemo({
+			table,
+			fnName: `table.get${capitalize(stage)}RowModel`,
+			memoDeps: () => [table.getCoreRowModel(), getTableWorkerBridge(tableWorker, table).stageVersions[stage]],
+			fn: () => {
+				const bridge = getTableWorkerBridge(tableWorker, table);
+				const payload = bridge.results[stage];
+				if (!payload) {
+					if (bridge.resultRequestId > 0) warnOnce(`The worker returned no '${stage}' result. Make sure the worker's initTableWorker() config registers a ${stage}RowModel factory.`);
+					return table[`getPre${capitalize(stage)}RowModel`]();
+				}
+				if (bridge.resultRequestId > 0) for (const upstream of tableWorkerPipeline) {
+					if (upstream === stage) break;
+					if (table.options.features[`${upstream}RowModel`] && !bridge.results[upstream]) warnOnce(`This table has a ${upstream}RowModel, but the worker result for '${stage}' was computed without an offloaded '${upstream}' stage, so it is bypassed. Offload it too with createWorkerRowModel(tableWorker, '${upstream}').`);
+				}
+				return rebuildRowModel(table, payload, stage !== "filtered");
+			}
+		});
+		return () => {
+			syncTableWorker(tableWorker, table);
+			return memoized();
+		};
+	};
+}
+
+//#endregion
+export { createWorkerRowModel };
+//# sourceMappingURL=createWorkerRowModel.js.map

package/dist/worker/createWorkerRowModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createWorkerRowModel.js","names":[],"sources":["../../src/worker/createWorkerRowModel.ts"],"sourcesContent":["import { tableMemo } from '../utils'\nimport { getTableWorkerBridge, syncTableWorker } from './createTableWorker'\nimport { rebuildRowModel } from './rebuildRowModel'\nimport { tableWorkerPipeline } from './tableWorkerProtocol'\nimport type { RowModel } from '../core/row-models/coreRowModelsFeature.types'\nimport type { Table, Table_Internal } from '../types/Table'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { RowData } from '../types/type-utils'\nimport type { TableWorker } from './createTableWorker'\nimport type { TableWorkerStage } from './tableWorkerProtocol'\n\ntype AnyTable = Table_Internal<any, any>\n\nfunction capitalize(stage: string) {\n  return stage.charAt(0).toUpperCase() + stage.slice(1)\n}\n\n/**\n * Turns any row model stage into a worker-backed one. The returned factory\n * plugs into the standard feature slot for that stage, so it composes with\n * the rest of the pipeline exactly like the sync factory it replaces.\n *\n * Register only the stages you want offloaded; each import is independent and\n * tree-shakable. All stages on a table share one worker and one round trip\n * per state change via the `tableWorker` handle. Until a result lands, the\n * stage returns its pre-stage model (stale-while-revalidate).\n *\n * Offloaded stages must form a contiguous prefix of the pipeline\n * (filtered -> grouped -> sorted -> expanded): a stage's worker result encodes\n * everything upstream as computed in the worker, so any upstream stage\n * registered on the main thread must be offloaded too. A dev warning fires on\n * mismatches.\n *\n * @example\n * ```ts\n * const tableWorker = createTableWorker({ createWorker })\n *\n * const features = tableFeatures({\n *   rowSortingFeature,\n *   columnGroupingFeature,\n *   workerRowModelsFeature,\n *   filteredRowModel: createWorkerRowModel(tableWorker, 'filtered'),\n *   groupedRowModel: createWorkerRowModel(tableWorker, 'grouped'),\n *   sortedRowModel: createWorkerRowModel(tableWorker, 'sorted'),\n * })\n * ```\n */\nexport function createWorkerRowModel(\n  tableWorker: TableWorker,\n  stage: TableWorkerStage,\n) {\n  return <TFeatures extends TableFeatures, TData extends RowData>(\n    _table: Table<TFeatures, TData>,\n  ): (() => RowModel<TFeatures, TData>) => {\n    const table = _table as unknown as AnyTable\n    // Stages register per table as their factories initialize (first read).\n    // The first render may therefore fire one extra coalesced request while\n    // the stage set grows; single-flight makes it a cheap trailing request.\n    getTableWorkerBridge(tableWorker, table).stages.add(stage)\n    let warned = false\n\n    const warnOnce = (message: string) => {\n      if (process.env.NODE_ENV === 'development' && !warned) {\n        warned = true\n        console.warn(`[table-worker] ${message}`)\n      }\n    }\n\n    const memoized = tableMemo({\n      table,\n      fnName: `table.get${capitalize(stage)}RowModel`,\n      // The per-stage version bumps only when this stage's payload actually\n      // changed, so stages the worker reported as `unchanged` skip the O(n)\n      // rebuild entirely (the re-render itself rides the state slice bump).\n      memoDeps: () => [\n        table.getCoreRowModel(),\n        getTableWorkerBridge(tableWorker, table).stageVersions[stage],\n      ],\n      fn: () => {\n        const bridge = getTableWorkerBridge(tableWorker, table)\n        const payload = bridge.results[stage]\n        if (!payload) {\n          if (bridge.resultRequestId > 0) {\n            warnOnce(\n              `The worker returned no '${stage}' result. Make sure the ` +\n                `worker's initTableWorker() config registers a ` +\n                `${stage}RowModel factory.`,\n            )\n          }\n          return (table as any)[`getPre${capitalize(stage)}RowModel`]()\n        }\n        // Contiguous-prefix check: any upstream stage registered on this\n        // table must also have a worker result, or it is silently bypassed.\n        if (bridge.resultRequestId > 0) {\n          for (const upstream of tableWorkerPipeline) {\n            if (upstream === stage) break\n            if (\n              (table.options.features as Record<string, unknown>)[\n                `${upstream}RowModel`\n              ] &&\n              !bridge.results[upstream]\n            ) {\n              warnOnce(\n                `This table has a ${upstream}RowModel, but the worker result ` +\n                  `for '${stage}' was computed without an offloaded ` +\n                  `'${upstream}' stage, so it is bypassed. Offload it too ` +\n                  `with createWorkerRowModel(tableWorker, '${upstream}').`,\n              )\n            }\n          }\n        }\n        return rebuildRowModel(table, payload, stage !== 'filtered')\n      },\n    })\n\n    return () => {\n      syncTableWorker(tableWorker, table)\n      return memoized()\n    }\n  }\n}\n"],"mappings":";;;;;;AAaA,SAAS,WAAW,OAAe;CACjC,OAAO,MAAM,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,MAAM,MAAM,CAAC;AACtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,qBACd,aACA,OACA;CACA,QACE,WACuC;EACvC,MAAM,QAAQ;EAId,qBAAqB,aAAa,KAAK,CAAC,CAAC,OAAO,IAAI,KAAK;EACzD,IAAI,SAAS;EAEb,MAAM,YAAY,YAAoB;GACpC,IAAI,QAAQ,IAAI,aAAa,iBAAiB,CAAC,QAAQ;IACrD,SAAS;IACT,QAAQ,KAAK,kBAAkB,SAAS;GAC1C;EACF;EAEA,MAAM,WAAW,UAAU;GACzB;GACA,QAAQ,YAAY,WAAW,KAAK,EAAE;GAItC,gBAAgB,CACd,MAAM,gBAAgB,GACtB,qBAAqB,aAAa,KAAK,CAAC,CAAC,cAAc,MACzD;GACA,UAAU;IACR,MAAM,SAAS,qBAAqB,aAAa,KAAK;IACtD,MAAM,UAAU,OAAO,QAAQ;IAC/B,IAAI,CAAC,SAAS;KACZ,IAAI,OAAO,kBAAkB,GAC3B,SACE,2BAA2B,MAAM,wEAE5B,MAAM,kBACb;KAEF,OAAQ,MAAc,SAAS,WAAW,KAAK,EAAE,UAAU,CAAC;IAC9D;IAGA,IAAI,OAAO,kBAAkB,GAC3B,KAAK,MAAM,YAAY,qBAAqB;KAC1C,IAAI,aAAa,OAAO;KACxB,IACG,MAAM,QAAQ,SACb,GAAG,SAAS,cAEd,CAAC,OAAO,QAAQ,WAEhB,SACE,oBAAoB,SAAS,uCACnB,MAAM,uCACV,SAAS,qFAC8B,SAAS,IACxD;IAEJ;IAEF,OAAO,gBAAgB,OAAO,SAAS,UAAU,UAAU;GAC7D;EACF,CAAC;EAED,aAAa;GACX,gBAAgB,aAAa,KAAK;GAClC,OAAO,SAAS;EAClB;CACF;AACF"}

package/dist/worker/initTableWorker.cjs

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

package/dist/worker/initTableWorker.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"initTableWorker.cjs","names":["makeObjectMap","constructTable","storeReactivityBindings","serializeRowModel"],"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        }) as unknown as Table_Internal<TFeatures, TData>\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        // columnGroupingFeature 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,gBAAwCA,4BAAc;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,QAAQC,sCAAiC;KACvC,GAAI;KACJ,UAAU;MACR,uBAAuBC,0DAAwB;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,gBAAgBF,4BAAc;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,SAASG,4CACd,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/initTableWorker.d.cts

@@ -0,0 +1,33 @@
+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.d.ts

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

package/dist/worker/initTableWorker.js

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

package/dist/worker/initTableWorker.js.map

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

package/dist/worker/rebuildRowModel.cjs

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