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

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

@@ -1,8 +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
 /**

package/dist/core/table/constructTable.js

@@ -11,8 +11,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 +21,27 @@ 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,
 		_features: {
 			...coreFeatures,
-			...tableOptions.features
+			...features
 		},
 		_rowModels: {},
-		_rowModelFns: {},
+		_rowModelFns: {
+			aggregationFns,
+			filterFns,
+			sortFns
+		},
 		baseAtoms: {},
 		atoms: {}
 	};
 	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,8 +81,7 @@ 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];
+			const externalAtom = table.options.atoms?.[key];
 			if (externalAtom) return externalAtom.get();
 			return table.baseAtoms[key].get();
 		}, { debugName: `table/atoms/${key}` });
@@ -93,9 +95,20 @@ function constructTable(tableOptions) {
 		}
 		return snapshot;
 	}, { debugName: "table/store" }));
+	for (let i = 0; i < featuresList.length; i++) featuresList[i].initTableInstanceData?.(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,10 +118,7 @@ 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);
-	}
+	for (let i = 0; i < featuresList.length; i++) featuresList[i].constructTableAPIs?.(table);
 	return table;
 }
 

package/dist/core/table/constructTable.js.map

@@ -1 +1 @@
-{"version":3,"file":"constructTable.js","names":[],"sources":["../../../src/core/table/constructTable.ts"],"sourcesContent":["import { coreFeatures } from '../coreFeatures'\nimport { cloneState } from '../../utils'\nimport { atomToStore } from '../reactivity/coreReactivityFeature.utils'\nimport { table_syncExternalStateToBaseAtoms } from './coreTablesFeature.utils'\nimport type { Atom } from '@tanstack/store'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { TableOptions } from '../../types/TableOptions'\nimport type { TableState, TableState_All } from '../../types/TableState'\n\n/**\n * Builds the initial table state from registered features and user initial state.\n *\n * Each feature contributes its default state before user-provided `initialState` values are merged in.\n */\nexport function getInitialTableState<TFeatures extends TableFeatures>(\n  features: TFeatures,\n  initialState: Partial<TableState<TFeatures>> | undefined = {},\n): TableState<TFeatures> {\n  Object.values(features).forEach((feature) => {\n    initialState = feature.getInitialState?.(initialState) ?? initialState\n  })\n  return cloneState(initialState) as TableState<TFeatures>\n}\n\n/**\n * Constructs a table instance from normalized table internals.\n *\n * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.\n */\nexport function constructTable<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(tableOptions: TableOptions<TFeatures, TData>): Table<TFeatures, TData> {\n  const _reactivity = tableOptions.features.coreReativityFeature!\n\n  const table = {\n    _reactivity,\n    _features: { ...coreFeatures, ...tableOptions.features },\n    _rowModels: {},\n    _rowModelFns: {},\n    baseAtoms: {},\n    atoms: {},\n  } as Table_Internal<TFeatures, TData>\n\n  const featuresList: Array<TableFeature> = Object.values(table._features)\n\n  const defaultOptions = featuresList.reduce((obj, feature) => {\n    return Object.assign(obj, feature.getDefaultTableOptions?.(table))\n  }, {}) as TableOptions<TFeatures, TData>\n\n  const mergedOptions = { ...defaultOptions, ...tableOptions }\n\n  if (_reactivity.wrapExternalAtoms && mergedOptions.atoms) {\n    for (const [atomKey, _atom] of Object.entries(mergedOptions.atoms)) {\n      const atom = _atom as Atom<any>\n      const wrappedAtom = _reactivity.createWritableAtom(atom.get(), {\n        debugName: `externalAtom/${atomKey}`,\n      })\n      ;(mergedOptions.atoms as any)[atomKey] = wrappedAtom\n      // Two-way syncing between the original atom and the wrapped one.\n      let syncExternal = false\n      const syncAtomToWrappedSub = atom.subscribe((value) => {\n        if (syncExternal) return\n        wrappedAtom.set(value)\n      })\n      const syncWrappedToAtomSub = wrappedAtom.subscribe((value) => {\n        syncExternal = true\n        atom.set(value)\n        syncExternal = false\n      })\n      _reactivity.addSubscription(syncAtomToWrappedSub)\n      _reactivity.addSubscription(syncWrappedToAtomSub)\n    }\n  }\n\n  if (_reactivity.createOptionsStore) {\n    // @ts-ignore - direct set\n    table.optionsStore = _reactivity.createWritableAtom<\n      TableOptions<TFeatures, TData>\n    >(mergedOptions, { debugName: 'table/optionsStore' })\n    Object.defineProperty(table, 'options', {\n      configurable: true,\n      enumerable: true,\n      get() {\n        return table.optionsStore!.get()\n      },\n      set(value) {\n        table.optionsStore!.set(() => value) // or your real update shape\n      },\n    })\n  } else {\n    table.options = mergedOptions\n  }\n\n  table.initialState = getInitialTableState(\n    table._features,\n    table.options.initialState,\n  )\n\n  const stateKeys = Object.keys(table.initialState) as Array<\n    string & keyof TableState_All\n  >\n\n  for (let i = 0; i < stateKeys.length; i++) {\n    const key = stateKeys[i]!\n    table.baseAtoms[key] = _reactivity.createWritableAtom(\n      table.initialState[key],\n      {\n        debugName: `table/baseAtoms/${key}`,\n      },\n    ) as any\n\n    // create readonly derived atom: on each get(), read either external atom or base atom\n    ;(table.atoms as any)[key] = _reactivity.createReadonlyAtom(\n      () => {\n        const externalAtoms = table.options.atoms as\n          | Partial<Record<keyof TableState_All, Atom<unknown>>>\n          | undefined\n        const externalAtom = externalAtoms?.[key]\n        if (externalAtom) {\n          return externalAtom.get()\n        }\n        return table.baseAtoms[key]!.get()\n      },\n      { debugName: `table/atoms/${key}` },\n    )\n  }\n\n  table_syncExternalStateToBaseAtoms(table)\n\n  table.store = atomToStore(\n    _reactivity.createReadonlyAtom(\n      () => {\n        const snapshot = {} as TableState<TFeatures> & TableState_All\n        for (let i = 0; i < stateKeys.length; i++) {\n          const key = stateKeys[i]!\n          ;(snapshot as Record<string, unknown>)[key] = table.atoms[key]!.get()\n        }\n        return snapshot\n      },\n      { debugName: 'table/store' },\n    ),\n  )\n\n  if (\n    process.env.NODE_ENV === 'development' &&\n    (tableOptions.debugAll || tableOptions.debugTable)\n  ) {\n    const features = Object.keys(table._features)\n    const rowModels = Object.keys(table.options.rowModels || {})\n    const states = Object.keys(table.initialState)\n\n    console.log(\n      `Constructing Table Instance\n\n  Features:   ${features.join('\\n              ')}\n\n  Row Models: ${rowModels.length ? rowModels.join('\\n              ') : '(none)'}\n\n  States:     ${states.join('\\n              ')}\\n`,\n      { table },\n    )\n  }\n\n  for (let i = 0; i < featuresList.length; i++) {\n    featuresList[i]!.constructTableAPIs?.(table)\n  }\n\n  return table\n}\n"],"mappings":"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"}
+{"version":3,"file":"constructTable.js","names":[],"sources":["../../../src/core/table/constructTable.ts"],"sourcesContent":["import { coreFeatures } from '../coreFeatures'\nimport { cloneState } from '../../utils'\nimport { atomToStore } from '../reactivity/coreReactivityFeature.utils'\nimport { table_syncExternalStateToBaseAtoms } from './coreTablesFeature.utils'\nimport type { Atom } from '@tanstack/store'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { TableOptions } from '../../types/TableOptions'\nimport type { TableState, TableState_All } from '../../types/TableState'\n\n/**\n * Builds the initial table state from registered features and user initial state.\n *\n * Each feature contributes its default state before user-provided `initialState` values are merged in.\n */\nexport function getInitialTableState<TFeatures extends TableFeatures>(\n  features: TFeatures,\n  initialState: Partial<TableState<TFeatures>> | undefined = {},\n): TableState<TFeatures> {\n  Object.values(features).forEach((feature) => {\n    initialState = feature.getInitialState?.(initialState) ?? initialState\n  })\n  return cloneState(initialState) as TableState<TFeatures>\n}\n\n/**\n * Constructs a table instance from normalized table internals.\n *\n * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.\n */\nexport function constructTable<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(tableOptions: TableOptions<TFeatures, TData>): Table<TFeatures, TData> {\n  const _reactivity = tableOptions.features.coreReactivityFeature!\n\n  // Strip the non-feature slots: type-only meta slots, row model factories,\n  // and row model fn registries all live on the `features` option but are not\n  // table features themselves.\n  const {\n    aggregationFns,\n    columnMeta: _columnMeta,\n    coreRowModel,\n    expandedRowModel,\n    facetedMinMaxValues,\n    facetedRowModel,\n    facetedUniqueValues,\n    filterFns,\n    filterMeta: _filterMeta,\n    filteredRowModel,\n    groupedRowModel,\n    paginatedRowModel,\n    sortFns,\n    sortedRowModel,\n    tableMeta: _tableMeta,\n    ...features\n  } = tableOptions.features\n\n  const table = {\n    _reactivity,\n    _features: { ...coreFeatures, ...features },\n    _rowModels: {},\n    _rowModelFns: { aggregationFns, filterFns, sortFns },\n    baseAtoms: {},\n    atoms: {},\n  } as unknown as Table_Internal<TFeatures, TData>\n\n  const featuresList: Array<TableFeature> = Object.values(table._features)\n\n  const defaultOptions = featuresList.reduce((obj, feature) => {\n    return Object.assign(obj, feature.getDefaultTableOptions?.(table))\n  }, {}) as TableOptions<TFeatures, TData>\n\n  const mergedOptions = { ...defaultOptions, ...tableOptions }\n\n  if (_reactivity.wrapExternalAtoms && mergedOptions.atoms) {\n    for (const [atomKey, _atom] of Object.entries(mergedOptions.atoms)) {\n      const atom = _atom as Atom<any>\n      const wrappedAtom = _reactivity.createWritableAtom(atom.get(), {\n        debugName: `externalAtom/${atomKey}`,\n      })\n      ;(mergedOptions.atoms as any)[atomKey] = wrappedAtom\n      // Two-way syncing between the original atom and the wrapped one.\n      let syncExternal = false\n      const syncAtomToWrappedSub = atom.subscribe((value) => {\n        if (syncExternal) return\n        wrappedAtom.set(value)\n      })\n      const syncWrappedToAtomSub = wrappedAtom.subscribe((value) => {\n        syncExternal = true\n        atom.set(value)\n        syncExternal = false\n      })\n      _reactivity.addSubscription(syncAtomToWrappedSub)\n      _reactivity.addSubscription(syncWrappedToAtomSub)\n    }\n  }\n\n  if (_reactivity.createOptionsStore) {\n    // @ts-ignore - direct set\n    table.optionsStore = _reactivity.createWritableAtom<\n      TableOptions<TFeatures, TData>\n    >(mergedOptions, { debugName: 'table/optionsStore' })\n    Object.defineProperty(table, 'options', {\n      configurable: true,\n      enumerable: true,\n      get() {\n        return table.optionsStore!.get()\n      },\n      set(value) {\n        table.optionsStore!.set(() => value) // or your real update shape\n      },\n    })\n  } else {\n    table.options = mergedOptions\n  }\n\n  table.initialState = getInitialTableState(\n    table._features,\n    table.options.initialState,\n  )\n\n  const stateKeys = Object.keys(table.initialState) as Array<\n    string & keyof TableState_All\n  >\n\n  for (let i = 0; i < stateKeys.length; i++) {\n    const key = stateKeys[i]!\n    table.baseAtoms[key] = _reactivity.createWritableAtom(\n      table.initialState[key],\n      {\n        debugName: `table/baseAtoms/${key}`,\n      },\n    ) as any\n\n    // create readonly derived atom: on each get(), read either external atom or base atom\n    ;(table.atoms as any)[key] = _reactivity.createReadonlyAtom(\n      () => {\n        const externalAtoms = table.options.atoms as\n          | Partial<Record<keyof TableState_All, Atom<unknown>>>\n          | undefined\n        const externalAtom = externalAtoms?.[key]\n        if (externalAtom) {\n          return externalAtom.get()\n        }\n        return table.baseAtoms[key]!.get()\n      },\n      { debugName: `table/atoms/${key}` },\n    )\n  }\n\n  table_syncExternalStateToBaseAtoms(table)\n\n  table.store = atomToStore(\n    _reactivity.createReadonlyAtom(\n      () => {\n        const snapshot = {} as TableState<TFeatures> & TableState_All\n        for (let i = 0; i < stateKeys.length; i++) {\n          const key = stateKeys[i]!\n          ;(snapshot as Record<string, unknown>)[key] = table.atoms[key]!.get()\n        }\n        return snapshot\n      },\n      { debugName: 'table/store' },\n    ),\n  )\n\n  for (let i = 0; i < featuresList.length; i++) {\n    featuresList[i]!.initTableInstanceData?.(table)\n  }\n\n  if (\n    process.env.NODE_ENV === 'development' &&\n    (tableOptions.debugAll || tableOptions.debugTable)\n  ) {\n    const features = Object.keys(table._features)\n    const rowModels = Object.entries({\n      coreRowModel,\n      filteredRowModel,\n      groupedRowModel,\n      sortedRowModel,\n      expandedRowModel,\n      paginatedRowModel,\n      facetedRowModel,\n      facetedMinMaxValues,\n      facetedUniqueValues,\n    })\n      .filter(([, factory]) => factory)\n      .map(([key]) => key)\n    const states = Object.keys(table.initialState)\n\n    console.log(\n      `Constructing Table Instance\n\n  Features:   ${features.join('\\n              ')}\n\n  Row Models: ${rowModels.length ? rowModels.join('\\n              ') : '(none)'}\n\n  States:     ${states.join('\\n              ')}\\n`,\n      { table },\n    )\n  }\n\n  for (let i = 0; i < featuresList.length; i++) {\n    featuresList[i]!.constructTableAPIs?.(table)\n  }\n\n  return table as unknown as Table<TFeatures, TData>\n}\n"],"mappings":"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"}

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

@@ -1,15 +1,26 @@
 import { RowData, Updater } from "../../types/type-utils.cjs";
 import { TableReactivityBindings } from "../reactivity/coreReactivityFeature.types.cjs";
 import { CoreFeatures } from "../coreFeatures.cjs";
+import { CachedRowModels } from "../../types/RowModel.cjs";
 import { RowModelFns } from "../../types/RowModelFns.cjs";
-import { CachedRowModels, CreateRowModels_All } from "../../types/RowModel.cjs";
 import { TableState, TableState_All } from "../../types/TableState.cjs";
 import { TableOptions } from "../../types/TableOptions.cjs";
-import { TableFeatures } from "../../types/TableFeatures.cjs";
+import { IsAny, TableFeatures, ValidateFeatureSlots } from "../../types/TableFeatures.cjs";
 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`.
@@ -30,7 +41,7 @@ type Atoms<TFeatures extends TableFeatures> = { [K in keyof TableState<TFeatures
  */
 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 +50,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 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<TableState_All[K]> }>;
-interface TableOptions_Table<TFeatures extends TableFeatures, TData extends RowData> {
+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.
+   * 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 features: TFeatures;
-  /**
-   * Row model factories used by features such as filtering, grouping, sorting,
-   * expansion, and pagination.
-   */
-  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 +100,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,7 +114,7 @@ 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.
    */
@@ -166,13 +178,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 +195,5 @@ 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 };
+export { Atoms, Atoms_All, BaseAtoms, BaseAtoms_All, ExternalAtoms, ExternalAtoms_All, ExtractTableMeta, TableMeta, TableOptions_Table, Table_CoreProperties, Table_Table };
 //# sourceMappingURL=coreTablesFeature.types.d.cts.map

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

@@ -1,15 +1,26 @@
 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, 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`.
@@ -30,7 +41,7 @@ type Atoms<TFeatures extends TableFeatures> = { [K in keyof TableState<TFeatures
  */
 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 +50,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 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<TableState_All[K]> }>;
-interface TableOptions_Table<TFeatures extends TableFeatures, TData extends RowData> {
+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.
+   * 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 features: TFeatures;
-  /**
-   * Row model factories used by features such as filtering, grouping, sorting,
-   * expansion, and pagination.
-   */
-  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 +100,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,7 +114,7 @@ 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.
    */
@@ -166,13 +178,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 +195,5 @@ 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 };
+export { Atoms, Atoms_All, BaseAtoms, BaseAtoms_All, ExternalAtoms, ExternalAtoms_All, ExtractTableMeta, TableMeta, TableOptions_Table, Table_CoreProperties, Table_Table };
 //# sourceMappingURL=coreTablesFeature.types.d.ts.map

package/dist/core/table/coreTablesFeature.utils.cjs

@@ -20,12 +20,13 @@ function table_syncExternalStateToBaseAtoms(table) {
 			const baseAtom = table.baseAtoms[key];
 			if (!baseAtom) continue;
 			const externalState = state[key];
-			if (externalState !== baseAtom.get()) baseAtom.set(() => externalState);
+			if (externalState !== table._reactivity.untrack(() => baseAtom.get())) baseAtom.set(() => externalState);
 		}
 	});
 }
 /**
-* Resets all internal table base atoms to `table.initialState`.
+* Resets all internal table base atoms to `table.initialState`, then clears
+* transient instance data through registered feature reset hooks.
 *
 * This resets internally owned state slices in a single reactivity batch. Use
 * feature-specific reset APIs when a slice may be externally owned.
@@ -44,12 +45,16 @@ function table_reset(table) {
 			table.baseAtoms[key].set(snap[key]);
 		}
 	});
+	const features = Object.values(table._features);
+	for (let i = 0; i < features.length; i++) features[i].resetTableInstanceData?.(table);
 }
 /**
 * Merges new table options with the current resolved options.
 *
 * If `options.mergeOptions` is provided, it owns the merge behavior; otherwise
-* options are shallow-merged.
+* options are shallow-merged. Static options that should never change after
+* initialization are restored on a fresh object so framework merge helpers may
+* return readonly getter/proxy objects.
 *
 * @example
 * ```ts
@@ -57,11 +62,37 @@ function table_reset(table) {
 * ```
 */
 function table_mergeOptions(table, newOptions) {
-	if (table.options.mergeOptions) return table.options.mergeOptions(table.options, newOptions);
-	return {
+	const { features, atoms, initialState } = table.options;
+	if (!table.options.mergeOptions) return {
 		...table.options,
-		...newOptions
+		...newOptions,
+		features,
+		atoms,
+		initialState
 	};
+	const mergedOptions = table.options.mergeOptions(table.options, newOptions);
+	const descriptors = { ...Object.getOwnPropertyDescriptors(mergedOptions) };
+	return Object.defineProperties(Object.create(Object.getPrototypeOf(mergedOptions)), {
+		...descriptors,
+		features: {
+			value: features,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		},
+		atoms: {
+			value: atoms,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		},
+		initialState: {
+			value: initialState,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		}
+	});
 }
 /**
 * Updates the table options object.
@@ -75,14 +106,7 @@ function table_mergeOptions(table, newOptions) {
 * ```
 */
 function table_setOptions(table, updater) {
-	const newOptions = require_utils.functionalUpdate(updater, table.options);
-	const { rowModels, features, atoms, initialState } = table.options;
-	const mergedOptions = Object.assign(table_mergeOptions(table, newOptions), {
-		rowModels,
-		features,
-		atoms,
-		initialState
-	});
+	const mergedOptions = table_mergeOptions(table, require_utils.functionalUpdate(updater, table.options));
 	if (table.optionsStore) table.optionsStore.set(() => mergedOptions);
 	else table.options = mergedOptions;
 	table_syncExternalStateToBaseAtoms(table);

package/dist/core/table/coreTablesFeature.utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"coreTablesFeature.utils.cjs","names":["cloneState","functionalUpdate"],"sources":["../../../src/core/table/coreTablesFeature.utils.ts"],"sourcesContent":["import { cloneState, functionalUpdate } from '../../utils'\nimport type { RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { TableOptions } from '../../types/TableOptions'\n\n/**\n * Synchronizes externally controlled state slices into the table's base atoms.\n *\n * This keeps legacy `options.state` values reflected in the atom graph so\n * derived atoms, stores, and table APIs read a consistent snapshot.\n *\n * @example\n * ```ts\n * table_syncExternalStateToBaseAtoms(table)\n * ```\n */\nexport function table_syncExternalStateToBaseAtoms<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): void {\n  const state = table.options.state\n  if (!state) {\n    return\n  }\n\n  table._reactivity.batch(() => {\n    for (const key in state) {\n      const baseAtom = (table.baseAtoms as Record<string, any>)[key]\n      if (!baseAtom) {\n        continue\n      }\n\n      const externalState = state[key as keyof typeof state]\n      if (externalState !== baseAtom.get()) {\n        baseAtom.set(() => externalState)\n      }\n    }\n  })\n}\n\n/**\n * Resets all internal table base atoms to `table.initialState`.\n *\n * This resets internally owned state slices in a single reactivity batch. Use\n * feature-specific reset APIs when a slice may be externally owned.\n *\n * @example\n * ```ts\n * table_reset(table)\n * ```\n */\nexport function table_reset<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): void {\n  const snap = cloneState(table.initialState)\n  table._reactivity.batch(() => {\n    const keys = Object.keys(snap) as Array<keyof typeof snap>\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i]!\n      ;(table.baseAtoms as any)[key].set(snap[key])\n    }\n  })\n}\n\n/**\n * Merges new table options with the current resolved options.\n *\n * If `options.mergeOptions` is provided, it owns the merge behavior; otherwise\n * options are shallow-merged.\n *\n * @example\n * ```ts\n * const options = table_mergeOptions(table, nextOptions)\n * ```\n */\nexport function table_mergeOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  newOptions: TableOptions<TFeatures, TData>,\n) {\n  if (table.options.mergeOptions) {\n    return table.options.mergeOptions(table.options, newOptions)\n  }\n\n  return {\n    ...table.options,\n    ...newOptions,\n  }\n}\n\n/**\n * Updates the table options object.\n *\n * The updater receives the current resolved options and the merged result is\n * immediately assigned to the table instance.\n *\n * @example\n * ```ts\n * table_setOptions(table, (old) => old)\n * ```\n */\nexport function table_setOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  updater: Updater<TableOptions<TFeatures, TData>>,\n): void {\n  const newOptions = functionalUpdate(updater, table.options)\n  // table static options that should never change after initialization\n  const { rowModels, features, atoms, initialState } = table.options\n  const mergedOptions = Object.assign(table_mergeOptions(table, newOptions), {\n    // Once the table instance is created those properties should never change after initialization,\n    // so we assign them back preserving the `table_mergeOptions` object reference\n    rowModels,\n    features,\n    atoms,\n    initialState,\n  })\n\n  if (table.optionsStore) {\n    table.optionsStore.set(() => mergedOptions)\n  } else {\n    table.options = mergedOptions\n  }\n  table_syncExternalStateToBaseAtoms(table)\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,mCAGd,OAA+C;CAC/C,MAAM,QAAQ,MAAM,QAAQ;CAC5B,IAAI,CAAC,OACH;CAGF,MAAM,YAAY,YAAY;EAC5B,KAAK,MAAM,OAAO,OAAO;GACvB,MAAM,WAAY,MAAM,UAAkC;GAC1D,IAAI,CAAC,UACH;GAGF,MAAM,gBAAgB,MAAM;GAC5B,IAAI,kBAAkB,SAAS,IAAI,GACjC,SAAS,UAAU,aAAa;EAEpC;CACF,CAAC;AACH;;;;;;;;;;;;AAaA,SAAgB,YAGd,OAA+C;CAC/C,MAAM,OAAOA,yBAAW,MAAM,YAAY;CAC1C,MAAM,YAAY,YAAY;EAC5B,MAAM,OAAO,OAAO,KAAK,IAAI;EAC7B,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;GACpC,MAAM,MAAM,KAAK;GAChB,AAAC,MAAM,UAAkB,IAAI,CAAC,IAAI,KAAK,IAAI;EAC9C;CACF,CAAC;AACH;;;;;;;;;;;;AAaA,SAAgB,mBAId,OACA,YACA;CACA,IAAI,MAAM,QAAQ,cAChB,OAAO,MAAM,QAAQ,aAAa,MAAM,SAAS,UAAU;CAG7D,OAAO;EACL,GAAG,MAAM;EACT,GAAG;CACL;AACF;;;;;;;;;;;;AAaA,SAAgB,iBAId,OACA,SACM;CACN,MAAM,aAAaC,+BAAiB,SAAS,MAAM,OAAO;CAE1D,MAAM,EAAE,WAAW,UAAU,OAAO,iBAAiB,MAAM;CAC3D,MAAM,gBAAgB,OAAO,OAAO,mBAAmB,OAAO,UAAU,GAAG;EAGzE;EACA;EACA;EACA;CACF,CAAC;CAED,IAAI,MAAM,cACR,MAAM,aAAa,UAAU,aAAa;MAE1C,MAAM,UAAU;CAElB,mCAAmC,KAAK;AAC1C"}
+{"version":3,"file":"coreTablesFeature.utils.cjs","names":["cloneState","functionalUpdate"],"sources":["../../../src/core/table/coreTablesFeature.utils.ts"],"sourcesContent":["import { cloneState, functionalUpdate } from '../../utils'\nimport type { RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { TableOptions } from '../../types/TableOptions'\n\n/**\n * Synchronizes externally controlled state slices into the table's base atoms.\n *\n * This keeps legacy `options.state` values reflected in the atom graph so\n * derived atoms, stores, and table APIs read a consistent snapshot.\n *\n * @example\n * ```ts\n * table_syncExternalStateToBaseAtoms(table)\n * ```\n */\nexport function table_syncExternalStateToBaseAtoms<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): void {\n  const state = table.options.state\n  if (!state) {\n    return\n  }\n\n  table._reactivity.batch(() => {\n    for (const key in state) {\n      const baseAtom = (table.baseAtoms as Record<string, any>)[key]\n      if (!baseAtom) {\n        continue\n      }\n\n      const externalState = state[key as keyof typeof state]\n      if (externalState !== table._reactivity.untrack(() => baseAtom.get())) {\n        baseAtom.set(() => externalState)\n      }\n    }\n  })\n}\n\n/**\n * Resets all internal table base atoms to `table.initialState`, then clears\n * transient instance data through registered feature reset hooks.\n *\n * This resets internally owned state slices in a single reactivity batch. Use\n * feature-specific reset APIs when a slice may be externally owned.\n *\n * @example\n * ```ts\n * table_reset(table)\n * ```\n */\nexport function table_reset<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): void {\n  const snap = cloneState(table.initialState)\n  table._reactivity.batch(() => {\n    const keys = Object.keys(snap) as Array<keyof typeof snap>\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i]!\n      ;(table.baseAtoms as any)[key].set(snap[key])\n    }\n  })\n\n  const features = Object.values(table._features)\n  for (let i = 0; i < features.length; i++) {\n    features[i]!.resetTableInstanceData?.(table)\n  }\n}\n\n/**\n * Merges new table options with the current resolved options.\n *\n * If `options.mergeOptions` is provided, it owns the merge behavior; otherwise\n * options are shallow-merged. Static options that should never change after\n * initialization are restored on a fresh object so framework merge helpers may\n * return readonly getter/proxy objects.\n *\n * @example\n * ```ts\n * const options = table_mergeOptions(table, nextOptions)\n * ```\n */\nexport function table_mergeOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  newOptions: TableOptions<TFeatures, TData>,\n) {\n  const { features, atoms, initialState } = table.options\n\n  // simple merge if no mergeOptions is provided - performant\n  if (!table.options.mergeOptions) {\n    return {\n      ...table.options,\n      ...newOptions,\n      features,\n      atoms,\n      initialState,\n    }\n  }\n\n  // else use the mergeOptions function and preserve getters/setters\n  const mergedOptions = table.options.mergeOptions(\n    table.options as TableOptions<TFeatures, TData>,\n    newOptions,\n  )\n  const descriptors: PropertyDescriptorMap = {\n    ...Object.getOwnPropertyDescriptors(mergedOptions),\n  }\n\n  return Object.defineProperties(\n    Object.create(Object.getPrototypeOf(mergedOptions)),\n    {\n      ...descriptors,\n      features: {\n        value: features,\n        enumerable: true,\n        configurable: true,\n        writable: true,\n      },\n      atoms: {\n        value: atoms,\n        enumerable: true,\n        configurable: true,\n        writable: true,\n      },\n      initialState: {\n        value: initialState,\n        enumerable: true,\n        configurable: true,\n        writable: true,\n      },\n    },\n  ) as TableOptions<TFeatures, TData>\n}\n\n/**\n * Updates the table options object.\n *\n * The updater receives the current resolved options and the merged result is\n * immediately assigned to the table instance.\n *\n * @example\n * ```ts\n * table_setOptions(table, (old) => old)\n * ```\n */\nexport function table_setOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  updater: Updater<TableOptions<TFeatures, TData>>,\n): void {\n  const newOptions = functionalUpdate(\n    updater,\n    table.options as TableOptions<TFeatures, TData>,\n  )\n  const mergedOptions = table_mergeOptions(table, newOptions)\n\n  if (table.optionsStore) {\n    table.optionsStore.set(() => mergedOptions)\n  } else {\n    table.options = mergedOptions\n  }\n  table_syncExternalStateToBaseAtoms(table)\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,mCAGd,OAA+C;CAC/C,MAAM,QAAQ,MAAM,QAAQ;CAC5B,IAAI,CAAC,OACH;CAGF,MAAM,YAAY,YAAY;EAC5B,KAAK,MAAM,OAAO,OAAO;GACvB,MAAM,WAAY,MAAM,UAAkC;GAC1D,IAAI,CAAC,UACH;GAGF,MAAM,gBAAgB,MAAM;GAC5B,IAAI,kBAAkB,MAAM,YAAY,cAAc,SAAS,IAAI,CAAC,GAClE,SAAS,UAAU,aAAa;EAEpC;CACF,CAAC;AACH;;;;;;;;;;;;;AAcA,SAAgB,YAGd,OAA+C;CAC/C,MAAM,OAAOA,yBAAW,MAAM,YAAY;CAC1C,MAAM,YAAY,YAAY;EAC5B,MAAM,OAAO,OAAO,KAAK,IAAI;EAC7B,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;GACpC,MAAM,MAAM,KAAK;GAChB,AAAC,MAAM,UAAkB,IAAI,CAAC,IAAI,KAAK,IAAI;EAC9C;CACF,CAAC;CAED,MAAM,WAAW,OAAO,OAAO,MAAM,SAAS;CAC9C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KACnC,SAAS,EAAE,CAAE,yBAAyB,KAAK;AAE/C;;;;;;;;;;;;;;AAeA,SAAgB,mBAId,OACA,YACA;CACA,MAAM,EAAE,UAAU,OAAO,iBAAiB,MAAM;CAGhD,IAAI,CAAC,MAAM,QAAQ,cACjB,OAAO;EACL,GAAG,MAAM;EACT,GAAG;EACH;EACA;EACA;CACF;CAIF,MAAM,gBAAgB,MAAM,QAAQ,aAClC,MAAM,SACN,UACF;CACA,MAAM,cAAqC,EACzC,GAAG,OAAO,0BAA0B,aAAa,EACnD;CAEA,OAAO,OAAO,iBACZ,OAAO,OAAO,OAAO,eAAe,aAAa,CAAC,GAClD;EACE,GAAG;EACH,UAAU;GACR,OAAO;GACP,YAAY;GACZ,cAAc;GACd,UAAU;EACZ;EACA,OAAO;GACL,OAAO;GACP,YAAY;GACZ,cAAc;GACd,UAAU;EACZ;EACA,cAAc;GACZ,OAAO;GACP,YAAY;GACZ,cAAc;GACd,UAAU;EACZ;CACF,CACF;AACF;;;;;;;;;;;;AAaA,SAAgB,iBAId,OACA,SACM;CAKN,MAAM,gBAAgB,mBAAmB,OAJtBC,+BACjB,SACA,MAAM,OAEiD,CAAC;CAE1D,IAAI,MAAM,cACR,MAAM,aAAa,UAAU,aAAa;MAE1C,MAAM,UAAU;CAElB,mCAAmC,KAAK;AAC1C"}

package/dist/core/table/coreTablesFeature.utils.d.cts

@@ -1,7 +1,7 @@
 import { RowData, Updater } from "../../types/type-utils.cjs";
 import { TableOptions } from "../../types/TableOptions.cjs";
+import { Table } from "../../types/Table.cjs";
 import { TableFeatures } from "../../types/TableFeatures.cjs";
-import { Table_Internal } from "../../types/Table.cjs";
 
 //#region src/core/table/coreTablesFeature.utils.d.ts
 /**
@@ -15,9 +15,10 @@ import { Table_Internal } from "../../types/Table.cjs";
  * table_syncExternalStateToBaseAtoms(table)
  * ```
  */
-declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): void;
 /**
- * Resets all internal table base atoms to `table.initialState`.
+ * Resets all internal table base atoms to `table.initialState`, then clears
+ * transient instance data through registered feature reset hooks.
  *
  * This resets internally owned state slices in a single reactivity batch. Use
  * feature-specific reset APIs when a slice may be externally owned.
@@ -27,19 +28,21 @@ declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatu
  * table_reset(table)
  * ```
  */
-declare function table_reset<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+declare function table_reset<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): void;
 /**
  * Merges new table options with the current resolved options.
  *
  * If `options.mergeOptions` is provided, it owns the merge behavior; otherwise
- * options are shallow-merged.
+ * options are shallow-merged. Static options that should never change after
+ * initialization are restored on a fresh object so framework merge helpers may
+ * return readonly getter/proxy objects.
  *
  * @example
  * ```ts
  * const options = table_mergeOptions(table, nextOptions)
  * ```
  */
-declare function table_mergeOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, newOptions: TableOptions<TFeatures, TData>): TableOptions<TFeatures, TData>;
+declare function table_mergeOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, newOptions: TableOptions<TFeatures, TData>): TableOptions<TFeatures, TData>;
 /**
  * Updates the table options object.
  *
@@ -51,7 +54,7 @@ declare function table_mergeOptions<TFeatures extends TableFeatures, TData exten
  * table_setOptions(table, (old) => old)
  * ```
  */
-declare function table_setOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<TableOptions<TFeatures, TData>>): void;
+declare function table_setOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, updater: Updater<TableOptions<TFeatures, TData>>): void;
 //#endregion
 export { table_mergeOptions, table_reset, table_setOptions, table_syncExternalStateToBaseAtoms };
 //# sourceMappingURL=coreTablesFeature.utils.d.cts.map

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

@@ -1,7 +1,7 @@
 import { RowData, Updater } from "../../types/type-utils.js";
 import { TableOptions } from "../../types/TableOptions.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
-import { Table_Internal } from "../../types/Table.js";
 
 //#region src/core/table/coreTablesFeature.utils.d.ts
 /**
@@ -15,9 +15,10 @@ import { Table_Internal } from "../../types/Table.js";
  * table_syncExternalStateToBaseAtoms(table)
  * ```
  */
-declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): void;
 /**
- * Resets all internal table base atoms to `table.initialState`.
+ * Resets all internal table base atoms to `table.initialState`, then clears
+ * transient instance data through registered feature reset hooks.
  *
  * This resets internally owned state slices in a single reactivity batch. Use
  * feature-specific reset APIs when a slice may be externally owned.
@@ -27,19 +28,21 @@ declare function table_syncExternalStateToBaseAtoms<TFeatures extends TableFeatu
  * table_reset(table)
  * ```
  */
-declare function table_reset<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+declare function table_reset<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): void;
 /**
  * Merges new table options with the current resolved options.
  *
  * If `options.mergeOptions` is provided, it owns the merge behavior; otherwise
- * options are shallow-merged.
+ * options are shallow-merged. Static options that should never change after
+ * initialization are restored on a fresh object so framework merge helpers may
+ * return readonly getter/proxy objects.
  *
  * @example
  * ```ts
  * const options = table_mergeOptions(table, nextOptions)
  * ```
  */
-declare function table_mergeOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, newOptions: TableOptions<TFeatures, TData>): TableOptions<TFeatures, TData>;
+declare function table_mergeOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, newOptions: TableOptions<TFeatures, TData>): TableOptions<TFeatures, TData>;
 /**
  * Updates the table options object.
  *
@@ -51,7 +54,7 @@ declare function table_mergeOptions<TFeatures extends TableFeatures, TData exten
  * table_setOptions(table, (old) => old)
  * ```
  */
-declare function table_setOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<TableOptions<TFeatures, TData>>): void;
+declare function table_setOptions<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, updater: Updater<TableOptions<TFeatures, TData>>): void;
 //#endregion
 export { table_mergeOptions, table_reset, table_setOptions, table_syncExternalStateToBaseAtoms };
 //# sourceMappingURL=coreTablesFeature.utils.d.ts.map