@tanstack/table-core 9.0.0-beta.1 → 9.0.0-beta.11

package/skills/filtering/SKILL.md

@@ -3,7 +3,7 @@ name: filtering
 description: >
   Filter rows in TanStack Table v9 with the `filteredRowModel` pipeline stage.
   Covers `columnFilteringFeature` + `globalFilteringFeature` + `columnFacetingFeature`,
-  `createFilteredRowModel(filterFns)`, `createFacetedRowModel()` /
+  `createFilteredRowModel()` (registered on `features` with `filterFns` slot), `createFacetedRowModel()` /
   `createFacetedUniqueValues()` / `createFacetedMinMaxValues()`, fuzzy filtering
   with `@tanstack/match-sorter-utils`, the built-in `filterFns` registry, custom
   `filterFn` + module augmentation, `state.columnFilters` (Array<{ id, value }>),
@@ -36,13 +36,13 @@ This skill builds on `tanstack-table/state-management` and `tanstack-table/custo
 
 Filtering has five subsystems in v9 — register only the features you need:
 
-| Subsystem        | Feature                  | Row-model                           |
-| ---------------- | ------------------------ | ----------------------------------- |
-| column-filtering | `columnFilteringFeature` | `createFilteredRowModel(filterFns)` |
-| global-filtering | `globalFilteringFeature` | (same `filteredRowModel`)           |
-| column-faceting  | `columnFacetingFeature`  | `createFacetedRowModel()` + helpers |
-| global-faceting  | `globalFacetingFeature`  | global versions of the helpers      |
-| fuzzy-filtering  | (custom filterFn)        | `@tanstack/match-sorter-utils`      |
+| Subsystem        | Feature                  | Row-model                                     |
+| ---------------- | ------------------------ | --------------------------------------------- |
+| column-filtering | `columnFilteringFeature` | `createFilteredRowModel()` + `filterFns` slot |
+| global-filtering | `globalFilteringFeature` | (same `filteredRowModel`)                     |
+| column-faceting  | `columnFacetingFeature`  | `createFacetedRowModel()` + helpers           |
+| global-faceting  | `globalFacetingFeature`  | global versions of the helpers                |
+| fuzzy-filtering  | (custom filterFn)        | `@tanstack/match-sorter-utils`                |
 
 ```ts
 import {
@@ -60,14 +60,13 @@ const features = tableFeatures({
   columnFilteringFeature,
   globalFilteringFeature,
   rowPaginationFeature,
+  filteredRowModel: createFilteredRowModel(),
+  paginatedRowModel: createPaginatedRowModel(),
+  filterFns,
 })
 
 const table = constructTable({
   features,
-  rowModels: {
-    filteredRowModel: createFilteredRowModel(filterFns),
-    paginatedRowModel: createPaginatedRowModel(),
-  },
   columns,
   data,
   initialState: {
@@ -130,7 +129,7 @@ function Filter({ column }) {
 
 ### Faceted filter UIs and fuzzy global search
 
-Faceting requires `createFacetedRowModel()` as the base plus `createFacetedUniqueValues()` / `createFacetedMinMaxValues()`; fuzzy filtering wires a custom `FilterFn` backed by `@tanstack/match-sorter-utils` (`rankItem` / `compareItems`) with module augmentation for `FilterFns` + `FilterMeta`. Full examples in [faceting-and-fuzzy.md](references/faceting-and-fuzzy.md).
+Faceting requires `createFacetedRowModel()` as the base plus `createFacetedUniqueValues()` / `createFacetedMinMaxValues()` — all registered on the `features` object; fuzzy filtering wires a custom `FilterFn` backed by `@tanstack/match-sorter-utils` (`rankItem` / `compareItems`) with the `filterFns` registry slot and `filterMeta` slot for type-safe meta. Full examples in [faceting-and-fuzzy.md](references/faceting-and-fuzzy.md).
 
 ### Server-side filtering
 
@@ -143,7 +142,7 @@ const { data } = useQuery({
 })
 const table = useTable({
   features: tableFeatures({ columnFilteringFeature }),
-  rowModels: {}, // no filteredRowModel needed for manual filtering
+  // no filteredRowModel registered — server filters
   data,
   columns,
   manualFiltering: true,
@@ -155,12 +154,15 @@ const table = useTable({
 ### Filter tree data and keep matching descendants visible
 
 ```ts
+const features = tableFeatures({
+  columnFilteringFeature,
+  rowExpandingFeature,
+  filteredRowModel: createFilteredRowModel(),
+  expandedRowModel: createExpandedRowModel(),
+  filterFns,
+})
 const table = constructTable({
-  features: tableFeatures({ columnFilteringFeature, rowExpandingFeature }),
-  rowModels: {
-    filteredRowModel: createFilteredRowModel(filterFns),
-    expandedRowModel: createExpandedRowModel(),
-  },
+  features,
   columns,
   data,
   getSubRows: (r) => r.subRows,
@@ -176,13 +178,15 @@ Wrong:
 
 ```tsx
 const table = useTable({
-  features: tableFeatures({ columnFacetingFeature, columnFilteringFeature }),
-  rowModels: {
-    filteredRowModel: createFilteredRowModel(filterFns),
+  features: tableFeatures({
+    columnFacetingFeature,
+    columnFilteringFeature,
+    filteredRowModel: createFilteredRowModel(),
     // BUG: missing facetedRowModel
     facetedUniqueValues: createFacetedUniqueValues(),
     facetedMinMaxValues: createFacetedMinMaxValues(),
-  },
+    filterFns,
+  }),
   columns,
   data,
 })
@@ -196,14 +200,13 @@ const table = useTable({
     columnFacetingFeature,
     columnFilteringFeature,
     rowPaginationFeature,
-  }),
-  rowModels: {
-    filteredRowModel: createFilteredRowModel(filterFns),
+    filteredRowModel: createFilteredRowModel(),
     paginatedRowModel: createPaginatedRowModel(),
     facetedRowModel: createFacetedRowModel(), // REQUIRED base
     facetedMinMaxValues: createFacetedMinMaxValues(),
     facetedUniqueValues: createFacetedUniqueValues(),
-  },
+    filterFns,
+  }),
   columns,
   data,
 })
@@ -220,8 +223,11 @@ Wrong:
 ```tsx
 // manualFiltering bypasses the filteredRowModel — filter UI changes do nothing
 const table = useTable({
-  features: tableFeatures({ columnFilteringFeature }),
-  rowModels: { filteredRowModel: createFilteredRowModel(filterFns) },
+  features: tableFeatures({
+    columnFilteringFeature,
+    filteredRowModel: createFilteredRowModel(),
+    filterFns,
+  }),
   data,
   columns,
   manualFiltering: true,
@@ -241,7 +247,7 @@ const { data } = useQuery({
 
 const table = useTable({
   features: tableFeatures({ columnFilteringFeature }),
-  rowModels: {}, // no filteredRowModel needed
+  // no filteredRowModel registered for manual mode
   data,
   columns,
   manualFiltering: true,
@@ -260,9 +266,11 @@ Wrong:
 
 ```tsx
 // drops the built-in registry
-filteredRowModel: createFilteredRowModel({
-  fuzzy: fuzzyFilter,
-}),
+const features = tableFeatures({
+  columnFilteringFeature,
+  filteredRowModel: createFilteredRowModel(),
+  filterFns: { fuzzy: fuzzyFilter }, // BUG: drops built-ins
+})
 // Column with filterFn: 'includesString' now warns and never filters
 ```
 
@@ -271,13 +279,17 @@ Correct:
 ```tsx
 import { filterFns } from '@tanstack/react-table'
 
-filteredRowModel: createFilteredRowModel({
-  ...filterFns, // KEEP built-ins
-  fuzzy: fuzzyFilter, // ADD custom
-}),
+const features = tableFeatures({
+  columnFilteringFeature,
+  filteredRowModel: createFilteredRowModel(),
+  filterFns: {
+    ...filterFns, // KEEP built-ins
+    fuzzy: fuzzyFilter, // ADD custom
+  },
+})
 ```
 
-`createFilteredRowModel` replaces the registry with whatever you pass. Any column using a built-in name like `'includesString'` becomes a no-op.
+The `filterFns` slot replaces the registry with whatever you provide. Any column using a built-in name like `'includesString'` becomes a no-op if the built-ins are dropped.
 
 Source: examples/react/filters-fuzzy/src/main.tsx
 
@@ -298,8 +310,11 @@ Correct:
 
 ```tsx
 const table = useTable({
-  features: tableFeatures({ globalFilteringFeature }),
-  rowModels: { filteredRowModel: createFilteredRowModel(filterFns) },
+  features: tableFeatures({
+    globalFilteringFeature,
+    filteredRowModel: createFilteredRowModel(),
+    filterFns,
+  }),
   columns,
   data,
   globalFilterFn: 'includesString',
@@ -333,8 +348,11 @@ Correct:
 
 ```ts
 const table = useTable({
-  features: tableFeatures({ columnFilteringFeature }),
-  rowModels: { filteredRowModel: createFilteredRowModel(filterFns) },
+  features: tableFeatures({
+    columnFilteringFeature,
+    filteredRowModel: createFilteredRowModel(),
+    filterFns,
+  }),
   columns,
   data,
 })

package/skills/filtering/references/faceting-and-fuzzy.md

@@ -16,17 +16,16 @@ const features = tableFeatures({
   columnFacetingFeature,
   columnFilteringFeature,
   rowPaginationFeature,
+  filteredRowModel: createFilteredRowModel(),
+  paginatedRowModel: createPaginatedRowModel(),
+  facetedRowModel: createFacetedRowModel(), // REQUIRED base
+  facetedMinMaxValues: createFacetedMinMaxValues(),
+  facetedUniqueValues: createFacetedUniqueValues(),
+  filterFns,
 })
 
 const table = constructTable({
   features,
-  rowModels: {
-    filteredRowModel: createFilteredRowModel(filterFns),
-    paginatedRowModel: createPaginatedRowModel(),
-    facetedRowModel: createFacetedRowModel(), // REQUIRED base
-    facetedMinMaxValues: createFacetedMinMaxValues(),
-    facetedUniqueValues: createFacetedUniqueValues(),
-  },
   columns,
   data,
 })
@@ -44,18 +43,28 @@ import {
   compareItems,
   type RankingInfo,
 } from '@tanstack/match-sorter-utils'
-import type { FilterFn, SortFn } from '@tanstack/table-core'
+import {
+  tableFeatures,
+  columnFilteringFeature,
+  globalFilteringFeature,
+  rowSortingFeature,
+  createFilteredRowModel,
+  createSortedRowModel,
+  filterFns,
+  sortFns,
+  metaHelper,
+} from '@tanstack/table-core'
+import type { FilterFn, SortFn, TableFeatures } from '@tanstack/table-core'
 
-declare module '@tanstack/react-table' {
-  interface FilterFns {
-    fuzzy: FilterFn<typeof features, Person>
-  }
-  interface FilterMeta {
-    itemRank?: RankingInfo
-  }
+// 1. Describe the filterMeta shape for this feature set.
+interface FuzzyFilterMeta {
+  itemRank?: RankingInfo
 }
 
-const fuzzyFilter: FilterFn<typeof features, Person> = (
+// 2. Extend TableFeatures so FilterFn / SortFn can read filterMeta types.
+type FuzzyFeatures = TableFeatures & { filterMeta: FuzzyFilterMeta }
+
+const fuzzyFilter: FilterFn<FuzzyFeatures, Person> = (
   row,
   columnId,
   value,
@@ -66,7 +75,7 @@ const fuzzyFilter: FilterFn<typeof features, Person> = (
   return itemRank.passed
 }
 
-const fuzzySort: SortFn<typeof features, Person> = (rowA, rowB, columnId) => {
+const fuzzySort: SortFn<FuzzyFeatures, Person> = (rowA, rowB, columnId) => {
   let dir = 0
   if (rowA.columnFiltersMeta[columnId]) {
     dir = compareItems(
@@ -77,21 +86,35 @@ const fuzzySort: SortFn<typeof features, Person> = (rowA, rowB, columnId) => {
   return dir === 0 ? sortFns.alphanumeric(rowA, rowB, columnId) : dir
 }
 
+// 3. Register everything on features — no rowModels option needed.
+const features = tableFeatures({
+  columnFilteringFeature,
+  globalFilteringFeature,
+  rowSortingFeature,
+  filteredRowModel: createFilteredRowModel(),
+  sortedRowModel: createSortedRowModel(),
+  filterFns: { ...filterFns, fuzzy: fuzzyFilter },
+  sortFns: { ...sortFns, fuzzy: fuzzySort },
+  filterMeta: metaHelper<FuzzyFilterMeta>(),
+})
+
 const table = constructTable({
   features,
-  rowModels: {
-    filteredRowModel: createFilteredRowModel({
-      ...filterFns,
-      fuzzy: fuzzyFilter,
-    }),
-    sortedRowModel: createSortedRowModel(sortFns),
-  },
   columns,
   data,
   globalFilterFn: 'fuzzy',
 })
 ```
 
+Use string refs in column defs when the fn is registered:
+
+```ts
+columnHelper.accessor('fullName', {
+  filterFn: 'fuzzy', // string ref — typechecks because 'fuzzy' is in features.filterFns
+  sortFn: 'fuzzy',
+})
+```
+
 ## Additional MEDIUM-priority failure modes
 
 ### Using `state.columnFilters` AND `initialState.columnFilters` simultaneously
@@ -131,11 +154,13 @@ Wrong:
 ```tsx
 // filterFromLeafRows hides children that don't match individually
 const table = useTable({
-  features: tableFeatures({ columnFilteringFeature, rowExpandingFeature }),
-  rowModels: {
-    filteredRowModel: createFilteredRowModel(filterFns),
+  features: tableFeatures({
+    columnFilteringFeature,
+    rowExpandingFeature,
+    filteredRowModel: createFilteredRowModel(),
     expandedRowModel: createExpandedRowModel(),
-  },
+    filterFns,
+  }),
   columns,
   data,
   getSubRows: (r) => r.subRows,
@@ -150,11 +175,13 @@ Correct:
 ```tsx
 // Filter root-only to preserve all sub-rows under a matching parent
 const table = useTable({
-  features: tableFeatures({ columnFilteringFeature, rowExpandingFeature }),
-  rowModels: {
-    filteredRowModel: createFilteredRowModel(filterFns),
+  features: tableFeatures({
+    columnFilteringFeature,
+    rowExpandingFeature,
+    filteredRowModel: createFilteredRowModel(),
     expandedRowModel: createExpandedRowModel(),
-  },
+    filterFns,
+  }),
   columns,
   data,
   getSubRows: (r) => r.subRows,

package/skills/grouping/SKILL.md

@@ -2,7 +2,7 @@
 name: grouping
 description: >
   Group rows by column values in TanStack Table v9 with the `groupedRowModel`
-  stage. Covers `columnGroupingFeature` + `createGroupedRowModel(aggregationFns)`,
+  stage. Covers `columnGroupingFeature` + `createGroupedRowModel()` (registered on `features` with `aggregationFns` slot),
   `state.grouping` (GroupingState = Array<string>), `onGroupingChange`,
   `columnDef.aggregationFn` ('auto'|name|fn) — distinct signature
   `(columnId, leafRows, childRows)` — `columnDef.aggregatedCell`,
@@ -49,6 +49,10 @@ const features = tableFeatures({
   columnGroupingFeature,
   rowExpandingFeature,
   rowPaginationFeature,
+  groupedRowModel: createGroupedRowModel(),
+  expandedRowModel: createExpandedRowModel(),
+  paginatedRowModel: createPaginatedRowModel(),
+  aggregationFns,
 })
 
 const columnHelper = createColumnHelper<typeof features, Person>()
@@ -66,11 +70,6 @@ const columns = columnHelper.columns([
 
 const table = constructTable({
   features,
-  rowModels: {
-    groupedRowModel: createGroupedRowModel(aggregationFns),
-    expandedRowModel: createExpandedRowModel(),
-    paginatedRowModel: createPaginatedRowModel(),
-  },
   columns,
   data,
   initialState: { grouping: [] satisfies GroupingState },
@@ -144,15 +143,16 @@ const weightedAverage: AggregationFn<typeof features, Person> = (
   return totalWeight === 0 ? 0 : weightedSum / totalWeight
 }
 
+const customFeatures = tableFeatures({
+  columnGroupingFeature,
+  rowExpandingFeature,
+  groupedRowModel: createGroupedRowModel(),
+  expandedRowModel: createExpandedRowModel(),
+  aggregationFns: { ...aggregationFns, weightedAverage },
+})
+
 const table = constructTable({
-  features,
-  rowModels: {
-    groupedRowModel: createGroupedRowModel({
-      ...aggregationFns,
-      weightedAverage,
-    }),
-    expandedRowModel: createExpandedRowModel(),
-  },
+  features: customFeatures,
   columns: columnHelper.columns([
     columnHelper.accessor('progress', {
       aggregationFn: 'weightedAverage',
@@ -177,10 +177,6 @@ columnHelper.accessor('firstName', {
 ```ts
 const table = constructTable({
   features,
-  rowModels: {
-    groupedRowModel: createGroupedRowModel(aggregationFns),
-    expandedRowModel: createExpandedRowModel(),
-  },
   columns,
   data,
   groupedColumnMode: 'reorder', // default — grouped columns lead
@@ -197,13 +193,12 @@ Wrong:
 
 ```ts
 // grouped rows show aggregates but can't be expanded
-const features = tableFeatures({ columnGroupingFeature })
-const table = useTable({
-  features,
-  rowModels: { groupedRowModel: createGroupedRowModel(aggregationFns) },
-  columns,
-  data,
+const features = tableFeatures({
+  columnGroupingFeature,
+  groupedRowModel: createGroupedRowModel(),
+  aggregationFns,
 })
+const table = useTable({ features, columns, data })
 // row.getToggleExpandedHandler() → TS error or undefined
 ```
 
@@ -221,16 +216,12 @@ import {
 const features = tableFeatures({
   columnGroupingFeature,
   rowExpandingFeature,
+  groupedRowModel: createGroupedRowModel(),
+  expandedRowModel: createExpandedRowModel(),
+  aggregationFns,
 })
 
-const table = useTable({
-  features,
-  rowModels: {
-    groupedRowModel: createGroupedRowModel(aggregationFns),
-    expandedRowModel: createExpandedRowModel(),
-  },
-  columns, data,
-})
+const table = useTable({ features, columns, data })
 
 // In cell renderer:
 {cell.getIsGrouped() && (
@@ -250,8 +241,11 @@ Wrong:
 
 ```ts
 const table = useTable({
-  features: tableFeatures({ columnGroupingFeature }),
-  rowModels: { groupedRowModel: createGroupedRowModel(aggregationFns) },
+  features: tableFeatures({
+    columnGroupingFeature,
+    groupedRowModel: createGroupedRowModel(),
+    aggregationFns,
+  }),
   columns, data,
   // @ts-ignore - this property doesn't exist on v9 TableOptions
   aggregationFns: {
@@ -265,26 +259,26 @@ Correct:
 ```ts
 import { aggregationFns, createGroupedRowModel } from '@tanstack/react-table'
 
-const table = useTable({
-  features: tableFeatures({ columnGroupingFeature, rowExpandingFeature }),
-  rowModels: {
-    groupedRowModel: createGroupedRowModel({
-      ...aggregationFns,
-      myCustomAggregation: (columnId, leafRows, childRows) => {
-        return /* aggregated value */
-      },
-    }),
-    expandedRowModel: createExpandedRowModel(),
+const features = tableFeatures({
+  columnGroupingFeature,
+  rowExpandingFeature,
+  groupedRowModel: createGroupedRowModel(),
+  expandedRowModel: createExpandedRowModel(),
+  aggregationFns: {
+    ...aggregationFns,
+    myCustomAggregation: (columnId, leafRows, childRows) => {
+      return /* aggregated value */
+    },
   },
-  columns,
-  data,
 })
 
+const table = useTable({ features, columns, data })
+
 // Then on a column:
 columnHelper.accessor('sales', { aggregationFn: 'myCustomAggregation' })
 ```
 
-In v9, the aggregation registry is the FIRST argument to `createGroupedRowModel`. There is no top-level `tableOptions.aggregationFns`.
+In v9, the aggregation registry is the `aggregationFns` slot on `features`. There is no top-level `tableOptions.aggregationFns`.
 
 Source: packages/table-core/src/features/column-grouping/createGroupedRowModel.ts
 
@@ -345,7 +339,6 @@ Wrong:
 ```ts
 const table = useTable({
   features,
-  rowModels: { groupedRowModel: createGroupedRowModel(aggregationFns) },
   columns,
   data,
   initialState: {
@@ -361,7 +354,6 @@ Correct:
 ```ts
 const table = useTable({
   features,
-  rowModels: { groupedRowModel: createGroupedRowModel(aggregationFns) },
   columns,
   data,
   initialState: {
@@ -424,12 +416,15 @@ const grouped = useMemo(() => {
 Correct:
 
 ```ts
+const features = tableFeatures({
+  columnGroupingFeature,
+  rowExpandingFeature,
+  groupedRowModel: createGroupedRowModel(),
+  expandedRowModel: createExpandedRowModel(),
+  aggregationFns,
+})
 const table = useTable({
-  features: tableFeatures({ columnGroupingFeature, rowExpandingFeature }),
-  rowModels: {
-    groupedRowModel: createGroupedRowModel(aggregationFns),
-    expandedRowModel: createExpandedRowModel(),
-  },
+  features,
   columns: columnHelper.columns([
     columnHelper.accessor('status', { enableGrouping: true }),
     columnHelper.accessor('age', { aggregationFn: 'mean' }),

package/skills/migrate-v8-to-v9/SKILL.md

@@ -4,11 +4,12 @@ description: >
   Mechanical breaking-change migration from TanStack Table v8 to v9 at the
   `@tanstack/table-core` level. Covers hook/entry rename
   (`useReactTable`/`createSolidTable`/… → `useTable`/`injectTable`/`createTable`/
-  `constructTable`), the new required `features` + `rowModels` options,
+  `constructTable`), the new required `features` option (which now carries row
+  model factories and fn registries — `rowModels` option is removed),
   `createColumnHelper<TData>()` → `createColumnHelper<typeof features, TData>()`,
   row-model factory rename (`getCoreRowModel()` → automatic; `getSortedRowModel()`
-  → `createSortedRowModel(sortFns)`; same for filtered/paginated/grouped/expanded/
-  faceted), `table.getState()` → `table.store.state` / `table.atoms.<slice>.get()`,
+  → `createSortedRowModel()` as a slot on `tableFeatures({...})` with `sortFns` also
+  a slot; same for filtered/paginated/grouped/expanded/faceted), `table.getState()` → `table.store.state` / `table.atoms.<slice>.get()`,
   sorting renames (`sortingFn` → `sortFn`, etc.), `enablePinning` split, column
   sizing/resizing split, underscore-prefixed APIs becoming public, `RowData`
   type tightening, TFeatures-first generics, the `useLegacyTable` React escape
@@ -32,9 +33,9 @@ sources:
 v9 is a substantial reshape, not a tweak. The breaking changes group into:
 
 1. **Hook/entry rename** per adapter.
-2. **`features` + `rowModels` are required** — features are tree-shaken.
+2. **`features` is required** — features are tree-shaken. Row model factories and fn registries (`sortFns`, `filterFns`, `aggregationFns`) now live as slots on the `features` object; the `rowModels` option is gone.
 3. **Column helper generic order** — `<TFeatures, TData>` not `<TData>`.
-4. **Row-model factories** moved out of root options, into `rowModels`, and now take their `*Fns` argument.
+4. **Row-model factories** moved out of root options and into `tableFeatures({...})` as named slots; factory args for `*Fns` are replaced by dedicated fn-registry slots on `features`.
 5. **State surface renamed** — `table.getState()` → `table.store.state` / `table.atoms.<slice>.get()` / `table.state` (selector).
 6. **Sorting names**: `sortingFn` → `sortFn`, `sortingFns` → `sortFns`, `getSortingFn()` → `getSortFn()`, type `SortingFn` → `SortFn`.
 7. **`enablePinning` split** into `enableColumnPinning` + `enableRowPinning` (table-level); per-column `enablePinning` stays.
@@ -75,6 +76,12 @@ const features = tableFeatures({
   columnFilteringFeature,
   columnSizingFeature,
   columnResizingFeature, // explicit — formerly part of ColumnSizing
+  // Row model factories and fn registries are slots on features, not rowModels.
+  sortedRowModel: createSortedRowModel(),
+  filteredRowModel: createFilteredRowModel(),
+  paginatedRowModel: createPaginatedRowModel(),
+  sortFns,
+  filterFns,
 })
 
 const columnHelper = createColumnHelper<typeof features, Person>()
@@ -88,11 +95,6 @@ const columns: ColumnDef<typeof features, Person>[] = columnHelper.columns([
 
 const table = useTable({
   features,
-  rowModels: {
-    sortedRowModel: createSortedRowModel(sortFns),
-    filteredRowModel: createFilteredRowModel(filterFns),
-    paginatedRowModel: createPaginatedRowModel(),
-  },
   columns,
   data,
   enableColumnPinning: true, // split from enablePinning
@@ -200,13 +202,12 @@ import {
   sortFns,
 } from '@tanstack/react-table'
 
-const features = tableFeatures({ rowSortingFeature })
-const table = useTable({
-  features,
-  rowModels: { sortedRowModel: createSortedRowModel(sortFns) },
-  columns,
-  data,
+const features = tableFeatures({
+  rowSortingFeature,
+  sortedRowModel: createSortedRowModel(),
+  sortFns,
 })
+const table = useTable({ features, columns, data })
 ```
 
 Every major release of TanStack Table has been a substantial upgrade. Agents trained on v7 or v8 will confidently emit shapes that no longer exist. This is the #2 AI failure (after reimplementing built-ins).
@@ -239,18 +240,15 @@ import {
   sortFns,
 } from '@tanstack/react-table'
 
-const features = tableFeatures({ rowSortingFeature })
-const table = useTable({
-  features,
-  rowModels: {
-    sortedRowModel: createSortedRowModel(sortFns), // factory takes sortFns argument
-  },
-  columns,
-  data,
+const features = tableFeatures({
+  rowSortingFeature,
+  sortedRowModel: createSortedRowModel(),
+  sortFns,
 })
+const table = useTable({ features, columns, data })
 ```
 
-In v9, row models live under `rowModels` and the factories REQUIRE their \*Fns argument for tree-shaking: `createFilteredRowModel(filterFns)`, `createSortedRowModel(sortFns)`, `createGroupedRowModel(aggregationFns)`. Core is automatic.
+In v9, row model factories are slots on `features`: `filteredRowModel: createFilteredRowModel()`, `sortedRowModel: createSortedRowModel()`, `groupedRowModel: createGroupedRowModel()`. The fn registries move too: `filterFns`, `sortFns`, `aggregationFns` are named slots on `features`. Core is automatic.
 
 Source: PR #6234 (atoms refactor); packages/table-core/src/index.ts
 
@@ -307,11 +305,11 @@ Correct:
 
 ```ts
 columnHelper.accessor('age', { sortFn: 'alphanumeric' })
-createSortedRowModel(sortFns) // pass registry to the factory
+// sortFns is a slot on features: tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns })
 column.getSortFn()
 ```
 
-v9 renamed every sorting API: `sortingFn` → `sortFn`, `sortingFns` → `sortFns`, type `SortingFn` → `SortFn`, `getSortingFn()` → `getSortFn()`. TypeScript surfaces these but agents try v8 names first.
+v9 renamed every sorting API: `sortingFn` → `sortFn`, `sortingFns` → `sortFns` (now a features slot, not a factory arg), type `SortingFn` → `SortFn`, `getSortingFn()` → `getSortFn()`. TypeScript surfaces these but agents try v8 names first.
 
 Source: packages/table-core/src/features/row-sorting/rowSortingFeature.types.ts
 
@@ -475,13 +473,12 @@ import {
   createSortedRowModel,
   sortFns,
 } from '@tanstack/react-table'
-const features = tableFeatures({ rowSortingFeature })
-const table = useTable({
-  features,
-  rowModels: { sortedRowModel: createSortedRowModel(sortFns) },
-  columns,
-  data,
+const features = tableFeatures({
+  rowSortingFeature,
+  sortedRowModel: createSortedRowModel(),
+  sortFns,
 })
+const table = useTable({ features, columns, data })
 ```
 
 `useLegacyTable` is React-only, deprecated, bundles every feature, doesn't support `table.Subscribe`, and is removed in v10. It exists to unblock incremental migration — not as a long-term API.