@tanstack/angular-table 9.0.0-beta.2 → 9.0.0-beta.20

package/dist/types/tanstack-angular-table.d.ts

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { Type, ComponentMirror, OutputEmitterRef, InputSignal, Injector, createComponent, Binding, TemplateRef, InjectionToken, Signal } from '@angular/core';
-import { TableFeatures, RowData, CellData, Cell, Header, CellContext, HeaderContext, Table, TableState, TableOptions, Column, Row, IdentifiedColumnDef, AccessorFn, DeepKeys, DeepValue, AccessorFnColumnDef, AccessorKeyColumnDef, ColumnDef, DisplayColumnDef, GroupColumnDef } from '@tanstack/table-core';
+import { TableFeatures, RowData, CellData, Cell, Header, CellContext, HeaderContext, Table, TableOptions, Column, Row, IdentifiedColumnDef, AccessorFn, DeepKeys, DeepValue, AccessorFnColumnDef, AccessorKeyColumnDef, ColumnDef, DisplayColumnDef, GroupColumnDef } from '@tanstack/table-core';
 export * from '@tanstack/table-core';
 import { Atom, ReadonlyAtom, Store, ReadonlyStore } from '@tanstack/angular-store';
 export { shallow } from '@tanstack/angular-store';
@@ -365,16 +365,11 @@ type SubscribeSource<TValue> = Atom<TValue> | ReadonlyAtom<TValue> | Store<TValu
 type AngularTable<TFeatures extends TableFeatures, TData extends RowData> = Table<TFeatures, TData> & {
     /**
      * @deprecated Prefer `table.atoms.<slice>.get()` for template/render reads
-     * of a specific state slice, `table.state` for full-state debug snapshots, or
-     * Angular computed values around explicit selectors. `table.store.state` is a
-     * current-value snapshot and is easy to misuse in render code.
+     * of a specific state slice, or Angular computed values around explicit
+     * selectors. `table.store.state` is a current-value snapshot and is easy to
+     * misuse in render code.
      */
     readonly store: Table<TFeatures, TData>['store'];
-    /**
-     * The current table state exposed as a flat proxy. Prefer
-     * `table.atoms.<slice>.get()` when reading a specific slice.
-     */
-    readonly state: Readonly<TableState<TFeatures>>;
 };
 /**
  * Creates and returns an Angular-reactive table instance.
@@ -449,7 +444,7 @@ interface TanStackTableCellContext<TFeatures extends TableFeatures, TData extend
  *
  * This token is provided by the {@link TanStackTableCell} directive.
  */
-declare const TanStackTableCellToken: InjectionToken<Signal<any>>;
+declare const TanStackTableCellToken: InjectionToken<Signal<Cell<TableFeatures, RowData, unknown>>>;
 /**
  * Provides a TanStack Table `Cell` instance in Angular DI.
  *
@@ -521,7 +516,7 @@ interface TanStackTableHeaderContext<TFeatures extends TableFeatures, TData exte
  *
  * This token is provided by the {@link TanStackTableHeader} directive.
  */
-declare const TanStackTableHeaderToken: InjectionToken<Signal<any>>;
+declare const TanStackTableHeaderToken: InjectionToken<Signal<Header<TableFeatures, RowData, unknown>>>;
 /**
  * Provides a TanStack Table `Header` instance in Angular DI.
  *
@@ -578,7 +573,7 @@ declare function injectTableHeaderContext<TFeatures extends TableFeatures, TData
  *
  * This token is provided by the {@link TanStackTable} directive.
  */
-declare const TanStackTableToken: InjectionToken<Signal<any>>;
+declare const TanStackTableToken: InjectionToken<Signal<AngularTable<TableFeatures, RowData>>>;
 /**
  * Provides a TanStack Table instance (`AngularTable`) in Angular DI.
  *
@@ -756,7 +751,7 @@ type CreateTableHookResult<TFeatures extends TableFeatures, TTableComponents ext
     injectTableCellContext: <TValue extends CellData = CellData, TRowData extends RowData = RowData>() => Signal<Cell<TFeatures, TRowData, TValue>>;
     injectFlexRenderHeaderContext: <TData extends RowData, TValue extends CellData>() => HeaderContext<TFeatures, TData, TValue>;
     injectFlexRenderCellContext: <TData extends RowData, TValue extends CellData>() => CellContext<TFeatures, TData, TValue>;
-    injectAppTable: <TData extends RowData>(tableOptions: () => Omit<TableOptions<TFeatures, TData>, 'features' | 'rowModels'>) => AppAngularTable<TFeatures, TData, TTableComponents, TCellComponents, THeaderComponents>;
+    injectAppTable: <TData extends RowData>(tableOptions: () => Omit<TableOptions<TFeatures, TData>, 'features'>) => AppAngularTable<TFeatures, TData, TTableComponents, TCellComponents, THeaderComponents>;
 };
 /**
  * Creates app-scoped Angular table helpers with features, row models, and
@@ -770,7 +765,6 @@ type CreateTableHookResult<TFeatures extends TableFeatures, TTableComponents ext
  * ```ts
  * const { injectAppTable, createAppColumnHelper } = createTableHook({
  *   features,
- *   rowModels: {},
  *   tableComponents: {},
  *   cellComponents: {},
  *   headerComponents: {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/angular-table",
-  "version": "9.0.0-beta.2",
+  "version": "9.0.0-beta.20",
   "description": "Headless UI for building powerful tables & datagrids for Angular.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -52,14 +52,15 @@
   ],
   "dependencies": {
     "@tanstack/angular-store": "^0.11.0",
-    "@tanstack/table-core": "9.0.0-beta.1",
-    "tslib": "^2.8.1"
+    "tslib": "^2.8.1",
+    "@tanstack/table-core": "9.0.0-beta.20"
   },
   "devDependencies": {
-    "@analogjs/vite-plugin-angular": "^2.6.0",
-    "@analogjs/vitest-angular": "^2.6.0",
-    "@angular/core": "^22.0.0",
-    "@angular/platform-browser": "^22.0.0",
+    "@analogjs/vite-plugin-angular": "^2.6.1",
+    "@analogjs/vitest-angular": "^2.6.1",
+    "@angular/compiler": "^22.0.2",
+    "@angular/core": "^22.0.2",
+    "@angular/platform-browser": "^22.0.2",
     "ng-packagr": "^22.0.0",
     "typescript": "6.0.3"
   },

package/skills/angular/angular-rendering-directives/SKILL.md

@@ -297,10 +297,10 @@ column defs short and typed.
 
 ```ts
 export const { injectAppTable, createAppColumnHelper } = createTableHook({
-  features: tableFeatures({ rowSortingFeature }),
-  rowModels: {
-    /* … */
-  },
+  features: tableFeatures({
+    rowSortingFeature,
+    /* row-model factories and fn registries also go here */
+  }),
   tableComponents: { PaginationControls, RowCount },
   cellComponents: { TextCell, NumberCell, StatusCell },
   headerComponents: { SortIndicator, ColumnFilter },

package/skills/angular/angular-rendering-directives/references/create-table-hook-registries.md

@@ -26,10 +26,10 @@ export const {
   injectTableCellContext,
   injectTableHeaderContext,
 } = createTableHook({
-  features: tableFeatures({ rowSortingFeature }),
-  rowModels: {
-    /* … */
-  },
+  features: tableFeatures({
+    rowSortingFeature,
+    /* row-model factories and fn registries also go here */
+  }),
   tableComponents: { PaginationControls, RowCount },
   cellComponents: { TextCell, NumberCell, StatusCell },
   headerComponents: { SortIndicator, ColumnFilter },

package/skills/angular/client-to-server/SKILL.md

@@ -3,12 +3,13 @@ name: angular/client-to-server
 description: >
   Convert an Angular Table v9 from client-side to server-side processing. Flip
   `manualPagination` / `manualSorting` / `manualFiltering` / `manualGrouping` / `manualExpanding`
-  for the slices the server now owns; drop the corresponding `rowModels` row-model factories the
-  server replaces; supply `rowCount` (server total) so pagination computes correctly; hoist
-  `pagination` / `sorting` / `columnFilters` / `globalFilter` to Angular signals with `state` +
-  `on[State]Change`; fetch via `rxResource` / `httpResource` / `@tanstack/angular-query`; preserve
-  previous data on refetch with `linkedSignal` (or `placeholderData: keepPreviousData` for Query);
-  set `getRowId` for stable selection across refetches.
+  for the slices the server now owns; drop the corresponding row-model factory slots from the
+  `features` object for the factories the server replaces; supply `rowCount` (server total) so
+  pagination computes correctly; hoist `pagination` / `sorting` / `columnFilters` / `globalFilter`
+  to Angular signals with `state` + `on[State]Change`; fetch via `rxResource` / `httpResource` /
+  `@tanstack/angular-query`; preserve previous data on refetch with `linkedSignal` (or
+  `placeholderData: keepPreviousData` for Query); set `getRowId` for stable selection across
+  refetches.
 type: lifecycle
 library: tanstack-table
 framework: angular
@@ -44,7 +45,7 @@ For each slice the server now owns:
 
 1. **Flip `manualX: true`** in table options. This tells the table "don't
    process this on the client — trust the data you receive."
-2. **Drop the matching client-side row-model factory** from `rowModels`
+2. **Drop the matching client-side row-model factory slot** from `features`
    (or keep it if you still want the feature's _state_ but no client
    recomputation — see §3).
 3. **Hoist the slice to an Angular signal**, control it via `state.x` +
@@ -97,6 +98,7 @@ import {
   tableFeatures,
   rowPaginationFeature,
   rowSortingFeature,
+  columnFilteringFeature,
   globalFilteringFeature,
   createColumnHelper,
   type ColumnDef,
@@ -107,6 +109,7 @@ import {
 const features = tableFeatures({
   rowPaginationFeature,
   rowSortingFeature,
+  columnFilteringFeature,
   globalFilteringFeature,
 })
 
@@ -198,12 +201,11 @@ export class App {
     }),
   ]
 
-  // 4. Wire the table — manualX flags, drop row-model factories, supply rowCount
+  // 4. Wire the table — manualX flags, features without row-model factories, supply rowCount
   readonly table = injectTable(() => {
     const data = this.dataWithLatest()
     return {
-      features,
-      rowModels: {}, // ← dropped paginatedRowModel, sortedRowModel, filteredRowModel
+      features, // ← features has no paginatedRowModel/sortedRowModel/filteredRowModel slots
       columns: this.columns,
       data: data.items,
       getRowId: (row) => String(row.id),
@@ -245,8 +247,8 @@ export class App {
 
 ### What changed from the client-side version
 
-- `rowModels: {}` — no `paginatedRowModel`, no `sortedRowModel`, no
-  `filteredRowModel`. The server is the source of truth.
+- `features` has no `paginatedRowModel`, `sortedRowModel`, or `filteredRowModel`
+  slots — the server is the source of truth for those.
 - `manualPagination` / `manualSorting` / `manualFiltering: true`.
 - `rowCount: data.totalCount` — required for correct `getPageCount()` and the
   next/prev buttons.
@@ -359,13 +361,12 @@ edits (toggle the flag around the update).
 
 ## Failure modes
 
-### 1. (CRITICAL) Flipping `manualPagination: true` but keeping
-
-`paginatedRowModel` in `rowModels`
+### 1. (CRITICAL) Flipping `manualPagination: true` but keeping `paginatedRowModel` on `features`
 
 The client row-model factory will re-paginate the (already-paginated) data,
 chopping the visible rows down to the first `pageSize` of the page slice.
-**Drop the factory** when going manual — or accept double-pagination.
+**Remove the `paginatedRowModel` slot from `features`** when going manual — or
+accept double-pagination.
 
 ### 2. (CRITICAL) Forgetting `rowCount` under `manualPagination`
 
@@ -409,12 +410,12 @@ the fetch itself).
 
 ```ts
 manualPagination: true,
-// columnFilteringFeature still registered, filteredRowModel still attached
+// columnFilteringFeature still registered, filteredRowModel slot still on features
 ```
 
 The filtered row model now filters only the _current page_ — useless. If the
 server paginates, the server must also filter; flip `manualFiltering: true`
-and drop the client `filteredRowModel`.
+and remove the `filteredRowModel` slot from `features`.
 
 ### 8. (HIGH) Forgetting to depend on the controlled signals in your fetch
 
@@ -448,11 +449,11 @@ the new filtered result set only has 2 pages. They have to manually click back
 to page 1. Always reset `pageIndex` to 0 in `onGlobalFilterChange` /
 `onColumnFiltersChange`.
 
-### 11. (MEDIUM) Treating `rowModels: {}` as "no row models work"
+### 11. (MEDIUM) Thinking that omitting all row-model slots means "no row models work"
 
 Core row model is always automatic. `table.getRowModel().rows` returns the
-data array as `Row<...>` objects no matter what — `rowModels: {}` just means
-no client-side processing on top.
+data array as `Row<...>` objects no matter what — a `features` object with no
+factory slots just means no client-side processing on top.
 
 ---
 

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

@@ -5,10 +5,10 @@ description: >
   Key the query on the controlled table state that drives the request (pagination, sorting,
   filters); use `placeholderData: keepPreviousData` to avoid a "0 rows flash" between pages;
   set `manualPagination` / `manualSorting` / `manualFiltering` for the slices the server owns;
-  drop the matching client `rowModels` factories; pass `rowCount` from the server response;
-  set `getRowId` for stable selection across refetches; hoist controlled slices to Angular
-  signals + `state` + `on[State]Change`. Alternative — `rxResource` / `httpResource` if you
-  don't want to add the Query dependency (see `client-to-server`).
+  drop the matching client row-model factory slots from `features`; pass `rowCount` from the
+  server response; set `getRowId` for stable selection across refetches; hoist controlled slices
+  to Angular signals + `state` + `on[State]Change`. Alternative: `rxResource` / `httpResource`
+  if you don't want to add the Query dependency (see `client-to-server`).
 type: composition
 library: tanstack-table
 framework: angular
@@ -82,6 +82,7 @@ import {
   tableFeatures,
   rowPaginationFeature,
   rowSortingFeature,
+  columnFilteringFeature,
   globalFilteringFeature,
   createColumnHelper,
   type ColumnDef,
@@ -92,6 +93,7 @@ import {
 const features = tableFeatures({
   rowPaginationFeature,
   rowSortingFeature,
+  columnFilteringFeature,
   globalFilteringFeature,
 })
 
@@ -165,12 +167,11 @@ export class App {
     }),
   ]
 
-  // 4. Wire the table — manual flags, no client row models, rowCount, getRowId
+  // 4. Wire the table — manual flags, features without row-model factories, rowCount, getRowId
   readonly table = injectTable(() => {
     const data = this.todosQuery.data() ?? { items: [], totalCount: 0 }
     return {
-      features,
-      rowModels: {}, // ← dropped paginatedRowModel / sortedRowModel / filteredRowModel
+      features, // ← features has no paginatedRowModel/sortedRowModel/filteredRowModel slots
       columns: this.columns,
       data: data.items,
       getRowId: (row) => String(row.id),
@@ -219,8 +220,8 @@ For server-driven Table + Query to work correctly:
    during refetches. Without it, `todosQuery.data()` becomes `undefined`
    mid-fetch, your table shows 0 rows for a frame, the user notices.
 3. **`manualPagination` / `manualSorting` / `manualFiltering: true`** for
-   slices the server owns + **drop the matching `rowModels` factories** so
-   the table doesn't re-process the data the server already filtered/sorted/paged.
+   slices the server owns + **remove the matching factory slots from `features`**
+   so the table doesn't re-process the data the server already filtered/sorted/paged.
 4. **`rowCount: data.totalCount`** (or `pageCount`) so `getPageCount()`
    computes correctly under `manualPagination`.
 
@@ -407,15 +408,18 @@ visible until the new one resolves.
 `getPageCount()` returns `-1`, "next" never disables. The server tells you
 how many rows exist — pass it.
 
-### 4. (CRITICAL) Keeping client row models for slices the server owns
+### 4. (CRITICAL) Keeping client row-model factory slots for slices the server owns
 
 ```ts
 // ❌ Double-processes the data
 manualPagination: true,
-rowModels: { paginatedRowModel: createPaginatedRowModel() }, // re-paginates server page
+// features still has paginatedRowModel slot → re-paginates server page
 
-// ✅
-rowModels: {} // (or just keep the ones still client-side)
+// ✅ remove the factory slot from features for server-owned slices
+const features = tableFeatures({
+  rowPaginationFeature,
+  // paginatedRowModel intentionally omitted — server handles it
+})
 ```
 
 Same applies to `sortedRowModel` under `manualSorting` and `filteredRowModel`

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

@@ -99,7 +99,6 @@ export const sortingStore = new Store<SortingState>([])
 export class App {
   readonly table = injectTable(() => ({
     features,
-    rowModels: { /* … */ },
     columns,
     data: this.data(),
     atoms: {
@@ -188,9 +187,6 @@ export class PageRoute {
 
   readonly table = injectTable(() => ({
     features,
-    rowModels: {
-      /* … */
-    },
     columns,
     data: this.data(),
     atoms: {
@@ -236,10 +232,23 @@ import { Store } from '@tanstack/store'
 
 export const sharedFilter = new Store<string | null>(null)
 
+const featuresA = tableFeatures({
+  columnFilteringFeature,
+  globalFilteringFeature,
+  filteredRowModel: createFilteredRowModel(),
+  filterFns,
+})
+
+const featuresB = tableFeatures({
+  columnFilteringFeature,
+  globalFilteringFeature,
+  filteredRowModel: createFilteredRowModel(),
+  filterFns,
+})
+
 // Table A
 readonly tableA = injectTable(() => ({
-  features: tableFeatures({ globalFilteringFeature }),
-  rowModels: { filteredRowModel: createFilteredRowModel(filterFns) },
+  features: featuresA,
   columns: columnsA,
   data: this.dataA(),
   atoms: { globalFilter: sharedFilter },
@@ -247,8 +256,7 @@ readonly tableA = injectTable(() => ({
 
 // Table B (separate component, same module)
 readonly tableB = injectTable(() => ({
-  features: tableFeatures({ globalFilteringFeature }),
-  rowModels: { filteredRowModel: createFilteredRowModel(filterFns) },
+  features: featuresB,
   columns: columnsB,
   data: this.dataB(),
   atoms: { globalFilter: sharedFilter },

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

@@ -82,7 +82,6 @@ export class VirtualTable {
 
   readonly table = injectTable(() => ({
     features,
-    rowModels: {},
     columns,
     data: this.data(),
     getRowId: (row) => row.id,
@@ -217,7 +216,7 @@ caches that, scrollbar adjusts.)
 Combine with `rowExpandingFeature` for "click to expand details":
 
 - Register `rowExpandingFeature` in `features` and
-  `expandedRowModel: createExpandedRowModel()` in `rowModels`.
+  `expandedRowModel: createExpandedRowModel()` as a slot on `features`.
 - Use `table.getExpandedRowModel().rows` (or `getRowModel().rows`, which
   already includes expansion under `paginateExpandedRows: true` semantics —
   see `tanstack-table/core/row-expanding`).

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

@@ -2,12 +2,11 @@
 name: angular/getting-started
 description: >
   End-to-end first-table journey for TanStack Table v9 in Angular: install
-  `@tanstack/angular-table`, declare `features` with `tableFeatures()`, register row-model
-  factories under `rowModels` with explicit `*Fns` parameters, build columns with the
-  `TFeatures, TData` generic order, call `injectTable(() => ({...}))` from an injection context,
-  and render with `FlexRender` / `*flexRenderHeader` / `*flexRenderCell` / `*flexRenderFooter`.
-  Covers the minimum-viable signal-backed table plus the upgrade path to sorting + filtering +
-  pagination.
+  `@tanstack/angular-table`, declare `features` with `tableFeatures()` (row-model factories and
+  fn registries live on the features object), build columns with the `TFeatures, TData` generic
+  order, call `injectTable(() => ({...}))` from an injection context, and render with `FlexRender` /
+  `*flexRenderHeader` / `*flexRenderCell` / `*flexRenderFooter`. Covers the minimum-viable
+  signal-backed table plus the upgrade path to sorting + filtering + pagination.
 type: lifecycle
 library: tanstack-table
 framework: angular
@@ -31,9 +30,9 @@ sources:
 > Goal: from zero to a working signal-backed, sorted + paginated, type-safe
 > table in Angular ≥19.
 >
-> v9 is **explicit**: tell the table which features you want with `features`,
-> tell it which row models you want with `rowModels`. That explicitness is what
-> makes the v9 bundle tree-shakeable.
+> v9 is **explicit**: tell the table which features you want with `features`.
+> Row-model factories and fn registries live on the features object alongside
+> the feature flags. That explicitness is what makes the v9 bundle tree-shakeable.
 
 ---
 
@@ -104,8 +103,7 @@ export class App {
 
   // 3. injectTable in an injection context (a class field qualifies)
   readonly table = injectTable(() => ({
-    features, // required in v9
-    rowModels: {}, // {} = core only; that's fine
+    features, // required in v9; core row model is automatic
     columns, // stable ref
     data: this.data(), // signal read → re-syncs the table on change
   }))
@@ -156,11 +154,9 @@ driven by the row model.
   (`getRowModel()`) is always available. With `features: tableFeatures({})`,
   `table.atoms.*` only contains the slices core ships with — no `pagination`,
   no `sorting`, no `rowSelection` until you add the matching features.
-- `rowModels: {}` does not register any feature-specific row models. Core
-  row model is included automatically.
 - `injectTable(() => ({...}))` runs the initializer, builds the table, and
   re-runs the initializer whenever any signal read inside changes. Stable
-  references outside the initializer keep `columns` / `features` / `rowModels`
+  references outside the initializer keep `columns` / `features`
   from getting recreated on every data update.
 
 ---
@@ -171,7 +167,7 @@ Each opt-in feature has two pieces in v9:
 
 1. The **feature** itself (`rowSortingFeature`) in `features` — adds APIs
    like `column.toggleSorting()` and the `sorting` state slice.
-2. The **row-model factory** (`createSortedRowModel(sortFns)`) in `rowModels`
+2. The **row-model factory** (`createSortedRowModel()`) on the features object
    — produces the sorted output. Without it, `table.getRowModel().rows` is
    unsorted regardless of sort state.
 
@@ -187,13 +183,12 @@ import {
 
 const features = tableFeatures({
   rowSortingFeature,
+  sortedRowModel: createSortedRowModel(), // <-- enables sorting output
+  sortFns,
 })
 
 readonly table = injectTable(() => ({
   features,
-  rowModels: {
-    sortedRowModel: createSortedRowModel(sortFns), // <-- enables sorting output
-  },
   columns,
   data: this.data(),
 }))
@@ -220,7 +215,7 @@ In the template, drive sorting from the header:
 
 `sortFns` is the registry of built-in sort functions
 (`alphanumeric`, `basic`, `datetime`, etc.). Pass only the ones you use to
-tree-shake (`createSortedRowModel({ basic: sortFns.basic })`), or pass `sortFns`
+tree-shake (`sortFns: { basic: sortFns.basic }`), or pass `sortFns`
 in its entirety for all of them.
 
 ---
@@ -246,15 +241,15 @@ const features = tableFeatures({
   rowSortingFeature,
   columnFilteringFeature,
   rowPaginationFeature,
+  sortedRowModel: createSortedRowModel(),
+  filteredRowModel: createFilteredRowModel(),
+  paginatedRowModel: createPaginatedRowModel(),
+  sortFns,
+  filterFns,
 })
 
 readonly table = injectTable(() => ({
   features,
-  rowModels: {
-    sortedRowModel: createSortedRowModel(sortFns),
-    filteredRowModel: createFilteredRowModel(filterFns),
-    paginatedRowModel: createPaginatedRowModel(),
-  },
   columns,
   data: this.data(),
   initialState: {
@@ -323,8 +318,8 @@ const columns = columnHelper.columns([
 > v9 changed the generic order: `createColumnHelper<typeof features, Person>()`,
 > **not** `createColumnHelper<Person>()`. Same for `ColumnDef<typeof features, Person>`.
 
-If multiple components share the same `features` / `rowModels`, factor them
-into a `createTableHook(...)` call — see
+If multiple components share the same `features` object, factor them into a
+`createTableHook(...)` call — see
 `tanstack-table/angular/angular-rendering-directives` §10 and the
 `composable-tables` example.
 
@@ -338,7 +333,6 @@ row pinning, and refetch-based updates correct.
 ```ts
 readonly table = injectTable(() => ({
   features,
-  rowModels: { /* … */ },
   columns,
   data: this.data(),
   getRowId: (row) => row.id, // ← stable ID across re-fetches
@@ -360,7 +354,6 @@ and `table.setSorting(...)` to drive updates.
 ```ts
 readonly table = injectTable(() => ({
   features,
-  rowModels: { /* … */ },
   columns,
   data: this.data(),
   initialState: {
@@ -404,8 +397,8 @@ import { injectTable, tableFeatures } from '@tanstack/angular-table'
 
 There is no `getCoreRowModel()` / `getSortedRowModel()` / `getFilteredRowModel()`
 in v9. Core row model is automatic; the rest are
-`createSortedRowModel(sortFns)` / `createFilteredRowModel(filterFns)` / etc.
-registered under `rowModels`.
+`createSortedRowModel()` / `createFilteredRowModel()` / etc.
+registered as slots on the `features` object alongside `sortFns` / `filterFns`.
 
 ### 3. (CRITICAL) Reimplementing what the table API already does
 
@@ -424,37 +417,35 @@ The table already does all of this. Use it.
 ### 4. (HIGH) Feature without its row model (or vice versa)
 
 ```ts
-// ❌ rowSortingFeature without createSortedRowModel → sort state changes, rows don't reorder
-features: tableFeatures({ rowSortingFeature })
-rowModels: {
-}
+// ❌ rowSortingFeature without sortedRowModel → sort state changes, rows don't reorder
+const features = tableFeatures({ rowSortingFeature })
 
-// ✅
-rowModels: {
-  sortedRowModel: createSortedRowModel(sortFns)
-}
+// ✅ factory and fn registry on the features object
+const features = tableFeatures({
+  rowSortingFeature,
+  sortedRowModel: createSortedRowModel(),
+  sortFns,
+})
 ```
 
 Full mapping table → [`references/feature-row-model-mapping.md`](references/feature-row-model-mapping.md).
 
-### 5. (HIGH) Declaring `columns` / `features` / `rowModels` inside the initializer
+### 5. (HIGH) Declaring `columns` / `features` inside the initializer
 
 ```ts
 // ❌ Recreated on every signal change
 readonly table = injectTable(() => ({
-  features: tableFeatures({ rowSortingFeature }),
-  rowModels: { sortedRowModel: createSortedRowModel(sortFns) },
+  features: tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns }),
   columns: [/* … */],
   data: this.data(),
 }))
 
 // ✅ Stable references outside, signal reads inside
-const features = tableFeatures({ rowSortingFeature })
+const features = tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns })
 const columns: Array<ColumnDef<typeof features, Person>> = [/* … */]
 
 readonly table = injectTable(() => ({
   features,
-  rowModels: { sortedRowModel: createSortedRowModel(sortFns) },
   columns,
   data: this.data(),
 }))

package/skills/angular/getting-started/references/feature-row-model-mapping.md

@@ -10,16 +10,19 @@ Every opt-in v9 feature has two pieces:
 
 1. The **feature** itself in `features` — adds APIs (e.g.
    `column.toggleSorting()`) and the matching state slice.
-2. A **row-model factory** in `rowModels` — produces the derived row output.
-   Without it, sort/filter/paginate UI updates but rows don't reorder.
+2. A **row-model factory slot** on the `features` object — produces the derived
+   row output. Without it, sort/filter/paginate UI updates but rows don't reorder.
 
-| Feature                                                                                                                                              | Row model needed                                                                             |
+Fn registries (`sortFns`, `filterFns`, `aggregationFns`) are also slots on the
+`features` object, not parameters to the factory calls.
+
+| Feature                                                                                                                                              | Slot needed on `features`                                                                    |
 | ---------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
-| `rowSortingFeature`                                                                                                                                  | `sortedRowModel: createSortedRowModel(sortFns)`                                              |
-| `columnFilteringFeature` / `globalFilteringFeature`                                                                                                  | `filteredRowModel: createFilteredRowModel(filterFns)`                                        |
+| `rowSortingFeature`                                                                                                                                  | `sortedRowModel: createSortedRowModel()` + `sortFns`                                         |
+| `columnFilteringFeature` / `globalFilteringFeature`                                                                                                  | `filteredRowModel: createFilteredRowModel()` + `filterFns`                                   |
 | `rowPaginationFeature`                                                                                                                               | `paginatedRowModel: createPaginatedRowModel()`                                               |
 | `rowExpandingFeature`                                                                                                                                | `expandedRowModel: createExpandedRowModel()`                                                 |
-| `columnGroupingFeature`                                                                                                                              | `groupedRowModel: createGroupedRowModel(aggregationFns)`                                     |
+| `columnGroupingFeature`                                                                                                                              | `groupedRowModel: createGroupedRowModel()` + `aggregationFns`                                |
 | `columnFacetingFeature`                                                                                                                              | `facetedRowModel: createFacetedRowModel()` (+ `facetedMinMaxValues` / `facetedUniqueValues`) |
 | `rowSelectionFeature`                                                                                                                                | (no row model needed)                                                                        |
 | `columnVisibilityFeature` / `columnOrderingFeature` / `columnPinningFeature` / `columnSizingFeature` / `columnResizingFeature` / `rowPinningFeature` | (no row model needed)                                                                        |