@tanstack/vue-table 9.0.0-beta.3 → 9.0.0-beta.30

package/skills/vue/compose-with-tanstack-query/SKILL.md

@@ -4,12 +4,12 @@ description: >
   Server-side / async data flow for `@tanstack/vue-table` v9 + `@tanstack/vue-query`. Key the
   `useQuery` query on the table state that drives the request (pagination + sorting + filters).
   Set `manualPagination` / `manualSorting` / `manualFiltering` for slices the server owns.
-  Drop the matching `rowModels` factory (don't ship `paginatedRowModel` when the server
-  paginates). Pass `rowCount` so `table.getPageCount()` works without all rows in memory. Pass
-  `placeholderData: keepPreviousData` to avoid a "0 rows flash" between pages. The cleanest
-  wiring uses external `createAtom`s + `options.atoms` so the table writes through to the atom
-  and the query refetches with no `on[State]Change` plumbing. The canonical Vue example is at
-  `examples/vue/with-tanstack-query/`.
+  Omit the matching row model factory from `tableFeatures` (don't ship `paginatedRowModel` when
+  the server paginates). Pass `rowCount` so `table.getPageCount()` works without all rows in
+  memory. Pass `placeholderData: keepPreviousData` to avoid a "0 rows flash" between pages. The
+  cleanest wiring uses external `createAtom`s + `options.atoms` so the table writes through to
+  the atom and the query refetches with no `on[State]Change` plumbing. The canonical Vue example
+  is at `examples/vue/with-tanstack-query/`.
 type: composition
 library: tanstack-table
 framework: vue
@@ -87,10 +87,9 @@ watchEffect(() => {
   if (next != null) rowCount.value = next
 })
 
-// 5) Manual pagination. No paginatedRowModel — server paginates.
+// 5) Manual pagination. No paginatedRowModel in features — server paginates.
 const table = useTable({
   features,
-  rowModels: {},
   columns,
   data: tableData,
   rowCount,
@@ -219,12 +218,12 @@ const dataQuery = useQuery(() => ({
 }))
 
 const table = useTable({
+  // server owns all three slices — no row model factories registered
   features: tableFeatures({
     rowSortingFeature,
     rowPaginationFeature,
     columnFilteringFeature,
   }),
-  rowModels: {}, // server owns all three
   columns,
   data: computed(() => dataQuery.data.value?.rows ?? EMPTY),
   rowCount,
@@ -265,7 +264,6 @@ Query tells it. Always invalidate on writes.
 // ❌ Table re-paginates the already-paginated server response.
 useTable({
   features,
-  rowModels: {},
   columns,
   data: tableData,
   rowCount,
@@ -286,13 +284,13 @@ server already paginated. The pager locks at "Page 1 of 1".
 
 ```ts
 // ❌ Ships the factory for nothing AND it tries to paginate server-paginated data.
-rowModels: {
-  paginatedRowModel: createPaginatedRowModel()
-}
+const features = tableFeatures({
+  rowPaginationFeature,
+  paginatedRowModel: createPaginatedRowModel(),
+})
 
-// ✅
-rowModels: {
-}
+// ✅ Omit the factory when the server paginates.
+const features = tableFeatures({ rowPaginationFeature })
 ```
 
 ### Forgetting controlled state in `queryKey` (CRITICAL)
@@ -350,14 +348,14 @@ Same hooks names, different reactivity model (function-returning-options instead
 
 ### Hallucinating pre-v9 table APIs (CRITICAL)
 
-`useVueTable` + `getCoreRowModel: getCoreRowModel()` is v8. v9 uses `useTable` +
-`features` + `rowModels`. See `tanstack-table/vue/migrate-v8-to-v9`.
+`useVueTable` + `getCoreRowModel: getCoreRowModel()` is v8. v9 uses `useTable` + `features`
+with row model factories as slots. See `tanstack-table/vue/migrate-v8-to-v9`.
 
 ### "API missing" because feature not in `features` (CRITICAL — v9-specific)
 
 Server-side pagination still needs `rowPaginationFeature` in `tableFeatures({...})`. The
-feature gives you `table.nextPage` / `table.setPageIndex` / `table.getPageCount`. The
-`rowModels` factory is what you drop; the feature stays.
+feature gives you `table.nextPage` / `table.setPageIndex` / `table.getPageCount`. The row
+model factory (`paginatedRowModel`) is what you omit; the feature stays.
 
 ### Reimplementing pagination loop manually (CRITICAL — #1 AI tell)
 

package/skills/vue/compose-with-tanstack-store/SKILL.md

@@ -57,7 +57,13 @@ import {
 
 type Person = { firstName: string; lastName: string; age: number }
 
-const features = tableFeatures({ rowSortingFeature, rowPaginationFeature })
+const features = tableFeatures({
+  rowSortingFeature,
+  rowPaginationFeature,
+  sortedRowModel: createSortedRowModel(),
+  paginatedRowModel: createPaginatedRowModel(),
+  sortFns,
+})
 const columnHelper = createColumnHelper<typeof features, Person>()
 const columns = columnHelper.columns([
   columnHelper.accessor('firstName', { header: 'First' }),
@@ -82,10 +88,6 @@ const data = ref<Person[]>([])
 //    `table.setSorting()` writes through to your atom.
 const table = useTable({
   features,
-  rowModels: {
-    sortedRowModel: createSortedRowModel(sortFns),
-    paginatedRowModel: createPaginatedRowModel(),
-  },
   columns,
   data,
   atoms: {
@@ -141,7 +143,6 @@ options.atoms[slice]    >  options.state[slice]  >  table.baseAtoms[slice]
 // ❌ Passing both for the SAME slice. `atoms.sorting` wins; `state.sorting` is silently dead.
 useTable({
   features,
-  rowModels: {},
   columns,
   data,
   state: {

package/skills/vue/compose-with-tanstack-virtual/SKILL.md

@@ -56,7 +56,12 @@ import {
 import { useVirtualizer } from '@tanstack/vue-virtual'
 import { makeData, type Person } from './makeData'
 
-const features = tableFeatures({ columnSizingFeature, rowSortingFeature })
+const features = tableFeatures({
+  columnSizingFeature,
+  rowSortingFeature,
+  sortedRowModel: createSortedRowModel(),
+  sortFns,
+})
 
 const columns: ColumnDef<typeof features, Person>[] = [
   { accessorKey: 'firstName' },
@@ -68,7 +73,6 @@ const data = ref<Person[]>(makeData(50_000))
 
 const table = useTable({
   features,
-  rowModels: { sortedRowModel: createSortedRowModel(sortFns) },
   columns,
   data,
 })
@@ -322,8 +326,8 @@ in Vue, not a plain object.
 ### "API missing" — `getRowModel` returns nothing (CRITICAL — v9-specific)
 
 If `table.getRowModel().rows` is empty when data is loaded, the row-model feature for whatever
-slice you need (filtering/sorting/grouping) isn't registered. Add it to `tableFeatures({...})`
-and `rowModels`.
+slice you need (filtering/sorting/grouping) isn't registered. Add the feature, its factory, and
+its fn registry to `tableFeatures({...})`.
 
 ### Reimplementing virtualization manually (CRITICAL — #1 AI tell)
 

package/skills/vue/getting-started/SKILL.md

@@ -2,11 +2,11 @@
 name: vue/getting-started
 description: >
   End-to-end first-table walkthrough for `@tanstack/vue-table` v9. Install the adapter, declare
-  `features` via `tableFeatures({})`, declare `rowModels` with their `*Fns` parameters
-  (`createSortedRowModel(sortFns)`, `createPaginatedRowModel()`, …), build a column helper with
-  both `TFeatures` and `TData` generics, instantiate `useTable(options, selector?)` from a
-  `<script setup>` block, and render with `<FlexRender :cell="cell" />` / `:header="header"`.
-  New users land here, not on legacy v8 names like `useVueTable`.
+  `features` via `tableFeatures({})` (row model factories and fn registries live here as slots),
+  build a column helper with both `TFeatures` and `TData` generics, instantiate
+  `useTable(options, selector?)` from a `<script setup>` block, and render with
+  `<FlexRender :cell="cell" />` / `:header="header"`. New users land here, not on legacy v8
+  names like `useVueTable`.
 type: lifecycle
 library: tanstack-table
 framework: vue
@@ -69,7 +69,6 @@ const data = ref<Person[]>([
 
 const table = useTable({
   features,
-  rowModels: {}, // required — core row model is automatic
   columns,
   data,
 })
@@ -100,8 +99,8 @@ Source: `examples/vue/basic-use-table/src/App.tsx`, `docs/framework/vue/vue-tabl
 ### What's mandatory in v9
 
 - `features` — built via `tableFeatures({...})`. Empty object is fine for a no-features table,
-  but the option key must exist.
-- `rowModels` — `{}` is fine (core row model is automatic). Register factories per feature.
+  but the option key must exist. Row model factories and fn registries go here as slots, not
+  as a separate `rowModels` option.
 - `createColumnHelper<typeof features, Person>()` — two generics, in that order. The v8 single
   generic does not compile.
 
@@ -122,7 +121,11 @@ import {
   useTable,
 } from '@tanstack/vue-table'
 
-const features = tableFeatures({ rowSortingFeature })
+const features = tableFeatures({
+  rowSortingFeature,
+  sortedRowModel: createSortedRowModel(),
+  sortFns,
+})
 const columnHelper = createColumnHelper<typeof features, Person>()
 const columns = columnHelper.columns([
   columnHelper.accessor('firstName', { header: 'First' }),
@@ -133,7 +136,6 @@ const data = ref<Person[]>([])
 
 const table = useTable({
   features,
-  rowModels: { sortedRowModel: createSortedRowModel(sortFns) },
   columns,
   data,
 })
@@ -159,10 +161,10 @@ const table = useTable({
 
 Three rules:
 
-1. Register the feature in `features` (`rowSortingFeature`).
-2. Provide the matching row model factory in `rowModels`
-   (`sortedRowModel: createSortedRowModel(sortFns)`). The factory **requires its `*Fns`
-   parameter** in v9 — this is what makes filter/sort registries tree-shakeable.
+1. Register the feature in `features` (`rowSortingFeature`) along with its row model factory
+   and fn registry as slots on the same object.
+2. The fn registry (`sortFns`) is what makes filter/sort registries tree-shakeable in v9 — do
+   not drop it.
 3. Wire UI to the built-in API: `column.getToggleSortingHandler()`, `column.getIsSorted()`.
    Do not reimplement sort logic.
 
@@ -187,13 +189,12 @@ const features = tableFeatures({
   rowSortingFeature,
   rowPaginationFeature,
   columnFilteringFeature,
-})
-
-const rowModels = {
-  sortedRowModel: createSortedRowModel(sortFns),
-  filteredRowModel: createFilteredRowModel(filterFns),
+  sortedRowModel: createSortedRowModel(),
+  filteredRowModel: createFilteredRowModel(),
   paginatedRowModel: createPaginatedRowModel(),
-}
+  sortFns,
+  filterFns,
+})
 ```
 
 Then use `table.nextPage()`, `table.setPageIndex(0)`, `table.setColumnFilters(...)`,
@@ -201,7 +202,7 @@ Then use `table.nextPage()`, `table.setPageIndex(0)`, `table.setColumnFilters(..
 
 ### 3. App-scoped tables with `createTableHook`
 
-If multiple tables in your app share `features`, `rowModels`, and conventions, prefer
+If multiple tables in your app share a `features` object (with its row model factories and conventions), prefer
 `createTableHook`. The hook factory returns `useAppTable`, `createAppColumnHelper`, plus
 context helpers (`useTableContext`, `useCellContext`, `useHeaderContext`).
 
@@ -217,14 +218,16 @@ import {
   tableFeatures,
 } from '@tanstack/vue-table'
 
-const features = tableFeatures({ rowSortingFeature, rowPaginationFeature })
+const features = tableFeatures({
+  rowSortingFeature,
+  rowPaginationFeature,
+  sortedRowModel: createSortedRowModel(),
+  paginatedRowModel: createPaginatedRowModel(),
+  sortFns,
+})
 
 export const { useAppTable, createAppColumnHelper } = createTableHook({
   features,
-  rowModels: {
-    sortedRowModel: createSortedRowModel(sortFns),
-    paginatedRowModel: createPaginatedRowModel(),
-  },
 })
 ```
 
@@ -274,7 +277,6 @@ export default defineComponent({
     const data = ref<Person[]>([])
     const table = useTable({
       features,
-      rowModels: {},
       columns,
       get data() {
         return data.value
@@ -304,7 +306,7 @@ Source: `examples/vue/basic-use-table/src/App.tsx`.
 
 ## Common Mistakes
 
-### Omitting `features` or `rowModels` (CRITICAL)
+### Omitting `features` (CRITICAL)
 
 ```ts
 // ❌ TS error: Property 'features' is missing in type ...
@@ -312,10 +314,10 @@ const table = useTable({ columns, data })
 
 // ✅
 const features = tableFeatures({})
-const table = useTable({ features, rowModels: {}, columns, data })
+const table = useTable({ features, columns, data })
 ```
 
-Both keys are required even for the simplest table.
+`features` is required even for the simplest table.
 
 ### Wrong `createColumnHelper` arity (CRITICAL)
 
@@ -327,20 +329,25 @@ const columnHelper = createColumnHelper<Person>()
 const columnHelper = createColumnHelper<typeof features, Person>()
 ```
 
-### Calling row-model factories without their `*Fns` parameter (CRITICAL)
+### Omitting the `*Fns` registry from `tableFeatures` (CRITICAL)
 
 ```ts
-// ❌ TS error / runtime missing fns.
-rowModels: {
-  sortedRowModel:   createSortedRowModel(),
-  filteredRowModel: createFilteredRowModel(),
-}
+// ❌ TS error / runtime missing fns — sort is a no-op.
+const features = tableFeatures({
+  rowSortingFeature,
+  sortedRowModel: createSortedRowModel(),
+  // sortFns missing!
+})
 
-// ✅ Pass the matching registry.
-rowModels: {
-  sortedRowModel:   createSortedRowModel(sortFns),
-  filteredRowModel: createFilteredRowModel(filterFns),
-}
+// ✅ Register the fn map as a slot alongside the factory.
+const features = tableFeatures({
+  rowSortingFeature,
+  columnFilteringFeature,
+  sortedRowModel: createSortedRowModel(),
+  filteredRowModel: createFilteredRowModel(),
+  sortFns,
+  filterFns,
+})
 ```
 
 This is what makes v9 tree-shakeable. Filter/sort/aggregation registries are open-ended — do
@@ -351,17 +358,16 @@ not cite a number of built-in fns; just pass `filterFns` / `sortFns` / `aggregat
 ```ts
 // ❌ `rowSortingFeature` not registered → `table.setSorting` is `undefined` and a TS error.
 const features = tableFeatures({})
-const table = useTable({ features, rowModels: {}, columns, data })
+const table = useTable({ features, columns, data })
 table.setSorting([{ id: 'age', desc: true }]) // missing
 
-// ✅ Register the feature AND its row model.
-const features = tableFeatures({ rowSortingFeature })
-const table = useTable({
-  features,
-  rowModels: { sortedRowModel: createSortedRowModel(sortFns) },
-  columns,
-  data,
+// ✅ Register the feature, its row model factory, and its fn registry in tableFeatures.
+const features = tableFeatures({
+  rowSortingFeature,
+  sortedRowModel: createSortedRowModel(),
+  sortFns,
 })
+const table = useTable({ features, columns, data })
 ```
 
 This is the #1 v9-specific failure mode — features must be declared to surface their APIs.

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

@@ -2,12 +2,12 @@
 name: vue/migrate-v8-to-v9
 description: >
   Mechanical breaking-change migration from `@tanstack/vue-table` v8 to v9. Rename `useVueTable`
-  → `useTable`, move `getCoreRowModel`/`getSortedRowModel`/etc. options into `rowModels`
-  factories, add the mandatory `features` via `tableFeatures({...})`, update
-  `createColumnHelper<TData>()` → `createColumnHelper<typeof features, TData>()`, rename
+  → `useTable`, move `getCoreRowModel`/`getSortedRowModel`/etc. options into the `tableFeatures`
+  object as row model factory slots, add the mandatory `features` via `tableFeatures({...})`,
+  update `createColumnHelper<TData>()` → `createColumnHelper<typeof features, TData>()`, rename
   `sortingFn`/`sortingFns` → `sortFn`/`sortFns`, swap `table.getState()` for `table.state`
-  / `table.state` / `table.atoms.<slice>.get()`, and prefer `<FlexRender :cell="cell" />` over the
-  legacy `:render`/`:props` shape. Vue has NO `/legacy` entrypoint — migration is a direct
+  / `table.state` / `table.atoms.<slice>.get()`, and prefer `<FlexRender :cell="cell" />` over
+  the legacy `:render`/`:props` shape. Vue has NO `/legacy` entrypoint — migration is a direct
   rewrite. The Vue adapter installs `vueReactivity()` automatically.
 type: lifecycle
 library: tanstack-table
@@ -89,7 +89,13 @@ import {
   useTable,
 } from '@tanstack/vue-table'
 
-const features = tableFeatures({ rowSortingFeature, rowPaginationFeature })
+const features = tableFeatures({
+  rowSortingFeature,
+  rowPaginationFeature,
+  sortedRowModel: createSortedRowModel(),
+  paginatedRowModel: createPaginatedRowModel(),
+  sortFns,
+})
 const columnHelper = createColumnHelper<typeof features, Person>()
 const columns = columnHelper.columns([
   columnHelper.accessor('age', { header: 'Age', sortFn: 'alphanumeric' }), // sortingFn → sortFn
@@ -97,10 +103,6 @@ const columns = columnHelper.columns([
 
 const table = useTable({
   features,
-  rowModels: {
-    sortedRowModel: createSortedRowModel(sortFns),
-    paginatedRowModel: createPaginatedRowModel(),
-  },
   columns,
   data,
 })
@@ -118,10 +120,10 @@ const table = useTable({
 | ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
 | `useVueTable(opts)`                                                                       | `useTable(opts, selector?)`                                                           |
 | `getCoreRowModel: getCoreRowModel()`                                                      | implicit; not an option                                                               |
-| `getSortedRowModel: getSortedRowModel()`                                                  | `rowModels: { sortedRowModel: createSortedRowModel(sortFns) }`                        |
-| `getFilteredRowModel: getFilteredRowModel()`                                              | `rowModels: { filteredRowModel: createFilteredRowModel(filterFns) }`                  |
-| `getPaginationRowModel: getPaginationRowModel()`                                          | `rowModels: { paginatedRowModel: createPaginatedRowModel() }`                         |
-| `getGroupedRowModel: getGroupedRowModel()`                                                | `rowModels: { groupedRowModel: createGroupedRowModel(aggregationFns) }`               |
+| `getSortedRowModel: getSortedRowModel()`                                                  | `tableFeatures({ sortedRowModel: createSortedRowModel(), sortFns })`                  |
+| `getFilteredRowModel: getFilteredRowModel()`                                              | `tableFeatures({ filteredRowModel: createFilteredRowModel(), filterFns })`            |
+| `getPaginationRowModel: getPaginationRowModel()`                                          | `tableFeatures({ paginatedRowModel: createPaginatedRowModel() })`                     |
+| `getGroupedRowModel: getGroupedRowModel()`                                                | `tableFeatures({ groupedRowModel: createGroupedRowModel(), aggregationFns })`         |
 | `createColumnHelper<TData>()`                                                             | `createColumnHelper<typeof features, TData>()`                                        |
 | `ColumnDef<TData, TValue>`                                                                | `ColumnDef<TFeatures, TData, TValue>`                                                 |
 | `Column<TData, TValue>` / `Row<TData>` / `Cell<TData, TValue>`                            | `…<TFeatures, TData, TValue>`                                                         |
@@ -143,19 +145,28 @@ non-Vue-specific renames are shared across adapters).
 
 ## Core Patterns
 
-### 1. Convert `getXRowModel` options to `rowModels` factories
+### 1. Convert `getXRowModel` options to features-slot factories
 
-Every row-model factory now requires its `*Fns` parameter — this is what makes the registries
-tree-shakeable in v9.
+Row model factories now live on the `tableFeatures({...})` object alongside the feature
+they belong to. The `*Fns` registries move there too — this is what makes them tree-shakeable
+in v9.
 
 ```ts
-rowModels: {
-  sortedRowModel:    createSortedRowModel(sortFns),
-  filteredRowModel:  createFilteredRowModel(filterFns),
+const features = tableFeatures({
+  rowSortingFeature,
+  columnFilteringFeature,
+  rowPaginationFeature,
+  rowGroupingFeature,
+  rowExpandingFeature,
+  sortedRowModel: createSortedRowModel(),
+  filteredRowModel: createFilteredRowModel(),
   paginatedRowModel: createPaginatedRowModel(),
-  groupedRowModel:   createGroupedRowModel(aggregationFns),
-  expandedRowModel:  createExpandedRowModel(),
-}
+  groupedRowModel: createGroupedRowModel(),
+  expandedRowModel: createExpandedRowModel(),
+  sortFns,
+  filterFns,
+  aggregationFns,
+})
 ```
 
 The `*Fns` registries are open-ended; do not cite a number of built-in fns.
@@ -214,7 +225,6 @@ const sorting = ref<SortingState>([])
 
 const table = useTable({
   features,
-  rowModels: { sortedRowModel: createSortedRowModel(sortFns) },
   columns,
   data,
   state: {
@@ -276,14 +286,15 @@ const table = useTable({
   getCoreRowModel: getCoreRowModel(),
 })
 
-// ✅ Core row model is implicit. `rowModels: {}` is fine.
-const table = useTable({ features, rowModels: {}, columns, data })
+// ✅ Core row model is implicit. No `rowModels` option needed.
+const table = useTable({ features, columns, data })
 ```
 
 ### Forgetting `features` (CRITICAL)
 
 `features` is required even for a no-features migration. Pass `tableFeatures({})` for empty,
-or list everything you use. Without it: `'features' is missing in type`.
+or list everything you use (features + row model factories + fn registries). Without it:
+`'features' is missing in type`.
 
 ### Wrong `createColumnHelper` generic arity (CRITICAL)
 
@@ -298,14 +309,21 @@ const columnHelper = createColumnHelper<typeof features, Person>()
 Same applies to type annotations: `ColumnDef<typeof features, Person>`,
 `Row<typeof features, Person>`, `Cell<typeof features, Person, unknown>`.
 
-### Forgetting to pass `sortFns` / `filterFns` to row-model factories (CRITICAL)
+### Forgetting to register `sortFns` / `filterFns` in the features object (CRITICAL)
 
 ```ts
 // ❌ Runtime: no sort fns registered, sort is a no-op.
-sortedRowModel: createSortedRowModel()
+const features = tableFeatures({
+  rowSortingFeature,
+  sortedRowModel: createSortedRowModel(),
+})
 
-// ✅
-sortedRowModel: createSortedRowModel(sortFns)
+// ✅ Register the fn map as a slot on the features object.
+const features = tableFeatures({
+  rowSortingFeature,
+  sortedRowModel: createSortedRowModel(),
+  sortFns,
+})
 ```
 
 ### Missed `sortingFn` → `sortFn` rename (HIGH)
@@ -371,5 +389,5 @@ etc.
 - `tanstack-table/vue/getting-started` — the v9 minimum-viable shape
 - `tanstack-table/vue/table-state` — reactivity model + reading state
 - `tanstack-table/vue/production-readiness` — finish the migration with bundle + identity audits
-- `tanstack-table/table-core/setup` — `features` / `rowModels` deep dive
+- `tanstack-table/table-core/setup` — `features` / row model factory slots deep dive
 - `tanstack-table/table-core/column-definitions` — column helper + generics

package/skills/vue/production-readiness/SKILL.md

@@ -3,13 +3,14 @@ name: vue/production-readiness
 description: >
   Ship-ready optimizations for `@tanstack/vue-table` v9. Tree-shake by listing ONLY the
   `features` you actually render — never default to `stockFeatures`. Keep `features`,
-  `rowModels`, `columnHelper`, and `columns` at module scope for stable identity (Vue
-  re-evaluates the `<script setup>` block per component instance — declare these outside or in
-  a const). Use the `useTable(opts, selector)` second argument or per-slice `computed(() =>
-  table.atoms.<slice>.get())` / `useSelector(table.atoms.<slice>)` from `@tanstack/vue-store`
-  to narrow re-renders. Vue's reactivity already evaluates only dirty computed deps, so
-  `table.Subscribe` is NOT the React-Compiler workaround it is in React — reach for
-  fine-grained reads (`computed`, `useSelector`) first.
+  `columnHelper`, and `columns` at module scope for stable identity (Vue re-evaluates the
+  `<script setup>` block per component instance — declare these outside or in a const). Row
+  model factories and fn registries live as slots on the `tableFeatures({...})` object, not as
+  a separate `rowModels` option. Use the `useTable(opts, selector)` second argument or per-slice
+  `computed(() => table.atoms.<slice>.get())` / `useSelector(table.atoms.<slice>)` from
+  `@tanstack/vue-store` to narrow re-renders. Vue's reactivity already evaluates only dirty
+  computed deps, so `table.Subscribe` is NOT the React-Compiler workaround it is in React;
+  reach for fine-grained reads (`computed`, `useSelector`) first.
 type: lifecycle
 library: tanstack-table
 framework: vue
@@ -52,26 +53,24 @@ import {
 export const features = tableFeatures({
   rowSortingFeature,
   rowPaginationFeature,
-})
-
-export const rowModels = {
-  sortedRowModel: createSortedRowModel(sortFns),
+  sortedRowModel: createSortedRowModel(),
   paginatedRowModel: createPaginatedRowModel(),
-}
+  sortFns,
+})
 ```
 
 ```vue
 <script setup lang="ts">
 import { ref } from 'vue'
 import { useTable } from '@tanstack/vue-table'
-import { features, rowModels } from './table-setup'
+import { features } from './table-setup'
 import { columns } from './columns'
 
 const props = defineProps<{ data: Person[] }>()
 const data = ref(props.data)
 
 // Narrow selector — table.state only carries what we actually render at this level.
-const table = useTable({ features, rowModels, columns, data }, (state) => ({
+const table = useTable({ features, columns, data }, (state) => ({
   pagination: state.pagination,
   sorting: state.sorting,
 }))
@@ -95,12 +94,16 @@ const features = tableFeatures({ rowSortingFeature })
 isn't wired into a column def or UI handler, drop it. v9 is tree-shakeable specifically so you
 only pay for what you use.
 
-### 2. Module-scope `features` / `rowModels` / `columnHelper` / `columns`
+### 2. Module-scope `features` / `columnHelper` / `columns`
 
 ```ts
 // ❌ Inside <script setup> — every component instance creates new identities, which churns
 //    the table's option-watcher and triggers a `setOptions` on every reactive tick.
-const features = tableFeatures({ rowSortingFeature })
+const features = tableFeatures({
+  rowSortingFeature,
+  sortedRowModel: createSortedRowModel(),
+  sortFns,
+})
 const columnHelper = createColumnHelper<typeof features, Person>()
 const columns = columnHelper.columns([
   /* ... */
@@ -109,7 +112,11 @@ const columns = columnHelper.columns([
 
 ```ts
 // ✅ Module scope — one identity, shared across instances, GC-friendly.
-const features = tableFeatures({ rowSortingFeature })
+const features = tableFeatures({
+  rowSortingFeature,
+  sortedRowModel: createSortedRowModel(),
+  sortFns,
+})
 const columnHelper = createColumnHelper<typeof features, Person>()
 export const columns = columnHelper.columns([
   /* ... */
@@ -124,11 +131,11 @@ write `data: ref([...])` inline in the table options (a fresh ref each render).
 ```ts
 // ❌ Default selector — table.state contains every registered slice; any state change re-renders
 //    every consumer of table.state.
-const table = useTable({ features, rowModels, columns, data })
+const table = useTable({ features, columns, data })
 
 // ✅ Project only what THIS component renders. Other slices still drive table internals; you
 //    just don't subscribe to them at the component level.
-const table = useTable({ features, rowModels, columns, data }, (state) => ({
+const table = useTable({ features, columns, data }, (state) => ({
   pagination: state.pagination,
   sorting: state.sorting,
 }))
@@ -191,7 +198,7 @@ Use `table.Subscribe` only for cross-store source subscription (`<table.Subscrib
 Defeats the entire reason v9 is tree-shakeable. Replace with an explicit
 `tableFeatures({...})` listing only the features your UI renders.
 
-### Re-declaring `features` / `rowModels` / `columns` inside `<script setup>` (HIGH)
+### Re-declaring `features` / `columns` inside `<script setup>` (HIGH)
 
 Vue runs `<script setup>` once per component instance, but that's still per-page-navigation in
 SPAs and per-instance in any reusable component. Module scope is cheapest and shared.
@@ -217,7 +224,7 @@ watchEffect(() => {
 
 ```ts
 // ❌ Whole table re-evaluates table.state on every keystroke in a column filter.
-const table = useTable({ features, rowModels, columns, data })
+const table = useTable({ features, columns, data })
 
 // ✅
 const table = useTable(opts, (s) => ({ pagination: s.pagination }))