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

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

@@ -2,13 +2,15 @@
 name: angular/migrate-v8-to-v9
 description: >
   Mechanical v8 → v9 migration for `@tanstack/angular-table`: `createAngularTable` →
-  `injectTable`, `get*RowModel()` options → `rowModels` factories with explicit `*Fns`,
-  required `features` via `tableFeatures()`, state access via `table.atoms.<slice>.get()`
-  or `table.state` instead of `table.getState()`, `createColumnHelper<TFeatures, TData>()` generic-order flip, every
-  type now requires `TFeatures`, `enablePinning` split into `enableColumnPinning` /
-  `enableRowPinning`, `sortingFn` → `sortFn` rename pile, `ColumnSizingInfo` → `ColumnResizing`
-  split, removal of `_`-prefixed internals, signal-backed atoms replacing v8 memoized accessors,
-  and structural-directive rendering replacing v8 component-based rendering.
+  `injectTable`, `get*RowModel()` options → row-model factories on the `features` object (no
+  separate `rowModels` option; fn registries like `filterFns`/`sortFns` are also slots on
+  `features`), required `features` via `tableFeatures()`, state access via
+  `table.atoms.<slice>.get()` or `table.state` instead of `table.getState()`,
+  `createColumnHelper<TFeatures, TData>()` generic-order flip, every type now requires `TFeatures`,
+  `enablePinning` split into `enableColumnPinning` / `enableRowPinning`, `sortingFn` → `sortFn`
+  rename pile, `ColumnSizingInfo` → `ColumnResizing` split, removal of `_`-prefixed internals,
+  signal-backed atoms replacing v8 memoized accessors, and structural-directive rendering replacing
+  v8 component-based rendering.
 type: lifecycle
 library: tanstack-table
 framework: angular
@@ -27,9 +29,9 @@ sources:
 # Migrate from TanStack Table v8 to v9 (Angular)
 
 > **Angular does not ship a legacy v8 API in v9** (unlike React's
-> `useLegacyTable`). You migrate directly to v9's `injectTable` + `features` +
-> `rowModels` shape. There is no incremental in-place adapter — the public
-> entrypoint name itself changes.
+> `useLegacyTable`). You migrate directly to v9's `injectTable` + `features`
+> shape (row-model factories and fn registries now live on the `features` object).
+> There is no incremental in-place adapter — the public entrypoint name itself changes.
 
 This skill is a mechanical translation table. Work through it top-to-bottom.
 
@@ -58,7 +60,6 @@ const features = tableFeatures({}) // empty is valid; core row model is automati
 
 const v9Table = injectTable(() => ({
   features,
-  rowModels: {},
   columns,
   data: data(),
 }))
@@ -66,14 +67,16 @@ const v9Table = injectTable(() => ({
 
 Key behavioral change: **the `injectTable` initializer re-runs when signals
 inside it change**, then the adapter calls `table.setOptions({ ...prev, ...new })`.
-Move stable values (`columns`, `features`, `rowModels`) **outside** the
-initializer so they aren't recreated on every data update.
+Move stable values (`columns`, `features`) **outside** the initializer so they
+aren't recreated on every data update.
 
 ---
 
-## 2. Required new options: `features` + `rowModels`
+## 2. Required new option: `features`
 
-v9 is opt-in for every feature. **Both options are required.**
+v9 is opt-in for every feature. `features` is required. Row-model factories and
+fn registries are now **slots on the features object** — there is no separate
+`rowModels` option.
 
 ```ts
 // v8 — features were bundled, row models added piecewise
@@ -106,15 +109,15 @@ const features = tableFeatures({
   columnFilteringFeature,
   rowSortingFeature,
   rowPaginationFeature,
+  filteredRowModel: createFilteredRowModel(), // factory is now a features slot
+  sortedRowModel: createSortedRowModel(),
+  paginatedRowModel: createPaginatedRowModel(),
+  filterFns, // fn registry is also a features slot
+  sortFns, // note rename: sortingFns → sortFns
 })
 
 injectTable(() => ({
   features,
-  rowModels: {
-    filteredRowModel: createFilteredRowModel(filterFns), // fns are PARAMETERS now
-    sortedRowModel: createSortedRowModel(sortFns),
-    paginatedRowModel: createPaginatedRowModel(),
-  },
   columns,
   data: data(),
 }))
@@ -167,7 +170,6 @@ readonly pagination = signal<PaginationState>({ pageIndex: 0, pageSize: 10 })
 
 readonly table = injectTable(() => ({
   features,
-  rowModels: { /* … */ },
   columns,
   data: this.data(),
   state: {
@@ -302,10 +304,10 @@ v8 backed reactivity with manual memoized getters. v9's adapter
 
 - [ ] Replace `createAngularTable` import + call with `injectTable`.
 - [ ] Add `features: tableFeatures({...})` (or `stockFeatures`) — required.
-- [ ] Convert every `get*RowModel()` option to a `rowModels.<slot>` entry with
-      the matching `create*RowModel(...)` factory.
-- [ ] Add `filterFns` / `sortFns` / `aggregationFns` as **factory parameters**
-      where needed.
+- [ ] Convert every `get*RowModel()` option to a slot on the `features` object
+      using the matching `create*RowModel()` factory.
+- [ ] Move `filterFns` / `sortFns` / `aggregationFns` fn registries to slots
+      on the `features` object (not as factory parameters).
 - [ ] Update `createColumnHelper<Person>()` → `createColumnHelper<typeof features, Person>()`.
 - [ ] Update every `ColumnDef<Person>` / `Cell<Person, X>` etc. to include
       `TFeatures`.
@@ -314,8 +316,7 @@ v8 backed reactivity with manual memoized getters. v9's adapter
 - [ ] Remove any usage of the v8 single `onStateChange` — split into per-slice
       `on[State]Change`.
 - [ ] In `on[State]Change` callbacks, handle both value and updater-fn shapes.
-- [ ] Move `columns`, `features`, `rowModels` **outside** the `injectTable`
-      initializer.
+- [ ] Move `columns` and `features` **outside** the `injectTable` initializer.
 - [ ] Switch any `flexRender` long-form to `*flexRenderCell` / `*flexRenderHeader` /
       `*flexRenderFooter` shorthand where applicable.
 - [ ] Where you need component rendering with explicit options, switch wrapper
@@ -326,8 +327,9 @@ v8 backed reactivity with manual memoized getters. v9's adapter
 - [ ] Rename `sortingFn` → `sortFn`, `getSortingFn` → `getSortFn`,
       `sortingFns` → `sortFns`, `SortingFn` → `SortFn`.
 - [ ] Replace `columnSizingInfo` state / setters / change handler with the
-      `columnResizing` equivalents; add `columnResizingFeature` to `features`
-      if you actually drag-resize.
+      `columnResizing` equivalents; add `columnSizingFeature` and
+      `columnResizingFeature` to `features` if you actually drag-resize
+      (`columnResizingFeature` requires `columnSizingFeature`).
 - [ ] Replace `enablePinning` with `enableColumnPinning` / `enableRowPinning`.
 - [ ] Update `ColumnMeta` module augmentation to include the `TFeatures`
       generic.
@@ -342,9 +344,9 @@ v8 backed reactivity with manual memoized getters. v9's adapter
 
 ### 1. (CRITICAL) Leaving `getCoreRowModel()` / `getSortedRowModel()` / etc. in v9 options
 
-These options don't exist anymore. They become `rowModels` entries with
-factory functions. The TypeScript error is loud but agents sometimes silence
-it with `as any` — don't.
+These options don't exist anymore. The equivalent factories become slots on the
+`features` object (e.g. `sortedRowModel: createSortedRowModel()`). The TypeScript
+error is loud but agents sometimes silence it with `as any` — don't.
 
 ### 2. (CRITICAL) Reaching for `createAngularTable` from v8 muscle memory
 
@@ -356,14 +358,14 @@ it must run from a class field, constructor, or
 
 ```ts
 // ❌ filtering enabled, but no filtered row model — UI changes, rows don't filter
-features: tableFeatures({ columnFilteringFeature })
-rowModels: {
-} // missing filteredRowModel
+const features = tableFeatures({ columnFilteringFeature }) // missing filteredRowModel
 
 // ✅
-rowModels: {
-  filteredRowModel: createFilteredRowModel(filterFns)
-}
+const features = tableFeatures({
+  columnFilteringFeature,
+  filteredRowModel: createFilteredRowModel(),
+  filterFns,
+})
 ```
 
 Same for sorting, pagination, expanding, grouping, faceting. Selection,
@@ -390,11 +392,12 @@ to default sort.
 const columnHelper = createColumnHelper<Person>()
 ```
 
-### 7. (HIGH) Putting `features` / `columns` / row-model factories inside the `injectTable` initializer
+### 7. (HIGH) Putting `features` / `columns` inside the `injectTable` initializer
 
 The v8 mental model was "build columns inside the hook". v9's
 `injectTable` initializer re-runs on every signal read change — keep heavy
-literals outside.
+literals outside. Because row-model factories and fn registries live on the
+`features` object, keeping `features` stable at module scope covers all of them.
 
 Lower-severity failure modes (MEDIUM/LOW: `stockFeatures` cleanup, `enablePinning`
 removal, `columnSizingInfo` rename, single-handler porting, hand-rolled

package/skills/angular/migrate-v8-to-v9/references/v8-to-v9-mapping.md

@@ -8,17 +8,21 @@ exhaustive lookup.
 
 ## Row-model migration table
 
-| v8 option                  | v9 `rowModels` key    | v9 factory                              |
-| -------------------------- | --------------------- | --------------------------------------- |
-| `getCoreRowModel()`        | (automatic)           | —                                       |
-| `getFilteredRowModel()`    | `filteredRowModel`    | `createFilteredRowModel(filterFns)`     |
-| `getSortedRowModel()`      | `sortedRowModel`      | `createSortedRowModel(sortFns)`         |
-| `getPaginationRowModel()`  | `paginatedRowModel`   | `createPaginatedRowModel()`             |
-| `getExpandedRowModel()`    | `expandedRowModel`    | `createExpandedRowModel()`              |
-| `getGroupedRowModel()`     | `groupedRowModel`     | `createGroupedRowModel(aggregationFns)` |
-| `getFacetedRowModel()`     | `facetedRowModel`     | `createFacetedRowModel()`               |
-| `getFacetedMinMaxValues()` | `facetedMinMaxValues` | `createFacetedMinMaxValues()`           |
-| `getFacetedUniqueValues()` | `facetedUniqueValues` | `createFacetedUniqueValues()`           |
+Row-model factories and fn registries are now **slots on the `features` object**,
+not a separate `rowModels` option. Factory calls no longer take fn arguments;
+pass the fn map as a sibling slot instead.
+
+| v8 option                  | v9 `features` slot key | v9 factory call               | v9 fn registry slot |
+| -------------------------- | ---------------------- | ----------------------------- | ------------------- |
+| `getCoreRowModel()`        | (automatic)            | —                             | —                   |
+| `getFilteredRowModel()`    | `filteredRowModel`     | `createFilteredRowModel()`    | `filterFns`         |
+| `getSortedRowModel()`      | `sortedRowModel`       | `createSortedRowModel()`      | `sortFns`           |
+| `getPaginationRowModel()`  | `paginatedRowModel`    | `createPaginatedRowModel()`   | —                   |
+| `getExpandedRowModel()`    | `expandedRowModel`     | `createExpandedRowModel()`    | —                   |
+| `getGroupedRowModel()`     | `groupedRowModel`      | `createGroupedRowModel()`     | `aggregationFns`    |
+| `getFacetedRowModel()`     | `facetedRowModel`      | `createFacetedRowModel()`     | —                   |
+| `getFacetedMinMaxValues()` | `facetedMinMaxValues`  | `createFacetedMinMaxValues()` | —                   |
+| `getFacetedUniqueValues()` | `facetedUniqueValues`  | `createFacetedUniqueValues()` | —                   |
 
 ## Feature registration table
 
@@ -116,7 +120,7 @@ declare module '@tanstack/angular-table' {
 | `SortingFns` interface              | `SortFns`                |
 | `sortingFns` (built-in fn registry) | `sortFns`                |
 
-Find-and-replace, then update `createSortedRowModel(sortFns)`.
+Find-and-replace, then verify `sortFns` is a slot on `features` alongside `sortedRowModel: createSortedRowModel()`.
 
 ---
 
@@ -171,13 +175,16 @@ during migration if you have shared base config:
 import { tableOptions, tableFeatures, rowSortingFeature } from '@tanstack/angular-table'
 
 const baseOptions = tableOptions({
-  features: tableFeatures({ rowSortingFeature }),
+  features: tableFeatures({
+    rowSortingFeature,
+    sortedRowModel: createSortedRowModel(),
+    sortFns,
+  }),
   debugTable: isDevMode(),
 })
 
 readonly table = injectTable(() => ({
   ...baseOptions,
-  rowModels: { /* … */ },
   columns: this.columns,
   data: this.data(),
 }))

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

@@ -2,14 +2,14 @@
 name: angular/production-readiness
 description: >
   Ship-ready optimizations for Angular Table v9: register only the `features` you actually use
-  (tree-shake the bundle); keep `columns` / `features` / `rowModels` / feature-fn maps as
-  stable references OUTSIDE the `injectTable` initializer; pass only the `*Fns` your data needs
-  to `createSortedRowModel` / `createFilteredRowModel` / `createGroupedRowModel`; use
-  `ChangeDetectionStrategy.OnPush`; lean on signal-backed atoms (`table.atoms.<slice>.get()`)
-  instead of broad `table.state` reads where granularity matters; use `{ equal: shallow }`
-  on object/array `computed` selectors; set `getRowId` for stable identity; track by `id` in
-  every `@for`; defer cell components with `flexRenderComponent` only when you need its options;
-  scope DI tokens via `[tanStackTable*]` directives to kill prop drilling.
+  (tree-shake the bundle); keep `columns` / `features` (which carries row-model factories and
+  fn registries) as stable references OUTSIDE the `injectTable` initializer; pass only the `*Fns`
+  your data needs as slots on the features object; use `ChangeDetectionStrategy.OnPush`; lean on
+  signal-backed atoms (`table.atoms.<slice>.get()`) instead of broad `table.state` reads where
+  granularity matters; use `{ equal: shallow }` on object/array `computed` selectors; set
+  `getRowId` for stable identity; track by `id` in every `@for`; defer cell components with
+  `flexRenderComponent` only when you need its options; scope DI tokens via `[tanStackTable*]`
+  directives to kill prop drilling.
 type: lifecycle
 library: tanstack-table
 framework: angular
@@ -59,10 +59,11 @@ Use `stockFeatures` to bootstrap during a v8 → v9 migration, then **come back
 and curate**. The bundle wins only land once you do.
 
 The same applies to feature-fn registries — pass only the `*Fns` your data
-needs:
+needs as slots on the features object:
 
 ```ts
 import {
+  tableFeatures,
   createSortedRowModel,
   createFilteredRowModel,
   sortFns,
@@ -70,16 +71,20 @@ import {
 } from '@tanstack/angular-table'
 
 // ❌ pulls in every built-in sort + filter fn
-rowModels: {
-  sortedRowModel:   createSortedRowModel(sortFns),
-  filteredRowModel: createFilteredRowModel(filterFns),
-}
+const features = tableFeatures({
+  sortedRowModel: createSortedRowModel(),
+  filteredRowModel: createFilteredRowModel(),
+  sortFns,
+  filterFns,
+})
 
 // ✅ only what you use
-rowModels: {
-  sortedRowModel:   createSortedRowModel({ basic: sortFns.basic, datetime: sortFns.datetime }),
-  filteredRowModel: createFilteredRowModel({ includesString: filterFns.includesString }),
-}
+const features = tableFeatures({
+  sortedRowModel: createSortedRowModel(),
+  filteredRowModel: createFilteredRowModel(),
+  sortFns: { basic: sortFns.basic, datetime: sortFns.datetime },
+  filterFns: { includesString: filterFns.includesString },
+})
 ```
 
 Same logic for `aggregationFns` if you use grouping.
@@ -91,30 +96,28 @@ Same logic for `aggregationFns` if you use grouping.
 `injectTable(() => ({...}))` **re-runs the initializer every time a signal read
 inside it changes** and then calls `table.setOptions({ ...prev, ...new })`.
 Anything you create inside the initializer is recreated on every signal
-change.
+change. Because row-model factories and fn registries live on the `features`
+object, keeping `features` stable at module scope covers all of them.
 
 ```ts
-// ❌ columns / features / rowModels / feature fns recreated on every data() change
+// ❌ columns / features recreated on every data() change
 @Component({...})
 export class App {
   readonly table = injectTable(() => ({
-    features: tableFeatures({ rowSortingFeature }),           // ← new ref each run
-    rowModels: { sortedRowModel: createSortedRowModel(sortFns) }, // ← new ref each run
-    columns: [/* … */],                                        // ← new ref each run
+    features: tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns }),
+    columns: [/* … */],
     data: this.data(),
   }))
 }
 
 // ✅ stable references outside; only reactive reads inside
-const features = tableFeatures({ rowSortingFeature })
-const rowModels = { sortedRowModel: createSortedRowModel(sortFns) }
+const features = tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns })
 const columns: Array<ColumnDef<typeof features, Person>> = [/* … */]
 
 @Component({...})
 export class App {
   readonly table = injectTable(() => ({
     features,
-    rowModels,
     columns,
     data: this.data(),
   }))
@@ -125,7 +128,7 @@ Same rule for the controlled-state pattern — keep `state: { pagination: this.p
 inside the initializer, but keep the signal definitions on the class.
 
 For shared infrastructure across multiple tables, `createTableHook(...)` lets
-you define `features` / `rowModels` / default options once at module scope.
+you define `features` / default options once at module scope.
 
 ---
 
@@ -337,11 +340,11 @@ the wiring cost. Pick exactly one source of truth per slice (see
 ## 13. Quick wins checklist
 
 - [ ] `features` listed explicitly (no `stockFeatures` in production).
-- [ ] `*Fns` registries passed only what you use to
-      `createSortedRowModel` / `createFilteredRowModel` /
-      `createGroupedRowModel`.
-- [ ] `columns`, `features`, `rowModels`, feature fns are at module scope
-      or stable class fields — never inside the `injectTable` initializer.
+- [ ] `*Fns` registry slots on `features` pass only what you use (not the full
+      `sortFns` / `filterFns` / `aggregationFns` spread when you can narrow it).
+- [ ] `columns` and `features` are at module scope or stable class fields —
+      never inside the `injectTable` initializer (factories and fn registries
+      live on `features`, so this covers them too).
 - [ ] Component is `ChangeDetectionStrategy.OnPush`.
 - [ ] `getRowId` set when rows have a stable primary key.
 - [ ] All `@for` blocks track by `id`.
@@ -366,13 +369,12 @@ the wiring cost. Pick exactly one source of truth per slice (see
 calls this out — `stockFeatures` is a v8 → v9 bootstrap, not a production
 end-state.
 
-### 2. (CRITICAL) Recreating `columns` / `features` / `rowModels` inside the
-
-`injectTable` initializer
+### 2. (CRITICAL) Recreating `columns` / `features` inside the `injectTable` initializer
 
-The initializer re-runs on every signal read change. New `columns` reference
+The initializer re-runs on every signal read change. A new `columns` reference
 triggers full column-model rebuilds — for big tables this is visibly slow.
-Module-scope it.
+Module-scope both `columns` and `features` (which carries the factories and fn
+registries).
 
 ### 3. (CRITICAL) Reimplementing what the table already does
 
@@ -386,7 +388,8 @@ Symptoms:
 
 All of these are far slower than the built-in row models (which memoize and
 short-circuit) and ship more code. Use `table.setSorting(...)`,
-`table.setColumnFilters(...)`, the registered `rowModels` factories.
+`table.setColumnFilters(...)`, and the row-model factories registered on the
+`features` object.
 
 ### 4. (HIGH) `OnPush` not set
 

package/skills/angular/table-state/SKILL.md

@@ -36,7 +36,7 @@ sources:
 
 ---
 
-## 1. Prerequisites — `features` and `rowModels` decide what state exists
+## 1. Prerequisites — `features` decides what state exists
 
 In v9, **a state slice only exists if its feature is registered in `features`**.
 This is the #1 v9-specific gotcha and the root cause of many "missing API"
@@ -57,14 +57,13 @@ import {
 const features = tableFeatures({
   rowPaginationFeature,
   rowSortingFeature,
+  paginatedRowModel: createPaginatedRowModel(),
+  sortedRowModel: createSortedRowModel(),
+  sortFns,
 })
 
 readonly table = injectTable(() => ({
   features,
-  rowModels: {
-    paginatedRowModel: createPaginatedRowModel(),
-    sortedRowModel: createSortedRowModel(sortFns),
-  },
   columns,
   data: this.data(),
 }))
@@ -91,7 +90,6 @@ run inside an Angular injection context (a component constructor / class field).
 ```ts
 readonly table = injectTable(() => ({
   features,
-  rowModels: {},
   columns,
   data: this.data(),
 }))
@@ -105,25 +103,23 @@ That means:
 
 - **Reactive values that should re-sync the table** (`this.data()`, controlled
   state signals) go _inside_ the initializer.
-- **Stable references** (`columns`, `features`, `rowModels`, feature-fn maps)
-  go _outside_ — or you'll recreate the column model on every data update.
+- **Stable references** (`columns`, `features`) go _outside_ — or you'll
+  recreate the column model on every data update.
 
 ```ts
 // ❌ WRONG — columns + features recreated on every data change
 readonly table = injectTable(() => ({
-  features: tableFeatures({ rowSortingFeature }),     // new reference each run
-  rowModels: { sortedRowModel: createSortedRowModel(sortFns) }, // ditto
-  columns: [/* … */],                                  // ditto
+  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(), // ← only the signal read should be inside
 }))
@@ -230,7 +226,6 @@ the value that reset APIs reset to.
 ```ts
 readonly table = injectTable(() => ({
   features,
-  rowModels: { /* … */ },
   columns,
   data: this.data(),
   initialState: {
@@ -276,9 +271,6 @@ export class Component {
 
   readonly table = injectTable(() => ({
     features,
-    rowModels: {
-      /* … */
-    },
     columns,
     data: this.data(),
     state: {
@@ -335,9 +327,9 @@ right ownership model.** When you need more, see
 - **State type imports** — `PaginationState`, `SortingState`,
   `RowSelectionState`, `TableState<typeof features>`, etc.
 - **`createTableHook(...)`** — app-wide `injectAppTable` /
-  `createAppColumnHelper` that pre-bind `features` and `rowModels`. Also
-  exposes `tableComponents` / `cellComponents` / `headerComponents` registries
-  (covered in `angular-rendering-directives`).
+  `createAppColumnHelper` that pre-bind `features` (which now carries row-model
+  factories and fn registries). Also exposes `tableComponents` / `cellComponents` /
+  `headerComponents` registries (covered in `angular-rendering-directives`).
 
 ---
 
@@ -359,15 +351,15 @@ import { injectTable, tableFeatures } from '@tanstack/angular-table'
 const features = tableFeatures({})
 const table = injectTable(() => ({
   features,
-  rowModels: {},
   columns,
   data: data(),
 }))
 ```
 
 Also retired: `getFilteredRowModel`, `getSortedRowModel`, `getPaginationRowModel`
-as top-level options → migrated to `rowModels: { filteredRowModel: ..., sortedRowModel: ..., paginatedRowModel: ... }`
-with explicit `*Fns` parameters.
+as top-level options → migrated to slots on the `features` object
+(`filteredRowModel: createFilteredRowModel()`, `sortedRowModel: createSortedRowModel()`,
+`paginatedRowModel: createPaginatedRowModel()`) with fn registries (`filterFns`, `sortFns`) also on `features`.
 
 ### 2. (CRITICAL) Missing API because feature not in `features`
 
@@ -394,9 +386,10 @@ Same for `setPageIndex`, `setPageSize`, `setSorting`, `toggleSorting`,
 ### 4. (HIGH) Expensive values declared **inside** the `injectTable` initializer
 
 Because the initializer re-runs when any reactive read inside it changes,
-declaring `columns`, `features`, `rowModels`, or feature-fn maps inside the
-function causes them to be recreated and re-applied on every data update.
-Move them outside the class or to stable class fields.
+declaring `columns` or `features` inside the function causes them to be
+recreated and re-applied on every data update (row-model factories and fn
+registries are part of `features`, so moving `features` outside covers all of
+them). Move them outside the class or to stable class fields.
 
 ### 5. (HIGH) Forgetting that the initializer re-runs
 

package/skills/angular/table-state/references/external-atoms-and-app-hook.md

@@ -24,7 +24,6 @@ const paginationAtom = new Store<PaginationState>({ pageIndex: 0, pageSize: 10 }
 
 readonly table = injectTable(() => ({
   features,
-  rowModels: { /* … */ },
   columns,
   data: this.data(),
   atoms: {
@@ -68,7 +67,7 @@ type MyTableState = TableState<typeof features>
 
 ## `createTableHook` — app-wide table infrastructure
 
-When multiple tables in an app share the same `features`, `rowModels`, and
+When multiple tables in an app share the same `features` object and
 component conventions, factor them into a `createTableHook(...)` call once and
 import the resulting `injectAppTable` / `createAppColumnHelper`.
 
@@ -91,11 +90,13 @@ export const {
   injectTableCellContext,
   injectTableHeaderContext,
 } = createTableHook({
-  features: tableFeatures({ rowSortingFeature, rowPaginationFeature }),
-  rowModels: {
-    sortedRowModel: createSortedRowModel(sortFns),
+  features: tableFeatures({
+    rowSortingFeature,
+    rowPaginationFeature,
+    sortedRowModel: createSortedRowModel(),
     paginatedRowModel: createPaginatedRowModel(),
-  },
+    sortFns,
+  }),
   getRowId: (row) => row.id,
 })
 ```
@@ -110,7 +111,7 @@ const columnHelper = createAppColumnHelper<Person>() // only TData generic neede
 readonly table = injectAppTable(() => ({
   columns,
   data: this.data(),
-})) // features & rowModels inherited
+})) // features (including row-model factories) inherited
 ```
 
 `createTableHook` also lets you register `tableComponents` / `cellComponents` /

package/src/helpers/cell.ts

@@ -23,7 +23,7 @@ export interface TanStackTableCellContext<
  * This token is provided by the {@link TanStackTableCell} directive.
  */
 export const TanStackTableCellToken = new InjectionToken<
-  TanStackTableCellContext<any, any, any>['cell']
+  TanStackTableCellContext<TableFeatures, RowData, CellData>['cell']
 >('[TanStack Table] CellContext')
 
 /**
@@ -100,5 +100,9 @@ export function injectTableCellContext<
   TData extends RowData,
   TValue extends CellData,
 >(): TanStackTableCellContext<TFeatures, TData, TValue>['cell'] {
-  return inject(TanStackTableCellToken)
+  return inject(TanStackTableCellToken) as unknown as TanStackTableCellContext<
+    TFeatures,
+    TData,
+    TValue
+  >['cell']
 }

package/src/helpers/createTableHook.ts

@@ -333,10 +333,7 @@ export type CreateTableHookResult<
     TValue extends CellData,
   >() => CellContext<TFeatures, TData, TValue>
   injectAppTable: <TData extends RowData>(
-    tableOptions: () => Omit<
-      TableOptions<TFeatures, TData>,
-      'features' | 'rowModels'
-    >,
+    tableOptions: () => Omit<TableOptions<TFeatures, TData>, 'features'>,
   ) => AppAngularTable<
     TFeatures,
     TData,
@@ -358,7 +355,6 @@ export type CreateTableHookResult<
  * ```ts
  * const { injectAppTable, createAppColumnHelper } = createTableHook({
  *   features,
- *   rowModels: {},
  *   tableComponents: {},
  *   cellComponents: {},
  *   headerComponents: {},
@@ -424,10 +420,7 @@ export function createTableHook<
     TData extends RowData,
     TSelected = TableState<TFeatures>,
   >(
-    tableOptions: () => Omit<
-      TableOptions<TFeatures, TData>,
-      'features' | 'rowModels'
-    >,
+    tableOptions: () => Omit<TableOptions<TFeatures, TData>, 'features'>,
   ): AppAngularTable<
     TFeatures,
     TData,
@@ -447,7 +440,7 @@ export function createTableHook<
       return footer as Header<TFeatures, TData, any> & THeaderComponents
     }
 
-    const appTableFeatures: TableFeature<{}> = {
+    const appTableFeatures: TableFeature = {
       constructTableAPIs: (table) => {
         Object.assign(table, tableComponents, { appCell, appHeader, appFooter })
       },
@@ -467,8 +460,14 @@ export function createTableHook<
           ...defaultTableOptions.features,
           appTableFeatures,
         },
-      } as TableOptions<TFeatures, TData>
-    }) as AngularTable<any, any>
+      } as unknown as TableOptions<TFeatures, TData>
+    }) as unknown as AppAngularTable<
+      TFeatures,
+      TData,
+      TTableComponents,
+      TCellComponents,
+      THeaderComponents
+    >
   }
 
   function createAppColumnHelper<TData extends RowData>(): AppColumnHelper<