@tanstack/table-core 9.0.0-beta.7 → 9.0.0-beta.70

package/dist/core/rows/coreRowsFeature.types.d.ts

@@ -1,11 +1,22 @@
 import { RowData } from "../../types/type-utils.js";
+import { Column } from "../../types/Column.js";
 import { Row } from "../../types/Row.js";
-import { TableFeatures } from "../../types/TableFeatures.js";
-import { Table_Internal } from "../../types/Table.js";
+import { Table } from "../../types/Table.js";
 import { Cell } from "../../types/Cell.js";
-
+import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/core/rows/coreRowsFeature.types.d.ts
-interface Row_CoreProperties<TFeatures extends TableFeatures, TData extends RowData> {
+interface Row_CoreProperties<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+  _cellsCache?: WeakMap<Column<TFeatures, TData, unknown>, Cell<TFeatures, TData, unknown>>;
+  /**
+   * Internal cache used while resolving the current display order.
+   *
+   * This value may be stale until display order is recomputed. Use
+   * `row.getDisplayIndex()` instead; it refreshes and validates the cached
+   * position before returning it.
+   *
+   * @internal
+   */
+  _displayIndexCache: number;
   _uniqueValuesCache: Record<string, unknown>;
   _valuesCache: Record<string, unknown>;
   /**
@@ -39,9 +50,16 @@ interface Row_CoreProperties<TFeatures extends TableFeatures, TData extends RowD
   /**
    * Reference to the parent table instance.
    */
-  table: Table_Internal<TFeatures, TData>;
+  table: Table<TFeatures, TData>;
 }
-interface Row_Row<TFeatures extends TableFeatures, TData extends RowData> extends Row_CoreProperties<TFeatures, TData> {
+interface Row_Row<in out TFeatures extends TableFeatures, in out TData extends RowData> extends Row_CoreProperties<TFeatures, TData> {
+  /**
+   * Returns the zero-based index of the row in the current display order
+   * before pagination, or `-1` if the row is not in that model. Use this for
+   * display row-number columns instead of `row.index` or the internal
+   * `_displayIndexCache` field.
+   */
+  getDisplayIndex: () => number;
   /**
    * Builds a lookup of this row's cells keyed by leaf column id.
    */
@@ -75,7 +93,7 @@ interface Row_Row<TFeatures extends TableFeatures, TData extends RowData> extend
    */
   renderValue: <TValue>(columnId: string) => TValue;
 }
-interface TableOptions_Rows<TFeatures extends TableFeatures, TData extends RowData> {
+interface TableOptions_Rows<in out TFeatures extends TableFeatures, in out TData extends RowData> {
   /**
    * This optional function is used to derive a unique ID for any given row. If not provided the rows index is used (nested rows join together with `.` using their grandparents' index eg. `index.index.index`). If you need to identify individual rows that are originating from any server-side operations, it's suggested you use this function to return an ID that makes sense regardless of network IO/ambiguity eg. a userId, taskId, database ID field, etc.
    * @example getRowId: row => row.userId
@@ -87,7 +105,22 @@ interface TableOptions_Rows<TFeatures extends TableFeatures, TData extends RowDa
    */
   getSubRows?: (originalRow: TData, index: number) => undefined | ReadonlyArray<TData>;
 }
-interface Table_Rows<TFeatures extends TableFeatures, TData extends RowData> {
+interface Table_Rows<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+  /**
+   * Returns the deepest structural row depth in the core row model.
+   * Root rows are depth `0`, direct sub-rows are depth `1`, and so on.
+   */
+  getMaxSubRowDepth: () => number;
+  /**
+   * Returns the rows in the current display order and assigns their display
+   * indexes. When expanded rows bypass pagination, expanded descendants are
+   * included in this order. This is the memoized source for
+   * `row.getDisplayIndex()`.
+   */
+  getRowsInDisplayOrder: () => Array<Row<TFeatures, TData>>;
+  /**
+   * Returns the row id for a given row.
+   */
   getRowId: (_: TData, index: number, parent?: Row<TFeatures, TData>) => string;
   /**
    * Returns the row with the given ID.
@@ -95,5 +128,4 @@ interface Table_Rows<TFeatures extends TableFeatures, TData extends RowData> {
   getRow: (id: string, searchAll?: boolean) => Row<TFeatures, TData>;
 }
 //#endregion
-export { Row_CoreProperties, Row_Row, TableOptions_Rows, Table_Rows };
-//# sourceMappingURL=coreRowsFeature.types.d.ts.map
+export { Row_CoreProperties, Row_Row, TableOptions_Rows, Table_Rows };

package/dist/core/rows/coreRowsFeature.utils.d.ts

@@ -1,10 +1,23 @@
 import { RowData } from "../../types/type-utils.js";
 import { Row } from "../../types/Row.js";
-import { TableFeatures } from "../../types/TableFeatures.js";
-import { Table_Internal } from "../../types/Table.js";
+import { Table } from "../../types/Table.js";
 import { Cell } from "../../types/Cell.js";
-
+import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/core/rows/coreRowsFeature.utils.d.ts
+/**
+ * Returns this row's zero-based position in the current pre-pagination row
+ * model. Rows outside that model return `-1`.
+ */
+declare function row_getDisplayIndex<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>): number;
+/**
+ * Returns the rows in the current display order after assigning their
+ * zero-based display indexes.
+ *
+ * When expanded rows bypass pagination, expanded descendants are inserted into
+ * the returned order even though they are absent from the pre-pagination row
+ * model.
+ */
+declare function table_getRowsInDisplayOrder<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): Row<TFeatures, TData>[];
 /**
  * Reads and caches this row's value for a column.
  *
@@ -52,11 +65,16 @@ declare function row_renderValue<TFeatures extends TableFeatures, TData extends
  * ```
  */
 declare function row_getLeafRows<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>): Array<Row<TFeatures, TData>>;
+/**
+ * Returns the deepest structural row depth in the core row model.
+ * Root rows are depth `0`, their direct sub-rows are depth `1`, and so on.
+ */
+declare function table_getMaxSubRowDepth<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): number;
 /**
  * Looks up this row's direct parent, if it has one.
  *
- * Parent lookup searches the pre-pagination row model so parent relationships
- * are available even when the parent is not on the current page.
+ * Parent lookup prefers the core row model for structural parents, then falls
+ * back to the pre-pagination row model for generated parent rows.
  *
  * @example
  * ```ts
@@ -109,7 +127,7 @@ declare function row_getAllCellsByColumnId<TFeatures extends TableFeatures, TDat
  * const id = table_getRowId(originalRow, table, index, parentRow)
  * ```
  */
-declare function table_getRowId<TFeatures extends TableFeatures, TData extends RowData>(originalRow: TData, table: Table_Internal<TFeatures, TData>, index: number, parent?: Row<TFeatures, TData>): string;
+declare function table_getRowId<TFeatures extends TableFeatures, TData extends RowData>(originalRow: TData, table: Table<TFeatures, TData>, index: number, parent?: Row<TFeatures, TData>): string;
 /**
  * Looks up a row by id from the current or full row model.
  *
@@ -121,7 +139,6 @@ declare function table_getRowId<TFeatures extends TableFeatures, TData extends R
  * const row = table_getRow(table, rowId, true)
  * ```
  */
-declare function table_getRow<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, rowId: string, searchAll?: boolean): Row<TFeatures, TData>;
+declare function table_getRow<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, rowId: string, searchAll?: boolean): Row<TFeatures, TData>;
 //#endregion
-export { row_getAllCells, row_getAllCellsByColumnId, row_getLeafRows, row_getParentRow, row_getParentRows, row_getUniqueValues, row_getValue, row_renderValue, table_getRow, table_getRowId };
-//# sourceMappingURL=coreRowsFeature.utils.d.ts.map
+export { row_getAllCells, row_getAllCellsByColumnId, row_getDisplayIndex, row_getLeafRows, row_getParentRow, row_getParentRows, row_getUniqueValues, row_getValue, row_renderValue, table_getMaxSubRowDepth, table_getRow, table_getRowId, table_getRowsInDisplayOrder };

package/dist/core/rows/coreRowsFeature.utils.js

@@ -1,8 +1,40 @@
-import { flattenBy } from "../../utils.js";
+import { flattenBy, hasOwn, makeObjectMap } from "../../utils.js";
 import { constructCell } from "../cells/constructCell.js";
 
 //#region src/core/rows/coreRowsFeature.utils.ts
 /**
+* Returns this row's zero-based position in the current pre-pagination row
+* model. Rows outside that model return `-1`.
+*/
+function row_getDisplayIndex(row) {
+	const rows = row.table.getRowsInDisplayOrder();
+	const displayIndex = row._displayIndexCache;
+	return rows[displayIndex] === row ? displayIndex : -1;
+}
+/**
+* Returns the rows in the current display order after assigning their
+* zero-based display indexes.
+*
+* When expanded rows bypass pagination, expanded descendants are inserted into
+* the returned order even though they are absent from the pre-pagination row
+* model.
+*/
+function table_getRowsInDisplayOrder(table) {
+	const rows = table.getPrePaginatedRowModel().rows;
+	if (table.options.paginateExpandedRows === false) {
+		const displayRows = [];
+		const handleRow = (row) => {
+			row._displayIndexCache = displayRows.length;
+			displayRows.push(row);
+			if (row.subRows.length && row.getIsExpanded?.()) row.subRows.forEach(handleRow);
+		};
+		rows.forEach(handleRow);
+		return displayRows;
+	}
+	for (let i = 0; i < rows.length; i++) rows[i]._displayIndexCache = i;
+	return rows;
+}
+/**
 * Reads and caches this row's value for a column.
 *
 * The value is produced by the column accessor. Missing columns or display
@@ -14,9 +46,9 @@ import { constructCell } from "../cells/constructCell.js";
 * ```
 */
 function row_getValue(row, columnId) {
-	if (row._valuesCache.hasOwnProperty(columnId)) return row._valuesCache[columnId];
+	if (hasOwn(row._valuesCache, columnId)) return row._valuesCache[columnId];
 	const column = row.table.getColumn(columnId);
-	if (!(column === null || column === void 0 ? void 0 : column.accessorFn)) return;
+	if (!column?.accessorFn) return;
 	row._valuesCache[columnId] = column.accessorFn(row.original, row.index);
 	return row._valuesCache[columnId];
 }
@@ -32,9 +64,9 @@ function row_getValue(row, columnId) {
 * ```
 */
 function row_getUniqueValues(row, columnId) {
-	if (row._uniqueValuesCache.hasOwnProperty(columnId)) return row._uniqueValuesCache[columnId];
+	if (hasOwn(row._uniqueValuesCache, columnId)) return row._uniqueValuesCache[columnId];
 	const column = row.table.getColumn(columnId);
-	if (!(column === null || column === void 0 ? void 0 : column.accessorFn)) return;
+	if (!column?.accessorFn) return;
 	if (!column.columnDef.getUniqueValues) {
 		row._uniqueValuesCache[columnId] = [row.getValue(columnId)];
 		return row._uniqueValuesCache[columnId];
@@ -70,10 +102,20 @@ function row_getLeafRows(row) {
 	return flattenBy(row.subRows, (d) => d.subRows);
 }
 /**
+* Returns the deepest structural row depth in the core row model.
+* Root rows are depth `0`, their direct sub-rows are depth `1`, and so on.
+*/
+function table_getMaxSubRowDepth(table) {
+	const rows = table.getCoreRowModel().flatRows;
+	let maxDepth = 0;
+	for (let i = 0; i < rows.length; i++) maxDepth = Math.max(maxDepth, rows[i].depth);
+	return maxDepth;
+}
+/**
 * Looks up this row's direct parent, if it has one.
 *
-* Parent lookup searches the pre-pagination row model so parent relationships
-* are available even when the parent is not on the current page.
+* Parent lookup prefers the core row model for structural parents, then falls
+* back to the pre-pagination row model for generated parent rows.
 *
 * @example
 * ```ts
@@ -81,7 +123,8 @@ function row_getLeafRows(row) {
 * ```
 */
 function row_getParentRow(row) {
-	return row.parentId ? row.table.getRow(row.parentId, true) : void 0;
+	if (!row.parentId) return;
+	return row.table.getCoreRowModel().rowsById[row.parentId] ?? row.table.getRow(row.parentId, true);
 }
 /**
 * Collects this row's ancestor chain from root to direct parent.
@@ -117,8 +160,18 @@ function row_getParentRows(row) {
 */
 function row_getAllCells(row) {
 	const columns = row.table.getAllLeafColumns();
+	let cache = row._cellsCache;
+	if (!cache) cache = row._cellsCache = /* @__PURE__ */ new WeakMap();
 	const cells = new Array(columns.length);
-	for (let i = 0; i < columns.length; i++) cells[i] = constructCell(columns[i], row, row.table);
+	for (let i = 0; i < columns.length; i++) {
+		const column = columns[i];
+		let cell = cache.get(column);
+		if (!cell) {
+			cell = constructCell(column, row, row.table);
+			cache.set(column, cell);
+		}
+		cells[i] = cell;
+	}
 	return cells;
 }
 /**
@@ -132,7 +185,7 @@ function row_getAllCells(row) {
 * ```
 */
 function row_getAllCellsByColumnId(row) {
-	const result = {};
+	const result = makeObjectMap();
 	const cells = row.getAllCells();
 	for (let i = 0; i < cells.length; i++) {
 		const cell = cells[i];
@@ -152,8 +205,7 @@ function row_getAllCellsByColumnId(row) {
 * ```
 */
 function table_getRowId(originalRow, table, index, parent) {
-	var _table$options$getRow, _table$options;
-	return ((_table$options$getRow = (_table$options = table.options).getRowId) === null || _table$options$getRow === void 0 ? void 0 : _table$options$getRow.call(_table$options, originalRow, index, parent)) ?? `${parent ? [parent.id, index].join(".") : index}`;
+	return table.options.getRowId?.(originalRow, index, parent) ?? (parent ? `${parent.id}.${index}` : String(index));
 }
 /**
 * Looks up a row by id from the current or full row model.
@@ -179,5 +231,4 @@ function table_getRow(table, rowId, searchAll) {
 }
 
 //#endregion
-export { row_getAllCells, row_getAllCellsByColumnId, row_getLeafRows, row_getParentRow, row_getParentRows, row_getUniqueValues, row_getValue, row_renderValue, table_getRow, table_getRowId };
-//# sourceMappingURL=coreRowsFeature.utils.js.map
+export { row_getAllCells, row_getAllCellsByColumnId, row_getDisplayIndex, row_getLeafRows, row_getParentRow, row_getParentRows, row_getUniqueValues, row_getValue, row_renderValue, table_getMaxSubRowDepth, table_getRow, table_getRowId, table_getRowsInDisplayOrder };

package/dist/core/table/constructTable.d.ts

@@ -1,9 +1,8 @@
 import { RowData } from "../../types/type-utils.js";
 import { TableState } from "../../types/TableState.js";
 import { TableOptions } from "../../types/TableOptions.js";
-import { TableFeatures } from "../../types/TableFeatures.js";
 import { Table } from "../../types/Table.js";
-
+import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/core/table/constructTable.d.ts
 /**
  * Builds the initial table state from registered features and user initial state.
@@ -18,5 +17,4 @@ declare function getInitialTableState<TFeatures extends TableFeatures>(features:
  */
 declare function constructTable<TFeatures extends TableFeatures, TData extends RowData>(tableOptions: TableOptions<TFeatures, TData>): Table<TFeatures, TData>;
 //#endregion
-export { constructTable, getInitialTableState };
-//# sourceMappingURL=constructTable.d.ts.map
+export { constructTable, getInitialTableState };

package/dist/core/table/constructTable.js

@@ -1,7 +1,8 @@
-import { cloneState } from "../../utils.js";
+import { cloneState, hasOwn } from "../../utils.js";
 import { table_syncExternalStateToBaseAtoms } from "./coreTablesFeature.utils.js";
 import { coreFeatures } from "../coreFeatures.js";
 import { atomToStore } from "../reactivity/coreReactivityFeature.utils.js";
+import { shallow } from "@tanstack/store";
 
 //#region src/core/table/constructTable.ts
 /**
@@ -11,8 +12,7 @@ import { atomToStore } from "../reactivity/coreReactivityFeature.utils.js";
 */
 function getInitialTableState(features, initialState = {}) {
 	Object.values(features).forEach((feature) => {
-		var _feature$getInitialSt;
-		initialState = ((_feature$getInitialSt = feature.getInitialState) === null || _feature$getInitialSt === void 0 ? void 0 : _feature$getInitialSt.call(feature, initialState)) ?? initialState;
+		initialState = feature.getInitialState?.(initialState) ?? initialState;
 	});
 	return cloneState(initialState);
 }
@@ -22,23 +22,32 @@ function getInitialTableState(features, initialState = {}) {
 * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.
 */
 function constructTable(tableOptions) {
-	const _reactivity = tableOptions.features.coreReativityFeature;
+	const _reactivity = tableOptions.features.coreReactivityFeature;
+	const { aggregationFns, columnMeta: _columnMeta, coreRowModel, expandedRowModel, facetedMinMaxValues, facetedRowModel, facetedUniqueValues, filterFns, filterMeta: _filterMeta, filteredRowModel, groupedRowModel, paginatedRowModel, sortFns, sortedRowModel, tableMeta: _tableMeta, ...features } = tableOptions.features;
 	const table = {
-		_reactivity,
+		_cellInstanceInitFns: [],
+		_columnInstanceInitFns: [],
 		_features: {
 			...coreFeatures,
-			...tableOptions.features
+			...features
+		},
+		_headerGroupInstanceInitFns: [],
+		_headerInstanceInitFns: [],
+		_reactivity,
+		_rowInstanceInitFns: [],
+		_rowModelFns: {
+			aggregationFns,
+			filterFns,
+			sortFns
 		},
 		_rowModels: {},
-		_rowModelFns: {},
-		baseAtoms: {},
-		atoms: {}
+		atoms: {},
+		baseAtoms: {}
 	};
 	const featuresList = Object.values(table._features);
 	const mergedOptions = {
 		...featuresList.reduce((obj, feature) => {
-			var _feature$getDefaultTa;
-			return Object.assign(obj, (_feature$getDefaultTa = feature.getDefaultTableOptions) === null || _feature$getDefaultTa === void 0 ? void 0 : _feature$getDefaultTa.call(feature, table));
+			return Object.assign(obj, feature.getDefaultTableOptions?.(table));
 		}, {}),
 		...tableOptions
 	};
@@ -78,10 +87,12 @@ function constructTable(tableOptions) {
 		const key = stateKeys[i];
 		table.baseAtoms[key] = _reactivity.createWritableAtom(table.initialState[key], { debugName: `table/baseAtoms/${key}` });
 		table.atoms[key] = _reactivity.createReadonlyAtom(() => {
-			const externalAtoms = table.options.atoms;
-			const externalAtom = externalAtoms === null || externalAtoms === void 0 ? void 0 : externalAtoms[key];
-			if (externalAtom) return externalAtom.get();
-			return table.baseAtoms[key].get();
+			const options = table.options;
+			const externalAtom = options.atoms?.[key];
+			const reactiveState = externalAtom ? externalAtom.get() : table.baseAtoms[key].get();
+			if (externalAtom) return reactiveState;
+			const controlledState = options.state;
+			return controlledState && hasOwn(controlledState, key) ? controlledState[key] : reactiveState;
 		}, { debugName: `table/atoms/${key}` });
 	}
 	table_syncExternalStateToBaseAtoms(table);
@@ -92,10 +103,33 @@ function constructTable(tableOptions) {
 			snapshot[key] = table.atoms[key].get();
 		}
 		return snapshot;
-	}, { debugName: "table/store" }));
+	}, {
+		compare: shallow,
+		debugName: "table/store"
+	}));
+	for (let i = 0; i < featuresList.length; i++) {
+		const feature = featuresList[i];
+		feature.initTableInstanceData?.(table);
+		if (feature.initCellInstanceData) table._cellInstanceInitFns.push(feature.initCellInstanceData.bind(feature));
+		if (feature.initColumnInstanceData) table._columnInstanceInitFns.push(feature.initColumnInstanceData.bind(feature));
+		if (feature.initHeaderGroupInstanceData) table._headerGroupInstanceInitFns.push(feature.initHeaderGroupInstanceData.bind(feature));
+		if (feature.initHeaderInstanceData) table._headerInstanceInitFns.push(feature.initHeaderInstanceData.bind(feature));
+		if (feature.initRowInstanceData) table._rowInstanceInitFns.push(feature.initRowInstanceData.bind(feature));
+		feature.constructTableAPIs?.(table);
+	}
 	if (process.env.NODE_ENV === "development" && (tableOptions.debugAll || tableOptions.debugTable)) {
 		const features = Object.keys(table._features);
-		const rowModels = Object.keys(table.options.rowModels || {});
+		const rowModels = Object.entries({
+			coreRowModel,
+			filteredRowModel,
+			groupedRowModel,
+			sortedRowModel,
+			expandedRowModel,
+			paginatedRowModel,
+			facetedRowModel,
+			facetedMinMaxValues,
+			facetedUniqueValues
+		}).filter(([, factory]) => factory).map(([key]) => key);
 		const states = Object.keys(table.initialState);
 		console.log(`Constructing Table Instance
 
@@ -105,13 +139,8 @@ function constructTable(tableOptions) {
 
   States:     ${states.join("\n              ")}\n`, { table });
 	}
-	for (let i = 0; i < featuresList.length; i++) {
-		var _constructTableAPIs, _ref;
-		(_constructTableAPIs = (_ref = featuresList[i]).constructTableAPIs) === null || _constructTableAPIs === void 0 || _constructTableAPIs.call(_ref, table);
-	}
 	return table;
 }
 
 //#endregion
-export { constructTable, getInitialTableState };
-//# sourceMappingURL=constructTable.js.map
+export { constructTable, getInitialTableState };

package/dist/core/table/coreTablesFeature.d.ts

@@ -1,10 +1,8 @@
 import { TableFeature } from "../../types/TableFeatures.js";
-
 //#region src/core/table/coreTablesFeature.d.ts
 /**
  * Core feature that adds base table instance APIs such as reset and setOptions.
  */
 declare const coreTablesFeature: TableFeature;
 //#endregion
-export { coreTablesFeature };
-//# sourceMappingURL=coreTablesFeature.d.ts.map
+export { coreTablesFeature };

package/dist/core/table/coreTablesFeature.js

@@ -13,5 +13,4 @@ const coreTablesFeature = { constructTableAPIs: (table) => {
 } };
 
 //#endregion
-export { coreTablesFeature };
-//# sourceMappingURL=coreTablesFeature.js.map
+export { coreTablesFeature };

package/dist/core/table/coreTablesFeature.types.d.ts

@@ -1,20 +1,30 @@
 import { RowData, Updater } from "../../types/type-utils.js";
 import { TableReactivityBindings } from "../reactivity/coreReactivityFeature.types.js";
 import { CoreFeatures } from "../coreFeatures.js";
+import { CachedRowModels } from "../../types/RowModel.js";
 import { RowModelFns } from "../../types/RowModelFns.js";
-import { CachedRowModels, CreateRowModels_All } from "../../types/RowModel.js";
 import { TableState, TableState_All } from "../../types/TableState.js";
 import { TableOptions } from "../../types/TableOptions.js";
-import { TableFeatures } from "../../types/TableFeatures.js";
+import { IsAny, TableFeature, TableFeatures, ValidateFeatureSlots } from "../../types/TableFeatures.js";
 import { Atom, ReadonlyAtom, ReadonlyStore } from "@tanstack/store";
-
 //#region src/core/table/coreTablesFeature.types.d.ts
-interface TableMeta<TFeatures extends TableFeatures, TData extends RowData> {}
+interface TableMeta<in out TFeatures extends TableFeatures, in out TData extends RowData> {}
+/**
+ * Resolves the type of `options.meta` for a feature set.
+ *
+ * When the features object declares a `tableMeta` type-only slot
+ * (`tableFeatures({ ..., tableMeta: {} as MyTableMeta })`), that type wins.
+ * Otherwise this falls back to the global declaration-merged `TableMeta`
+ * interface.
+ */
+type ExtractTableMeta<TFeatures extends TableFeatures, TData extends RowData> = IsAny<TFeatures> extends true ? TableMeta<TFeatures, TData> : TFeatures extends {
+  tableMeta: infer TMeta extends object;
+} ? TMeta : TableMeta<TFeatures, TData>;
 /**
  * A map of writable atoms, one per `TableState` slice. These are the internal
  * writable atoms that the library always writes to via `makeStateUpdater`.
  */
-type BaseAtoms<TFeatures extends TableFeatures> = { [K in keyof TableState<TFeatures>]-?: Atom<TableState<TFeatures>[K]> };
+type BaseAtoms<TFeatures extends TableFeatures> = { [K in keyof TableState<TFeatures>]-?: Atom<TableState<TFeatures>[K]>; };
 /**
  * A map of readonly derived atoms, one per `TableState` slice. Each derives
  * from its corresponding `baseAtom` plus, optionally, a per-slice external
@@ -22,15 +32,15 @@ type BaseAtoms<TFeatures extends TableFeatures> = { [K in keyof TableState<TFeat
  *
  * Precedence: `options.atoms[key]` > `options.state[key]` > `baseAtoms[key]`.
  */
-type Atoms<TFeatures extends TableFeatures> = { [K in keyof TableState<TFeatures>]-?: ReadonlyAtom<TableState<TFeatures>[K]> };
+type Atoms<TFeatures extends TableFeatures> = { [K in keyof TableState<TFeatures>]-?: ReadonlyAtom<TableState<TFeatures>[K]>; };
 /**
  * A map of optional external atoms, one per `TableState` slice. Consumers can
  * provide their own writable atom for any state slice to take over ownership
  * of that slice.
  */
-type ExternalAtoms<TFeatures extends TableFeatures> = Partial<{ [K in keyof TableState<TFeatures>]: Atom<TableState<TFeatures>[K]> }>;
+type ExternalAtoms<TFeatures extends TableFeatures> = Partial<{ [K in keyof TableState<TFeatures>]: Atom<TableState<TFeatures>[K]>; }>;
 /**
- * Internal "all features" flat variants of the atom types. `Table_Internal`
+ * Internal "all features" flat variants of the atom types. `Table`
  * uses these so feature code (written generically over `TFeatures`) can access
  * any slice atom (e.g. `table.atoms.columnPinning`) without TypeScript
  * narrowing away slices that aren't in the current `TFeatures` union.
@@ -39,22 +49,20 @@ type ExternalAtoms<TFeatures extends TableFeatures> = Partial<{ [K in keyof Tabl
  * but those slices may not be registered on the current table. Consumers must
  * use optional chaining (`table.atoms.columnPinning?.get() ?? default`).
  */
-type BaseAtoms_All = { [K in keyof TableState_All]?: Atom<TableState_All[K]> };
-type Atoms_All = { [K in keyof TableState_All]?: ReadonlyAtom<TableState_All[K]> };
-type ExternalAtoms_All = Partial<{ [K in keyof TableState_All]: Atom<TableState_All[K]> }>;
-interface TableOptions_Table<TFeatures extends TableFeatures, TData extends RowData> {
+type BaseAtoms_All = { [K in keyof TableState_All]?: Atom<Exclude<TableState_All[K], undefined>>; };
+type Atoms_All = { [K in keyof TableState_All]?: ReadonlyAtom<TableState_All[K]>; };
+type ExternalAtoms_All = Partial<{ [K in keyof TableState_All]: Atom<Exclude<TableState_All[K], undefined>>; }>;
+interface TableOptions_Table<in out TFeatures extends TableFeatures, in out TData extends RowData> {
   /**
    * The feature modules registered on this table instance.
    *
    * Feature registration controls which state slices, options, and prototype
-   * APIs are available.
-   */
-  readonly features: TFeatures;
-  /**
-   * Row model factories used by features such as filtering, grouping, sorting,
-   * expansion, and pagination.
+   * APIs are available. This object also carries the table's row model
+   * factories (`sortedRowModel`, `filteredRowModel`, etc.), row model function
+   * registries (`sortFns`, `filterFns`, `aggregationFns`), and type-only meta
+   * slots (`tableMeta`, `columnMeta`).
    */
-  readonly rowModels?: CreateRowModels_All<TFeatures, TData>;
+  readonly features: TFeatures & ValidateFeatureSlots<TFeatures>;
   /**
    * Optionally, provide your own external writable atoms for individual state slices.
    * When an atom is provided for a given slice, it takes precedence over `options.state[key]`
@@ -91,8 +99,11 @@ interface TableOptions_Table<TFeatures extends TableFeatures, TData extends RowD
   readonly mergeOptions?: (defaultOptions: TableOptions<TFeatures, TData>, options: Partial<TableOptions<TFeatures, TData>>) => TableOptions<TFeatures, TData>;
   /**
    * You can pass any object to `options.meta` and access it anywhere the `table` is available via `table.options.meta`.
+   *
+   * Declare its type per-table via the `tableMeta` type-only slot on the
+   * `features` option, or globally via declaration merging on `TableMeta`.
    */
-  readonly meta?: TableMeta<TFeatures, TData>;
+  readonly meta?: ExtractTableMeta<TFeatures, TData>;
   /**
    * Optionally provide externally managed values for individual state slices.
    *
@@ -102,15 +113,23 @@ interface TableOptions_Table<TFeatures extends TableFeatures, TData extends RowD
    */
   readonly state?: Partial<TableState<TFeatures>>;
 }
-interface Table_CoreProperties<TFeatures extends TableFeatures, TData extends RowData> {
+interface Table_CoreProperties<in out TFeatures extends TableFeatures, in out TData extends RowData> {
   /**
    * Table reactivity bindings for interacting with TanStack Store.
    */
   readonly _reactivity: TableReactivityBindings;
+  /**
+   * Cache of the `initCellInstanceData` functions for features that define one.
+   */
+  _cellInstanceInitFns: Array<NonNullable<TableFeature['initCellInstanceData']>>;
   /**
    * Prototype cache for Cell objects - shared by all cells in this table
    */
   _cellPrototype?: object;
+  /**
+   * Cache of the `initColumnInstanceData` functions for features that define one.
+   */
+  _columnInstanceInitFns: Array<NonNullable<TableFeature['initColumnInstanceData']>>;
   /**
    * Prototype cache for Column objects - shared by all columns in this table
    */
@@ -119,6 +138,14 @@ interface Table_CoreProperties<TFeatures extends TableFeatures, TData extends Ro
    * The features that are enabled for the table.
    */
   readonly _features: Partial<CoreFeatures> & TFeatures;
+  /**
+   * Cache of the `initHeaderGroupInstanceData` functions for features that define one.
+   */
+  _headerGroupInstanceInitFns: Array<NonNullable<TableFeature['initHeaderGroupInstanceData']>>;
+  /**
+   * Cache of the `initHeaderInstanceData` functions for features that define one.
+   */
+  _headerInstanceInitFns: Array<NonNullable<TableFeature['initHeaderInstanceData']>>;
   /**
    * Prototype cache for Header objects - shared by all headers in this table
    */
@@ -135,6 +162,10 @@ interface Table_CoreProperties<TFeatures extends TableFeatures, TData extends Ro
    * Prototype cache for Row objects - shared by all rows in this table
    */
   _rowPrototype?: object;
+  /**
+   * Cache of the `initRowInstanceData` functions for features that define one.
+   */
+  _rowInstanceInitFns: Array<NonNullable<TableFeature['initRowInstanceData']>>;
   /**
    * The readonly derived atoms for each `TableState` slice. Each derives from
    * its corresponding `baseAtom` plus, optionally, a per-slice external atom or
@@ -166,13 +197,14 @@ interface Table_CoreProperties<TFeatures extends TableFeatures, TData extends Ro
    */
   readonly store: ReadonlyStore<TableState<TFeatures>>;
 }
-interface Table_Table<TFeatures extends TableFeatures, TData extends RowData> extends Table_CoreProperties<TFeatures, TData> {
+interface Table_Table<in out TFeatures extends TableFeatures, in out TData extends RowData> extends Table_CoreProperties<TFeatures, TData> {
   /**
    * Resets the table's internal base atoms to `table.initialState`.
    *
    * Prefer feature-specific reset APIs, such as `resetPagination`, when a state
    * slice may be owned by an external atom or needs that feature's blank/default
-   * reset behavior.
+   * reset behavior. After resetting internal atoms, this also invokes feature
+   * reset hooks for mutable, transient table-instance data.
    */
   reset: () => void;
   /**
@@ -182,5 +214,4 @@ interface Table_Table<TFeatures extends TableFeatures, TData extends RowData> ex
   setOptions: (newOptions: Updater<TableOptions<TFeatures, TData>>) => void;
 }
 //#endregion
-export { Atoms, Atoms_All, BaseAtoms, BaseAtoms_All, ExternalAtoms, ExternalAtoms_All, TableMeta, TableOptions_Table, Table_CoreProperties, Table_Table };
-//# sourceMappingURL=coreTablesFeature.types.d.ts.map
+export { Atoms, Atoms_All, BaseAtoms, BaseAtoms_All, ExternalAtoms, ExternalAtoms_All, ExtractTableMeta, TableMeta, TableOptions_Table, Table_CoreProperties, Table_Table };