@tanstack/table-core 9.0.0-beta.47 → 9.0.0-beta.48

package/dist/types/TableFeatures.d.ts

@@ -2,7 +2,7 @@ import { CellData, RowData, UnionToIntersection } from "./type-utils.js";
 import { CoreFeatures } from "../core/coreFeatures.js";
 import { SortFn } from "../features/row-sorting/rowSortingFeature.types.js";
 import { ColumnDefBase_All } from "./ColumnDef.js";
-import { AggregationFn } from "../features/column-grouping/columnGroupingFeature.types.js";
+import { AggregationFnDef } from "../features/aggregation/aggregationFeature.types.js";
 import { Row } from "./Row.js";
 import { FilterFn } from "../features/column-filtering/columnFilteringFeature.types.js";
 import { RowModel } from "../core/row-models/coreRowModelsFeature.types.js";
@@ -61,9 +61,9 @@ type NonFeatureKeys = 'aggregationFns' | 'columnMeta' | 'coreRowModel' | 'expand
  */
 interface FeatureSlotPrereqs {
   /**
-   * Named aggregation functions are only meaningful when grouping is enabled.
+   * Named aggregation functions require the independent aggregation feature.
    */
-  aggregationFns: 'columnGroupingFeature';
+  aggregationFns: 'aggregationFeature';
   /**
    * Column resizing builds on the column sizing state and APIs.
    */
@@ -146,7 +146,7 @@ interface TableFeatures extends Partial<CoreFeatures>, Partial<StockFeatures>, P
    * Spreading the exported `aggregationFns` registry also works, but puts
    * every built-in aggregation function in your bundle.
    */
-  aggregationFns?: Record<string, AggregationFn<any, any>>;
+  aggregationFns?: Record<string, AggregationFnDef<any, any, any, any>>;
   /**
    * Type-only slot for declaring the type of `columnDef.meta` for all columns
    * of this table.

package/dist/types/TableOptions.d.cts

@@ -1,12 +1,13 @@
 import { RowData, UnionToIntersection } from "./type-utils.cjs";
 import { CoreFeatures } from "../core/coreFeatures.cjs";
+import { TableOptions_ColumnGrouping } from "../features/column-grouping/columnGroupingFeature.types.cjs";
 import { TableOptions_Cell } from "../core/cells/coreCellsFeature.types.cjs";
 import { TableOptions_ColumnPinning } from "../features/column-pinning/columnPinningFeature.types.cjs";
 import { TableOptions_ColumnSizing } from "../features/column-sizing/columnSizingFeature.types.cjs";
 import { TableOptions_ColumnResizing } from "../features/column-resizing/columnResizingFeature.types.cjs";
 import { TableOptions_GlobalFiltering } from "../features/global-filtering/globalFilteringFeature.types.cjs";
 import { TableOptions_RowSorting } from "../features/row-sorting/rowSortingFeature.types.cjs";
-import { TableOptions_ColumnGrouping } from "../features/column-grouping/columnGroupingFeature.types.cjs";
+import { TableOptions_Aggregation } from "../features/aggregation/aggregationFeature.types.cjs";
 import { TableOptions_ColumnVisibility } from "../features/column-visibility/columnVisibilityFeature.types.cjs";
 import { TableOptions_RowExpanding } from "../features/row-expanding/rowExpandingFeature.types.cjs";
 import { TableOptions_RowPinning } from "../features/row-pinning/rowPinningFeature.types.cjs";
@@ -36,6 +37,7 @@ type DebugOptions<TFeatures extends TableFeatures> = {
   debugTable?: boolean;
 } & DebugKeysFor<CoreFeatures & TFeatures>;
 interface TableOptions_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+  aggregationFeature: TableOptions_Aggregation;
   columnFilteringFeature: TableOptions_ColumnFiltering<TFeatures, TData>;
   columnGroupingFeature: TableOptions_ColumnGrouping;
   columnOrderingFeature: TableOptions_ColumnOrdering;
@@ -50,7 +52,7 @@ interface TableOptions_FeatureMap<in out TFeatures extends TableFeatures, in out
   rowSelectionFeature: TableOptions_RowSelection<TFeatures, TData>;
   rowSortingFeature: TableOptions_RowSorting;
 }
-type TableOptions_StockFeatureKeys = 'columnFilteringFeature' | 'columnGroupingFeature' | 'columnOrderingFeature' | 'columnPinningFeature' | 'columnResizingFeature' | 'columnSizingFeature' | 'columnVisibilityFeature' | 'globalFilteringFeature' | 'rowExpandingFeature' | 'rowPaginationFeature' | 'rowPinningFeature' | 'rowSelectionFeature' | 'rowSortingFeature';
+type TableOptions_StockFeatureKeys = 'aggregationFeature' | 'columnFilteringFeature' | 'columnGroupingFeature' | 'columnOrderingFeature' | 'columnPinningFeature' | 'columnResizingFeature' | 'columnSizingFeature' | 'columnVisibilityFeature' | 'globalFilteringFeature' | 'rowExpandingFeature' | 'rowPaginationFeature' | 'rowPinningFeature' | 'rowSelectionFeature' | 'rowSortingFeature';
 /**
  * Plugin entries declaration-merged into `TableOptions_FeatureMap`, i.e. keys
  * beyond the stock set. Resolves to `unknown` (an intersection no-op) when no
@@ -69,7 +71,7 @@ type TableOptions<TFeatures extends TableFeatures, TData extends RowData> = Tabl
  * Internal broad option shape used where feature code may need to read options
  * from features that are not present in the current generic feature set.
  */
-type TableOptions_All<TFeatures extends TableFeatures, TData extends RowData> = TableOptions_Core<TFeatures, TData> & Partial<TableOptions_ColumnFiltering<TFeatures, TData> & TableOptions_ColumnGrouping & TableOptions_ColumnOrdering & TableOptions_ColumnPinning & TableOptions_ColumnResizing & TableOptions_ColumnSizing & TableOptions_ColumnVisibility & TableOptions_GlobalFiltering<TFeatures, TData> & TableOptions_RowExpanding<TFeatures, TData> & TableOptions_RowPagination & TableOptions_RowPinning<TFeatures, TData> & TableOptions_RowSelection<TFeatures, TData> & TableOptions_RowSorting & TableOptions_PluginFeatureMapTypes<TFeatures, TData>>;
+type TableOptions_All<TFeatures extends TableFeatures, TData extends RowData> = TableOptions_Core<TFeatures, TData> & Partial<TableOptions_Aggregation & TableOptions_ColumnFiltering<TFeatures, TData> & TableOptions_ColumnGrouping & TableOptions_ColumnOrdering & TableOptions_ColumnPinning & TableOptions_ColumnResizing & TableOptions_ColumnSizing & TableOptions_ColumnVisibility & TableOptions_GlobalFiltering<TFeatures, TData> & TableOptions_RowExpanding<TFeatures, TData> & TableOptions_RowPagination & TableOptions_RowPinning<TFeatures, TData> & TableOptions_RowSelection<TFeatures, TData> & TableOptions_RowSorting & TableOptions_PluginFeatureMapTypes<TFeatures, TData>>;
 //#endregion
 export { DebugOptions, TableOptions, TableOptions_All, TableOptions_Core, TableOptions_FeatureMap };
 //# sourceMappingURL=TableOptions.d.cts.map

package/dist/types/TableOptions.d.ts

@@ -1,12 +1,13 @@
 import { RowData, UnionToIntersection } from "./type-utils.js";
 import { CoreFeatures } from "../core/coreFeatures.js";
+import { TableOptions_ColumnGrouping } from "../features/column-grouping/columnGroupingFeature.types.js";
 import { TableOptions_Cell } from "../core/cells/coreCellsFeature.types.js";
 import { TableOptions_ColumnPinning } from "../features/column-pinning/columnPinningFeature.types.js";
 import { TableOptions_ColumnSizing } from "../features/column-sizing/columnSizingFeature.types.js";
 import { TableOptions_ColumnResizing } from "../features/column-resizing/columnResizingFeature.types.js";
 import { TableOptions_GlobalFiltering } from "../features/global-filtering/globalFilteringFeature.types.js";
 import { TableOptions_RowSorting } from "../features/row-sorting/rowSortingFeature.types.js";
-import { TableOptions_ColumnGrouping } from "../features/column-grouping/columnGroupingFeature.types.js";
+import { TableOptions_Aggregation } from "../features/aggregation/aggregationFeature.types.js";
 import { TableOptions_ColumnVisibility } from "../features/column-visibility/columnVisibilityFeature.types.js";
 import { TableOptions_RowExpanding } from "../features/row-expanding/rowExpandingFeature.types.js";
 import { TableOptions_RowPinning } from "../features/row-pinning/rowPinningFeature.types.js";
@@ -36,6 +37,7 @@ type DebugOptions<TFeatures extends TableFeatures> = {
   debugTable?: boolean;
 } & DebugKeysFor<CoreFeatures & TFeatures>;
 interface TableOptions_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+  aggregationFeature: TableOptions_Aggregation;
   columnFilteringFeature: TableOptions_ColumnFiltering<TFeatures, TData>;
   columnGroupingFeature: TableOptions_ColumnGrouping;
   columnOrderingFeature: TableOptions_ColumnOrdering;
@@ -50,7 +52,7 @@ interface TableOptions_FeatureMap<in out TFeatures extends TableFeatures, in out
   rowSelectionFeature: TableOptions_RowSelection<TFeatures, TData>;
   rowSortingFeature: TableOptions_RowSorting;
 }
-type TableOptions_StockFeatureKeys = 'columnFilteringFeature' | 'columnGroupingFeature' | 'columnOrderingFeature' | 'columnPinningFeature' | 'columnResizingFeature' | 'columnSizingFeature' | 'columnVisibilityFeature' | 'globalFilteringFeature' | 'rowExpandingFeature' | 'rowPaginationFeature' | 'rowPinningFeature' | 'rowSelectionFeature' | 'rowSortingFeature';
+type TableOptions_StockFeatureKeys = 'aggregationFeature' | 'columnFilteringFeature' | 'columnGroupingFeature' | 'columnOrderingFeature' | 'columnPinningFeature' | 'columnResizingFeature' | 'columnSizingFeature' | 'columnVisibilityFeature' | 'globalFilteringFeature' | 'rowExpandingFeature' | 'rowPaginationFeature' | 'rowPinningFeature' | 'rowSelectionFeature' | 'rowSortingFeature';
 /**
  * Plugin entries declaration-merged into `TableOptions_FeatureMap`, i.e. keys
  * beyond the stock set. Resolves to `unknown` (an intersection no-op) when no
@@ -69,7 +71,7 @@ type TableOptions<TFeatures extends TableFeatures, TData extends RowData> = Tabl
  * Internal broad option shape used where feature code may need to read options
  * from features that are not present in the current generic feature set.
  */
-type TableOptions_All<TFeatures extends TableFeatures, TData extends RowData> = TableOptions_Core<TFeatures, TData> & Partial<TableOptions_ColumnFiltering<TFeatures, TData> & TableOptions_ColumnGrouping & TableOptions_ColumnOrdering & TableOptions_ColumnPinning & TableOptions_ColumnResizing & TableOptions_ColumnSizing & TableOptions_ColumnVisibility & TableOptions_GlobalFiltering<TFeatures, TData> & TableOptions_RowExpanding<TFeatures, TData> & TableOptions_RowPagination & TableOptions_RowPinning<TFeatures, TData> & TableOptions_RowSelection<TFeatures, TData> & TableOptions_RowSorting & TableOptions_PluginFeatureMapTypes<TFeatures, TData>>;
+type TableOptions_All<TFeatures extends TableFeatures, TData extends RowData> = TableOptions_Core<TFeatures, TData> & Partial<TableOptions_Aggregation & TableOptions_ColumnFiltering<TFeatures, TData> & TableOptions_ColumnGrouping & TableOptions_ColumnOrdering & TableOptions_ColumnPinning & TableOptions_ColumnResizing & TableOptions_ColumnSizing & TableOptions_ColumnVisibility & TableOptions_GlobalFiltering<TFeatures, TData> & TableOptions_RowExpanding<TFeatures, TData> & TableOptions_RowPagination & TableOptions_RowPinning<TFeatures, TData> & TableOptions_RowSelection<TFeatures, TData> & TableOptions_RowSorting & TableOptions_PluginFeatureMapTypes<TFeatures, TData>>;
 //#endregion
 export { DebugOptions, TableOptions, TableOptions_All, TableOptions_Core, TableOptions_FeatureMap };
 //# sourceMappingURL=TableOptions.d.ts.map

package/dist/types/TableState.d.cts

@@ -1,9 +1,9 @@
+import { TableState_ColumnGrouping } from "../features/column-grouping/columnGroupingFeature.types.cjs";
 import { TableState_ColumnPinning } from "../features/column-pinning/columnPinningFeature.types.cjs";
 import { TableState_ColumnSizing } from "../features/column-sizing/columnSizingFeature.types.cjs";
 import { TableState_ColumnResizing } from "../features/column-resizing/columnResizingFeature.types.cjs";
 import { TableState_GlobalFiltering } from "../features/global-filtering/globalFilteringFeature.types.cjs";
 import { TableState_RowSorting } from "../features/row-sorting/rowSortingFeature.types.cjs";
-import { TableState_ColumnGrouping } from "../features/column-grouping/columnGroupingFeature.types.cjs";
 import { TableState_ColumnVisibility } from "../features/column-visibility/columnVisibilityFeature.types.cjs";
 import { TableState_RowExpanding } from "../features/row-expanding/rowExpandingFeature.types.cjs";
 import { TableState_RowPinning } from "../features/row-pinning/rowPinningFeature.types.cjs";

package/dist/types/TableState.d.ts

@@ -1,9 +1,9 @@
+import { TableState_ColumnGrouping } from "../features/column-grouping/columnGroupingFeature.types.js";
 import { TableState_ColumnPinning } from "../features/column-pinning/columnPinningFeature.types.js";
 import { TableState_ColumnSizing } from "../features/column-sizing/columnSizingFeature.types.js";
 import { TableState_ColumnResizing } from "../features/column-resizing/columnResizingFeature.types.js";
 import { TableState_GlobalFiltering } from "../features/global-filtering/globalFilteringFeature.types.js";
 import { TableState_RowSorting } from "../features/row-sorting/rowSortingFeature.types.js";
-import { TableState_ColumnGrouping } from "../features/column-grouping/columnGroupingFeature.types.js";
 import { TableState_ColumnVisibility } from "../features/column-visibility/columnVisibilityFeature.types.js";
 import { TableState_RowExpanding } from "../features/row-expanding/rowExpandingFeature.types.js";
 import { TableState_RowPinning } from "../features/row-pinning/rowPinningFeature.types.js";

package/dist/worker/initTableWorker.cjs.map

@@ -1 +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        })\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"}
+{"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        })\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        // aggregationFeature 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.js.map

@@ -1 +1 @@
-{"version":3,"file":"initTableWorker.js","names":[],"sources":["../../src/worker/initTableWorker.ts"],"sourcesContent":["import { constructTable } from '../core/table/constructTable'\nimport { storeReactivityBindings } from '../store-reactivity-bindings'\nimport { makeObjectMap } from '../utils'\nimport { serializeRowModel } from './serializeRowModel'\nimport type { RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { TableOptions } from '../types/TableOptions'\nimport type { Table_Internal } from '../types/Table'\nimport type {\n  TableWorkerRequest,\n  TableWorkerResult,\n  TableWorkerStage,\n  TableWorkerStagePayload,\n} from './tableWorkerProtocol'\n\nexport type TableWorkerConfig<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> = Omit<TableOptions<TFeatures, TData>, 'data'>\n\nfunction capitalize(stage: string) {\n  return stage.charAt(0).toUpperCase() + stage.slice(1)\n}\n\n/** Flatten column-group defs to leaf defs (mirrors core's id resolution). */\nfunction flattenColumnDefs(defs: Array<any>): Array<any> {\n  return defs.flatMap((def) =>\n    def.columns ? flattenColumnDefs(def.columns) : [def],\n  )\n}\n\n/**\n * Runs a headless \"shadow table\" inside a dedicated Web Worker.\n *\n * Call this from a user-authored worker entry file, passing the same columns\n * and processing features used on the main thread. The shadow table runs the\n * real table-core row model pipeline (real fns, real Row objects) off the\n * main thread and posts back one payload per stage the main thread requested:\n * a transferable index permutation for flat results, a serialized row tree\n * (with eagerly computed aggregates) when grouping produces synthetic rows.\n *\n * Everything passed here must be thread-portable: `accessorKey` columns or\n * accessors defined in a shared module, and fns from registries or shared\n * modules (no closures over app state).\n *\n * @example\n * ```ts\n * // table.worker.ts\n * import { initTableWorker } from '@tanstack/table-core/experimental-worker-plugin'\n * import { columns, sharedFeatures } from './tableConfig'\n *\n * initTableWorker({ features: sharedFeatures, columns })\n * ```\n */\nexport function initTableWorker<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(config: TableWorkerConfig<TFeatures, TData>): void {\n  let table: Table_Internal<TFeatures, TData> | undefined\n  let dataVersion = 0\n  let coreIndexById: Record<string, number> = makeObjectMap()\n  let aggregateColumnIds: Array<string> = []\n  // Last-sent model identity per stage: the memoized getters return stable\n  // objects when their inputs did not change, so identity equality is exactly\n  // \"this stage's result is unchanged\".\n  let lastSentModels: { [K in TableWorkerStage]?: unknown } = {}\n\n  self.onmessage = (event: MessageEvent<TableWorkerRequest<TData>>) => {\n    const message = event.data\n\n    if (message.type === 'data') {\n      dataVersion = message.dataVersion\n      lastSentModels = {}\n      if (!table) {\n        table = constructTable<TFeatures, TData>({\n          ...(config as TableOptions<TFeatures, TData>),\n          features: {\n            coreReactivityFeature: storeReactivityBindings(),\n            ...config.features,\n          },\n          data: message.data,\n        })\n        // Only columns with an explicit aggregation get eagerly aggregated\n        // per group. Sync tables aggregate lazily (visible cells only), so\n        // auto-aggregating every column would explode on high-cardinality\n        // grouping for values nothing renders. Read the RAW column defs:\n        // 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"}
+{"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        // aggregationFeature 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/table-core",
-  "version": "9.0.0-beta.47",
+  "version": "9.0.0-beta.48",
   "description": "Headless UI for building powerful tables & datagrids for TS/JS.",
   "author": "Tanner Linsley",
   "license": "MIT",

package/skills/aggregation/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: aggregation
+description: >
+  Aggregate TanStack Table columns independently of grouping, including grand totals, caller-selected row totals, multiple keyed aggregations, custom context-based definitions, grouped merges, manual values, and worker constraints.
+metadata:
+  {
+    type: sub-skill,
+    library: '@tanstack/table-core',
+    library_version: '9.0.0-beta.48',
+  }
+requires: ['core', 'table-features']
+sources:
+  - 'TanStack/table:docs/guide/aggregation.md'
+  - 'TanStack/table:docs/framework/react/guide/aggregation.md'
+  - 'TanStack/table:packages/table-core/src/features/aggregation'
+  - 'TanStack/table:examples/react/aggregation'
+  - 'TanStack/table:examples/react/grouped-aggregation'
+---
+
+This skill builds on `core` and `table-features`. Aggregation is independent
+from grouping: use it alone for totals, or combine it with the `grouping` skill
+for synthetic grouped rows.
+
+## Setup
+
+<!-- skill-snippet:check -->
+
+```ts
+import {
+  aggregationFeature,
+  aggregationFn_mean,
+  aggregationFn_sum,
+  tableFeatures,
+} from '@tanstack/table-core'
+
+export const features = tableFeatures({
+  aggregationFeature,
+  aggregationFns: {
+    mean: aggregationFn_mean,
+    sum: aggregationFn_sum,
+  },
+})
+```
+
+## Core Patterns
+
+### Grand total and selected row scopes
+
+```ts
+const grandTotal = salaryColumn.getAggregationValue()
+const filteredTotal = salaryColumn.getAggregationValue(
+  table.getFilteredRowModel().rows,
+)
+```
+
+The default uses the pre-grouped row model. Explicit rows can come from any row
+model or caller-selected subset. Hierarchical inputs are normalized to unique
+terminal rows. Default calls are cached; explicit-row calls intentionally are
+not because array identity and contents are caller-owned.
+
+### Multiple aggregations
+
+```ts
+columnHelper.accessor('salary', {
+  aggregationFn: ['mean', { id: 'range', aggregationFn: 'extent' }],
+})
+
+const value = salaryColumn.getAggregationValue<{
+  mean: number
+  range: [number, number]
+}>()
+```
+
+A scalar option returns a scalar. An array returns a keyed object. Named
+functions use their registry name; descriptors provide a stable `id`, which is
+required for inline definitions in an array.
+
+### Custom definitions
+
+```ts
+const weightedMean = constructAggregationFn({
+  aggregate: ({ rows, getValue }) => {
+    const total = rows.reduce((sum, row) => sum + Number(getValue(row)), 0)
+    return rows.length ? total / rows.length : undefined
+  },
+})
+```
+
+The context provides `rows`, `getValue`, `column`, `columnId`, `table`, and an
+optional `groupingRow`. Add `merge({ childResults, childRows, ...context })`
+when nested groups can efficiently combine child results; otherwise the engine
+re-runs `aggregate` over normalized terminal rows.
+
+### Manual or remote values
+
+Set a column definition's `getAggregationValue(context)` to return `{ value }`
+for requests handled by a server or another execution environment. Returning
+`undefined` falls back to the local definition. `manualAggregation: true`
+disables that local fallback.
+
+## Common Mistakes
+
+### [HIGH] Adding grouping for a grand total
+
+Wrong: registering `columnGroupingFeature` solely to total a column.
+
+Correct: register `aggregationFeature` and call
+`column.getAggregationValue()`. Grouping is only required for grouped rows.
+
+### [HIGH] Passing a scope label and rows
+
+There is no scope option. Call `getAggregationValue()` for the default or pass
+the exact rows from the desired row model.
+
+### [HIGH] Reusing the legacy callable signature
+
+Wrong: `(columnId, leafRows, childRows) => result`.
+
+Correct: `constructAggregationFn({ aggregate: ({ rows, getValue }) => result })`.
+
+### [MEDIUM] Assuming arbitrary totals run in the worker
+
+The experimental worker computes grouped row-model aggregates. Public
+`getAggregationValue(rows?)` totals execute on the main thread, and custom
+grouped results sent by the worker must be structured-cloneable.
+
+## API Discovery
+
+Inspect `node_modules/@tanstack/table-core/src/features/aggregation/` and the
+Aggregation Guide. Use `Column_Aggregation`, `AggregationFnDef`,
+`AggregationContext`, and `AggregationResult` for the typed public surface.

package/skills/api-not-found/SKILL.md

@@ -5,7 +5,7 @@ description: >
 metadata:
   type: sub-skill
   library: '@tanstack/table-core'
-  library_version: '9.0.0-beta.47'
+  library_version: '9.0.0-beta.48'
 requires: ['core', 'table-features']
 sources:
   - 'TanStack/table:packages/table-core/src/index.ts'

package/skills/client-vs-server/SKILL.md

@@ -5,7 +5,7 @@ description: >
 metadata:
   type: sub-skill
   library: '@tanstack/table-core'
-  library_version: '9.0.0-beta.47'
+  library_version: '9.0.0-beta.48'
 requires: ['core', 'table-features']
 sources:
   - 'TanStack/table:docs/guide/row-models.md'

package/skills/column-faceting/SKILL.md

@@ -6,7 +6,7 @@ metadata:
   {
     type: sub-skill,
     library: '@tanstack/table-core',
-    library_version: '9.0.0-beta.47',
+    library_version: '9.0.0-beta.48',
   }
 requires: ['core', 'table-features', 'column-filtering']
 sources:

package/skills/column-filtering/SKILL.md

@@ -6,7 +6,7 @@ metadata:
   {
     type: sub-skill,
     library: '@tanstack/table-core',
-    library_version: '9.0.0-beta.47',
+    library_version: '9.0.0-beta.48',
   }
 requires: ['core', 'table-features', 'client-vs-server']
 sources:

package/skills/column-ordering/SKILL.md

@@ -6,7 +6,7 @@ metadata:
   {
     type: sub-skill,
     library: '@tanstack/table-core',
-    library_version: '9.0.0-beta.47',
+    library_version: '9.0.0-beta.48',
   }
 requires: ['core', 'table-features']
 sources:

package/skills/column-pinning/SKILL.md

@@ -6,7 +6,7 @@ metadata:
   {
     type: sub-skill,
     library: '@tanstack/table-core',
-    library_version: '9.0.0-beta.47',
+    library_version: '9.0.0-beta.48',
   }
 requires: ['core', 'table-features', 'column-sizing']
 sources:

package/skills/column-resizing/SKILL.md

@@ -6,7 +6,7 @@ metadata:
   {
     type: sub-skill,
     library: '@tanstack/table-core',
-    library_version: '9.0.0-beta.47',
+    library_version: '9.0.0-beta.48',
   }
 requires: ['core', 'table-features', 'column-sizing']
 sources:

package/skills/column-sizing/SKILL.md

@@ -6,7 +6,7 @@ metadata:
   {
     type: sub-skill,
     library: '@tanstack/table-core',
-    library_version: '9.0.0-beta.47',
+    library_version: '9.0.0-beta.48',
   }
 requires: ['core', 'table-features']
 sources:

package/skills/column-visibility/SKILL.md

@@ -6,7 +6,7 @@ metadata:
   {
     type: sub-skill,
     library: '@tanstack/table-core',
-    library_version: '9.0.0-beta.47',
+    library_version: '9.0.0-beta.48',
   }
 requires: ['core', 'table-features']
 sources:

package/skills/core/SKILL.md

@@ -5,7 +5,7 @@ description: >
 metadata:
   type: core
   library: '@tanstack/table-core'
-  library_version: '9.0.0-beta.47'
+  library_version: '9.0.0-beta.48'
 sources:
   - 'TanStack/table:docs/overview.md'
   - 'TanStack/table:docs/guide/tables.md'

package/skills/custom-features/SKILL.md

@@ -5,7 +5,7 @@ description: >
 metadata:
   type: sub-skill
   library: '@tanstack/table-core'
-  library_version: '9.0.0-beta.47'
+  library_version: '9.0.0-beta.48'
 requires: ['core', 'table-features', 'typescript']
 sources:
   - 'TanStack/table:docs/framework/react/guide/custom-features.md'

package/skills/expanding/SKILL.md

@@ -6,7 +6,7 @@ metadata:
   {
     type: sub-skill,
     library: '@tanstack/table-core',
-    library_version: '9.0.0-beta.47',
+    library_version: '9.0.0-beta.48',
   }
 requires: ['core', 'table-features', 'client-vs-server']
 sources:

package/skills/global-filtering/SKILL.md

@@ -6,7 +6,7 @@ metadata:
   {
     type: sub-skill,
     library: '@tanstack/table-core',
-    library_version: '9.0.0-beta.47',
+    library_version: '9.0.0-beta.48',
   }
 requires: ['core', 'table-features', 'client-vs-server', 'column-filtering']
 sources:

package/skills/grouping/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: grouping
 description: >
-  Group and aggregate rows with columnGroupingFeature, groupedRowModel, aggregationFns, groupedColumnMode, and manualGrouping. Load for grouped, placeholder, or aggregated cells and grouping interactions with expansion or pagination.
+  Group rows with columnGroupingFeature, groupedRowModel, groupedColumnMode, and manualGrouping. Load for grouped or placeholder cells and grouping interactions with expansion or pagination.
 metadata:
   {
     type: sub-skill,
     library: '@tanstack/table-core',
-    library_version: '9.0.0-beta.47',
+    library_version: '9.0.0-beta.48',
   }
 requires: ['core', 'table-features', 'client-vs-server']
 sources:
@@ -15,13 +15,12 @@ sources:
   - 'TanStack/table:examples/react/grouping'
 ---
 
-This skill builds on `core`, `table-features`, and `client-vs-server`. Grouping creates row structure and aggregate values; the renderer chooses grouped-cell UI.
+This skill builds on `core`, `table-features`, and `client-vs-server`. Grouping creates row structure and the renderer chooses grouped-cell UI. Load the separate `aggregation` skill when grouped rows should also calculate values.
 
 ## Setup
 
 ```ts
 import {
-  aggregationFn_sum,
   columnGroupingFeature,
   createGroupedRowModel,
   tableFeatures,
@@ -30,26 +29,18 @@ import {
 export const features = tableFeatures({
   columnGroupingFeature,
   groupedRowModel: createGroupedRowModel(),
-  aggregationFns: { sum: aggregationFn_sum },
 })
 ```
 
-Import individual `aggregationFn_*` built-ins and register only those your
-columns reference by string name or that `aggregationFn: 'auto'` should
-resolve (numbers resolve to `sum`, dates to `extent`). The full
-`aggregationFns` registry object still works but bundles every built-in.
-
 ## Core Patterns
 
 ```ts
 const options = { groupedColumnMode: 'reorder' as const }
 const mode = cell.getIsGrouped()
   ? 'grouped'
-  : cell.getIsAggregated()
-    ? 'aggregated'
-    : cell.getIsPlaceholder()
-      ? 'placeholder'
-      : 'value'
+  : cell.getIsPlaceholder()
+    ? 'placeholder'
+    : 'value'
 ```
 
 Render these cell modes deliberately.
@@ -62,7 +53,7 @@ Wrong: `tableFeatures({ groupedRowModel: createGroupedRowModel() })`
 
 Correct: `tableFeatures({ columnGroupingFeature, groupedRowModel: createGroupedRowModel() })`
 
-The grouped slot and aggregation registry require `columnGroupingFeature`.
+The grouped row-model slot requires `columnGroupingFeature`.
 
 Source: `packages/table-core/src/types/TableFeatures.ts#FeatureSlotPrereqs`
 
@@ -95,10 +86,13 @@ Wrong: `render(cell.getValue())`
 
 Correct: `render(cell.getIsPlaceholder() ? null : cell.getValue())`
 
-Placeholder and aggregated cells do not represent ordinary leaf values.
+Placeholder cells do not represent ordinary leaf values. Group rows should
+only render their grouped cell when aggregation is not enabled.
 
 Source: `examples/react/grouping/src/main.tsx`
 
 ## API Discovery
 
-Inspect `node_modules/@tanstack/table-core/src/features/column-grouping/` and `src/fns/aggregationFns.ts`.
+Inspect `node_modules/@tanstack/table-core/src/features/column-grouping/` for
+grouping. Load the `aggregation` skill when totals, multiple aggregations,
+grouped aggregate values, or custom definitions are part of the task.