@tanstack/ember-table 9.2.4 → 9.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/ember-table",
-  "version": "9.2.4",
+  "version": "9.2.6",
   "description": "Headless UI for building powerful tables & datagrids for Ember.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -57,40 +57,40 @@
   ],
   "dependencies": {
     "@embroider/addon-shim": "^1.10.3",
-    "@tanstack/store": "^0.11.1",
-    "@tanstack/table-core": "9.2.4",
+    "@tanstack/store": "^0.11.2",
+    "@tanstack/table-core": "9.2.6",
     "decorator-transforms": "2.4.0"
   },
   "devDependencies": {
     "@babel/core": "7.29.7",
     "@babel/plugin-transform-typescript": "7.29.7",
-    "@ember/app-tsconfig": "2.0.0",
-    "@ember/library-tsconfig": "^2.0.0",
-    "@ember/test-helpers": "^5.4.3",
-    "@embroider/addon-dev": "^8.3.1",
-    "@embroider/core": "4.6.3",
-    "@embroider/macros": "1.20.6",
-    "@embroider/vite": "^1.7.10",
+    "@ember/app-tsconfig": "2.1.0",
+    "@ember/library-tsconfig": "^3.0.0",
+    "@ember/test-helpers": "^5.7.0",
+    "@embroider/addon-dev": "^8.4.0",
+    "@embroider/core": "4.6.7",
+    "@embroider/macros": "1.21.1",
+    "@embroider/vite": "^1.7.13",
     "@eslint/js": "^10.0.1",
     "@glimmer/component": "2.1.1",
-    "@glint/ember-tsc": "1.11.0",
-    "@glint/template": "1.8.0",
-    "@glint/tsserver-plugin": "2.7.3",
+    "@glint/ember-tsc": "1.11.6",
+    "@glint/template": "1.9.0",
+    "@glint/tsserver-plugin": "2.7.9",
     "@rollup/plugin-babel": "7.1.0",
     "@types/qunit": "^2.19.14",
     "babel-plugin-ember-template-compilation": "4.0.0",
-    "ember-qunit": "^9.1.0",
-    "ember-source": "7.2.0",
+    "ember-qunit": "^9.2.0",
+    "ember-source": "7.3.0",
     "ember-strict-application-resolver": "0.1.1",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-ember": "^13.5.0",
+    "eslint-plugin-ember": "^13.6.0",
     "eslint-plugin-import-x": "^4.17.1",
-    "globals": "^17.11.0",
-    "qunit": "^2.26.0",
+    "globals": "^17.13.0",
+    "qunit": "^3.0.0",
     "qunit-dom": "^3.6.0",
-    "rollup": "^4.63.0",
-    "testem": "^3.20.1",
-    "typescript-eslint": "^8.68.0"
+    "rollup": "^4.64.0",
+    "testem": "^3.21.3",
+    "typescript-eslint": "^8.71.0"
   },
   "ember": {
     "edition": "octane"

package/skills/getting-started/SKILL.md

@@ -1,36 +1,37 @@
 ---
 name: getting-started
-description: >
-  Create a TanStack Ember Table v9 table with useTable, a tracked options thunk, stable tableFeatures and columns, .gts templates, FlexRenderCell/Header/Footer, and correctly bound template helpers. Load for first-table setup, Glimmer reactivity, component cell renderers, or adapting another framework's example to Ember.
+description:
+  Create and render Table v9 with the ember adapter. Route reusable createTableHook
+  defaults, and framework setup; use table-state for reactive ownership.
 metadata:
   type: framework
   library: '@tanstack/ember-table'
   framework: ember
-  library_version: '9.2.4'
+  library_version: '9.2.6'
 requires:
   - '@tanstack/table-core#core'
-  - '@tanstack/table-core#table-features'
 sources:
-  - 'TanStack/table:docs/framework/ember/quick-start.md'
-  - 'TanStack/table:examples/ember/basic-table'
-  - 'TanStack/table:packages/ember-table/src/index.ts'
-  - 'TanStack/table:packages/ember-table/src/use-table.ts'
-  - 'TanStack/table:packages/ember-table/src/FlexRender.gts'
+  - TanStack/table:docs/framework/ember/quick-start.md
+  - TanStack/table:examples/ember/basic-table
+  - TanStack/table:packages/ember-table/src/index.ts
+  - TanStack/table:packages/ember-table/src/use-table.ts
+  - TanStack/table:packages/ember-table/src/FlexRender.gts
+  - TanStack/table:docs/framework/ember/guide/composable-tables.md
+  - TanStack/table:examples/ember/basic-app-table
+  - TanStack/table:packages/ember-table/src/create-table-hook.ts
 ---
 
-This skill builds on `@tanstack/table-core#core` and `@tanstack/table-core#table-features`. Ember Table is headless: it supplies reactive table models and renderer helpers, while the application owns semantic markup, CSS, accessibility, and design-system components.
+Load `intent load @tanstack/table-core#core` first for the headless model, stable inputs, and column inference.
 
-The v9 addon requires Ember 5.8 or newer with Embroider or ember-auto-import v2. Prefer `.gts`/`.gjs` template-tag components with Glint.
+Ember 5.8 or newer requires Embroider or ember-auto-import v2. Prefer `.gts` or `.gjs` template-tag components with Glint.
 
 ## Setup
 
 ```gts
 import Component from '@glimmer/component'
 import { tracked } from '@glimmer/tracking'
-import { on } from '@ember/modifier'
 import {
   FlexRenderCell,
-  FlexRenderHeader,
   createColumnHelper,
   tableFeatures,
   useTable,
@@ -55,41 +56,19 @@ const getAllCells = (
 export default class PeopleTable extends Component {
   @tracked data = initialData
 
-  table = useTable(() => ({
+  table = useTable(this, () => ({
     features,
     columns,
     data: this.data,
     getRowId,
   }))
 
-  get headerGroups() {
-    return this.table.getHeaderGroups()
-  }
-
   get rows() {
     return this.table.getRowModel().rows
   }
 
-  addPerson = () => {
-    this.data = [...this.data, { id: '2', name: 'Grace' }]
-  }
-
   <template>
-    <button type='button' {{on 'click' this.addPerson}}>Add person</button>
     <table>
-      <thead>
-        {{#each this.headerGroups as |group|}}
-          <tr>
-            {{#each group.headers as |header|}}
-              <th colspan={{header.colSpan}}>
-                {{#unless header.isPlaceholder}}
-                  <FlexRenderHeader @header={{header}} />
-                {{/unless}}
-              </th>
-            {{/each}}
-          </tr>
-        {{/each}}
-      </thead>
       <tbody>
         {{#each this.rows as |row|}}
           <tr>
@@ -104,57 +83,22 @@ export default class PeopleTable extends Component {
 }
 ```
 
-`useTable` takes an options thunk. Tracked properties read by that thunk update table options, and table API reads inside getters/templates participate in Glimmer tracking. Keep `features` and `columns` at stable module or component-lifetime scope; replace `@tracked data` only when data meaningfully changes.
-
-## Ember-Specific Patterns
-
-### Preserve method receivers in templates
-
-V9 table, column, row, cell, and header methods live on prototypes and require their receiver. Ember templates extract function references, so call methods in a getter or a small module-level helper:
-
-```gts
-const getCanSort = (column: Column<typeof features, Person>) =>
-  column.getCanSort()
-
-const toggleSort =
-  (column: Column<typeof features, Person>) => (event: Event) =>
-    column.getToggleSortingHandler()?.(event)
-```
-
-Pass `toggleSort header.column` to `{{on}}`; do not pass an extracted Table method directly.
-
-### Render definitions through the matching component
-
-Use `FlexRenderCell`, `FlexRenderHeader`, and `FlexRenderFooter` with their matching object. A definition may return a primitive or `flexRenderComponent(Component, options)`. The rendered component receives `@ctx` and optional `@options`; Table does not instantiate arbitrary component-library markup for you.
-
-## Common Mistakes
-
-### HIGH Passing an options object instead of a thunk
-
-Wrong: `useTable({ features, columns, data: this.data })`.
-
-Correct: `useTable(() => ({ features, columns, data: this.data }))`.
-
-The thunk is how tracked option reads are connected to the table.
-
-### HIGH Passing an unbound prototype method to a template modifier
-
-Wrong: `{{on 'click' header.column.getToggleSortingHandler}}`.
-
-Correct: wrap the call in a helper that invokes the method on `header.column`, as shown above.
+## Construction and rendering
 
-An extracted v9 prototype method loses `this` and can throw or silently target the wrong receiver.
+`useTable` takes an options thunk. Read tracked data inside it, and keep features, atoms, and columns stable. In a component, pass `this` as the owner to bind external-atom cleanup to the component lifecycle. The one-argument thunk form remains available for standalone tables.
 
-### HIGH Recreating model inputs inside the options thunk
+Read Table APIs in template-consumed getters. Column, row, cell, and header prototype methods require their receiver, so use a getter or module helper such as `getAllCells(row)` rather than an extracted method. Wrap event calls the same way.
 
-Wrong: `columns: columnHelper.columns(...)` or `data: this.data.slice()` inside `useTable(() => ...)`.
+Use `FlexRenderCell`, `FlexRenderHeader`, and `FlexRenderFooter` for the matching object. Rendered components receive `@ctx` and optional `@options` through `flexRenderComponent(Component, options)`.
 
-Correct: keep columns stable and pass the tracked data reference directly. The thunk may rerun; it should not manufacture new model inputs on every tracked update.
+With `tableFeatures({})`, render `row.getAllCells()`. Register `columnVisibilityFeature` before switching to `row.getVisibleCells()`.
 
-### MEDIUM Using a visibility-aware API without its feature
+## Read for the task
 
-With `tableFeatures({})`, render `row.getAllCells()`. Add `columnVisibilityFeature` before using `row.getVisibleCells()`.
+- When adding or configuring optional features, load `intent load @tanstack/table-core#table-features` and read only references for the requested behavior.
+- For state ownership or reactive reads, read [table-state](../table-state/SKILL.md).
+- When tables share features, defaults, or reusable UI, read [create-table-hook](references/create-table-hook.md).
 
-## API Discovery
+## API discovery
 
-Inspect `node_modules/@tanstack/ember-table/declarations/index.d.ts` for exports, `use-table.d.ts` for options/reactivity behavior, `FlexRender.d.ts` and `flex-render.d.ts` for renderer contracts, and `node_modules/@tanstack/table-core/dist/features/<feature>/` for feature-gated APIs. Do not substitute React hooks, subscriptions, or component signatures.
+Inspect `node_modules/@tanstack/ember-table/declarations/index.d.ts`, `use-table.d.ts`, `signal.d.ts`, and `FlexRender.d.ts`. Core feature APIs are in `node_modules/@tanstack/table-core/dist/features/`.

package/skills/{create-table-hook/SKILL.md → getting-started/references/create-table-hook.md}

@@ -1,23 +1,8 @@
----
-name: create-table-hook
-description: >
-  Share TanStack Ember Table v9 features, row-model slots, defaults, and inferred column helpers with createTableHook, createAppTable, createAppColumnHelper, and appFeatures. Load for recurring Ember table conventions, per-table overrides, or confusion with component/context registries from other adapters.
-metadata:
-  type: framework
-  library: '@tanstack/ember-table'
-  framework: ember
-  library_version: '9.2.4'
-requires:
-  - '@tanstack/table-core#core'
-  - getting-started
-  - table-state
-sources:
-  - 'TanStack/table:docs/framework/ember/guide/composable-tables.md'
-  - 'TanStack/table:examples/ember/basic-app-table'
-  - 'TanStack/table:packages/ember-table/src/create-table-hook.ts'
----
-
-This skill builds on `@tanstack/table-core#core`, `getting-started`, and `table-state`. Use an app factory when several tables share real features or defaults; keep a one-off table on `useTable`.
+# Ember reusable table hooks
+
+Read when multiple Ember tables share features, defaults, or rendering conventions. Keep standalone construction for tables without shared conventions. For controlled state or reactive reads, read [table-state](../../table-state/SKILL.md).
+
+This reference inherits the version of its owning skill.
 
 ## Setup
 
@@ -53,16 +38,16 @@ const columns = columnHelper.columns([
 export default class PeopleTable extends Component {
   @tracked data: Person[] = []
 
-  table = createAppTable(() => ({
+  table = createAppTable(this, () => ({
     columns,
     data: this.data,
   }))
 }
 ```
 
-Create the hook and column helpers at stable module scope. `createAppTable` preserves the `useTable` options thunk, so tracked reads such as `this.data` remain reactive. Do not pass `features` again at the table call site; the factory owns the feature set and binds it into column inference.
+Create the hook and column helpers at stable module scope. Pass the component as the first `createAppTable` argument to bind external-atom cleanup to its lifecycle; the one-argument thunk form remains supported for standalone tables. `createAppTable` preserves the `useTable` options thunk, so tracked reads such as `this.data` remain reactive. Do not pass `features` again at the table call site; the factory owns the feature set and binds it into column inference.
 
-## Composition Contract
+## Composition contract
 
 - Hook options supply stable shared `features` and default table options.
 - `createAppColumnHelper<TData>()` binds the feature type while inferring each row type.
@@ -74,11 +59,11 @@ Shared options intentionally exclude `columns`, `data`, and `state`. Keep model
 
 Sharing `rowSortingFeature`, `sortedRowModel`, and sorting defaults gives every table sorting capability; it does not make their internal sorting state shared. The factory technically accepts a stable external atom in shared `atoms`, but that deliberately couples tables and their column IDs. Prefer independent state unless synchronized tables are the actual product behavior.
 
-## Render Normally
+## Render normally
 
-Ember's factory does not register `AppTable`, `AppCell`, `AppHeader`, context hooks, or reusable component registries. Continue rendering with `FlexRenderCell`, `FlexRenderHeader`, and `FlexRenderFooter`. Continue wrapping receiver-dependent v9 methods in Ember template helpers as described by `getting-started`.
+Ember's factory does not register `AppTable`, `AppCell`, `AppHeader`, context hooks, or reusable component registries. Continue rendering with `FlexRenderCell`, `FlexRenderHeader`, and `FlexRenderFooter`. Continue wrapping receiver-dependent v9 methods in Ember template helpers as described by [getting-started](../SKILL.md).
 
-## Common Mistakes
+## Common mistakes
 
 ### HIGH Copying another adapter's component registry
 
@@ -96,7 +81,7 @@ Wrong:
 createAppTable(() => ({ features: otherFeatures, columns, data: this.data }))
 ```
 
-Correct: define a separate app hook when a table needs a genuinely different feature set. `createAppTable` omits `features` from its call-site type.
+Correct: define a separate app hook when a table needs a different feature set. `createAppTable` omits `features` from its call-site type.
 
 ### HIGH Recreating the hook or columns with tracked updates
 
@@ -112,6 +97,12 @@ The hook options omit `state`. Put `state` and matching `on[State]Change` callba
 
 Use `createAppColumnHelper<Person>()`; do not thread `typeof features` through every column helper after the factory has already captured it.
 
-## API Discovery
+## API discovery
 
 Inspect `node_modules/@tanstack/ember-table/declarations/create-table-hook.d.ts` for the installed factory return shape, omitted options, and merge precedence. Inspect `use-table.d.ts` for thunk reactivity and `node_modules/@tanstack/table-core/dist/features/<feature>/` for the shared feature APIs. Do not infer Ember component/context behavior from another adapter's createTableHook.
+
+## Sources
+
+- `TanStack/table:docs/framework/ember/guide/composable-tables.md`
+- `TanStack/table:examples/ember/basic-app-table`
+- `TanStack/table:packages/ember-table/src/create-table-hook.ts`

package/skills/table-state/SKILL.md

@@ -1,187 +1,83 @@
 ---
 name: table-state
-description: >
-  Read, track, initialize, control, and reset TanStack Ember Table v9 state through Glimmer-reactive table APIs, baseAtoms, atoms, store, Ember createAtom, or @tracked state plus on*Change. Load for ownership precedence, updater callbacks, stale template state, options-thunk reactivity, or incorrect table.Subscribe/store.subscribe usage.
+description:
+  Read and control Table v9 state in ember. Use for tracked reads, subscriptions,
+  controlled slices, and framework-specific reactive boundaries.
 metadata:
   type: framework
   library: '@tanstack/ember-table'
   framework: ember
-  library_version: '9.2.4'
+  library_version: '9.2.6'
 requires:
-  - '@tanstack/table-core#core'
-  - getting-started
+  - '@tanstack/table-core#table-state'
 sources:
-  - 'TanStack/table:docs/framework/ember/guide/table-state.md'
-  - 'TanStack/table:examples/ember/basic-external-atoms'
-  - 'TanStack/table:examples/ember/basic-external-state'
-  - 'TanStack/table:packages/ember-table/src/use-table.ts'
-  - 'TanStack/table:packages/ember-table/src/reactivity.ts'
-  - 'TanStack/table:packages/ember-table/src/signal.ts'
+  - TanStack/table:docs/framework/ember/guide/table-state.md
+  - TanStack/table:examples/ember/basic-external-atoms
+  - TanStack/table:examples/ember/basic-external-state
+  - TanStack/table:packages/ember-table/src/use-table.ts
+  - TanStack/table:packages/ember-table/src/reactivity.ts
+  - TanStack/table:packages/ember-table/src/signal.ts
 ---
 
-This skill builds on `@tanstack/table-core#core` and `getting-started`. Keep state internal unless another part of the application must read, persist, validate, or drive a slice.
+Load `intent load @tanstack/table-core#table-state` first for shared ownership, initialization, updater, and reset rules.
 
-## State Surfaces
+Glimmer tracks Table APIs, atom reads, and store-property reads inside template-consumed getters. A value cached outside tracked consumption is only a snapshot. There is no `table.Subscribe` or selector argument to `useTable`; `table.store.subscribe` is intentionally a no-op and cannot drive rendering.
 
-State exists only for registered features:
-
-- `table.baseAtoms` are the table's internal writable atoms.
-- `table.atoms` are readonly, ownership-aware atoms for each registered slice.
-- `table.store.state` exposes the current flat state.
-- Feature methods such as `setSorting`, `setPageSize`, and `row.toggleSelected()` are the preferred write path.
-
-Ember's reactivity feature bridges these reads into Glimmer tracking. There is no `table.Subscribe`, no selector argument to `useTable`, and no need to subscribe during rendering. Read the relevant API inside a template-consumed getter:
-
-```gts
-get rows() {
-  return this.table.getRowModel().rows
-}
-
-get pageIndex() {
-  return this.table.atoms.pagination.get().pageIndex
-}
-```
-
-`table.store.subscribe` is not the Ember rendering mechanism. The adapter's store is pull-based; Glimmer tracks individual property and atom reads.
-
-`features` and `atoms` are construct-time inputs in this adapter. Create them once before `useTable`; rerunning the options thunk updates ordinary live options but does not swap the table's feature set or atom owners.
-
-## Choose One Owner Per Slice
-
-For a slice such as pagination, choose one source of truth:
-
-1. Internal `baseAtoms` by default.
-2. `initialState.pagination` for an internally owned starting value.
-3. An external writable atom in `atoms.pagination`.
-4. A `@tracked` value in `state.pagination`, paired with `onPaginationChange`.
-
-Read precedence is `atoms[key]` over `state[key]` over the internal `baseAtoms[key]`. Do not configure multiple owners merely as fallbacks.
-
-## Internal and Initial State
-
-With no `initialState`, `atoms`, `state`, or `on[State]Change`, Table owns registered state internally. Use `initialState` when only the starting/reset value differs:
-
-```gts
-table = useTable(() => ({
-  features,
-  columns,
-  data: this.data,
-  initialState: {
-    pagination: { pageIndex: 0, pageSize: 25 },
-  },
-}))
-```
-
-Changing `initialState` later does not reset existing state. Prefer feature reset methods such as `resetPagination()`; passing `true` requests that feature's blank/default state. Core `table.reset()` resets internal base atoms and is not the primary reset path for externally owned atoms.
-
-## External Ember Atoms
-
-Use the adapter's re-exported `createAtom` when a slice should be shared or read directly outside Table. It satisfies the TanStack Store atom contract and its reads are Glimmer-reactive:
+## Controlled tracked setup
 
 ```gts
+import Component from '@glimmer/component'
+import { tracked } from '@glimmer/tracking'
+import { on } from '@ember/modifier'
 import {
-  createAtom,
-  useTable,
-  type PaginationState,
-} from '@tanstack/ember-table'
-
-paginationAtom = createAtom<PaginationState>({
-  pageIndex: 0,
-  pageSize: 10,
-})
-
-table = useTable(() => ({
-  features,
-  columns,
-  data: this.data,
-  atoms: { pagination: this.paginationAtom },
-}))
-
-get pagination() {
-  return this.paginationAtom.get()
-}
-```
-
-Feature APIs write through the external atom, so do not add `onPaginationChange` for the same atom-owned slice. Write the external atom itself when using the low-level path.
-
-## Controlled Tracked State
-
-Use `state` plus the matching callback when a `@tracked` property owns a slice. Resolve both raw values and updater functions:
-
-```gts
-import {
-  createPaginatedRowModel,
   rowPaginationFeature,
   tableFeatures,
+  useTable,
   type PaginationState,
 } from '@tanstack/ember-table'
 
-const features = tableFeatures({
-  rowPaginationFeature,
-  paginatedRowModel: createPaginatedRowModel(),
-})
-
-@tracked pagination: PaginationState = { pageIndex: 0, pageSize: 10 }
-
-table = useTable(() => ({
-  features,
-  columns,
-  data: this.data,
-  state: { pagination: this.pagination },
-  onPaginationChange: (updater) => {
-    this.pagination =
-      typeof updater === 'function' ? updater(this.pagination) : updater
-  },
-}))
-```
-
-The pagination feature owns the state and APIs; the row-model slot enables client-side pagination. For server-owned pagination, keep `rowPaginationFeature`, omit the client row-model slot, and configure the matching manual/server data options. The options thunk must read `this.pagination`; assigning the tracked field reruns the thunk and feeds the controlled value back into Table. V9 has no global `onStateChange` option.
-
-## Low-Level Writes and Types
-
-Use a feature method first. If internally owned state truly needs a low-level update:
-
-```ts
-this.table.baseAtoms.pagination.set((old) => ({ ...old, pageIndex: 0 }))
-```
-
-Do not write `table.atoms.pagination`; it is readonly and may point at an external owner. Infer the complete registered shape with `TableState<typeof features>` and use feature-specific types such as `PaginationState` or `SortingState` for owned fields.
-
-## Common Mistakes
-
-### CRITICAL Controlling a slice without writing callbacks back
-
-Wrong:
-
-```gts
-state: { pagination: this.pagination },
-onPaginationChange: () => {},
+const features = tableFeatures({ rowPaginationFeature })
+const columns = [{ accessorKey: 'name' }]
+const data = [{ name: 'Ada' }]
+
+export default class PageStatus extends Component {
+  @tracked pagination: PaginationState = { pageIndex: 0, pageSize: 10 }
+  table = useTable(this, () => ({
+    features,
+    columns,
+    data,
+    state: { pagination: this.pagination },
+    onPaginationChange: (next) => {
+      this.pagination =
+        typeof next === 'function' ? next(this.pagination) : next
+    },
+  }))
+
+  get pageNumber() {
+    return this.table.atoms.pagination.get().pageIndex + 1
+  }
+
+  nextPage = () => this.table.nextPage()
+
+  <template>
+    <button type='button' {{on 'click' this.nextPage}}>Page
+      {{this.pageNumber}}</button>
+  </template>
+}
 ```
 
-Correct: apply the value-or-updater to the tracked owner. Otherwise the slice is frozen at the controlled value.
-
-### HIGH Expecting a snapshot read or subscription component
-
-Wrong: invent `<table.Subscribe>`, call `table.store.subscribe(...)` for rendering, or cache `table.store.state.pagination` outside a tracked getter.
-
-Correct: read `table.atoms.pagination.get()`, `table.store.state.pagination`, or the relevant Table API inside a template-consumed getter.
-
-`table.getState()` is removed v8 API, not an Ember state-read alternative.
-
-### HIGH Mixing atom and state ownership
-
-If both `atoms.pagination` and `state.pagination` are present, the atom wins. Choose one owner so resets and writes have an unambiguous destination.
-
-### HIGH Mutating controlled objects in place
-
-Wrong: `this.pagination.pageIndex++`.
+## Reactive boundaries
 
-Correct: assign a new tracked value or let `table.setPageIndex(...)` invoke the controlled updater. Glimmer and the options thunk need an observable owner update.
+- Read tracked values inside the options thunk and assign callback results back to their tracked owner. Mutating `this.pagination.pageIndex++` does not notify the thunk.
+- `features` and `atoms` are construction-time inputs. Updating ordinary live options does not replace the feature set or atom owners; create them once before `useTable`.
+- Pass the component as the owner for lifecycle cleanup when external atoms are used. The standalone one-argument thunk form remains supported.
+- Use the adapter's `createAtom` for external Glimmer-reactive ownership. Read it in a tracked getter and use feature APIs or the external atom to write.
+- Keep features, columns, and data stable. Call receiver-dependent methods through getters or helpers rather than passing extracted methods to templates.
 
-### MEDIUM Writing the internal base atom for an external owner
+## Read for the task
 
-When `atoms.pagination` owns the slice, changing `baseAtoms.pagination` does not replace the active value. Write the external atom or use the feature API.
+For advanced reactive boundaries, shared atoms, or detailed subscription examples, read [reactivity](references/reactivity.md). For construction or rendering setup, read [getting-started](../getting-started/SKILL.md).
 
-## API Discovery
+## API discovery
 
-Inspect `node_modules/@tanstack/ember-table/declarations/use-table.d.ts` for option/state precedence and the Glimmer bridge, `signal.d.ts` for `createAtom` behavior, and `reactivity.d.ts` for scheduling/tracking. Inspect the registered feature under `node_modules/@tanstack/table-core/dist/features/<feature>/` for its state type, update API, and reset semantics.
+Inspect `node_modules/@tanstack/ember-table/declarations/index.d.ts`, `use-table.d.ts`, `signal.d.ts`, and `FlexRender.d.ts`. Core feature APIs are in `node_modules/@tanstack/table-core/dist/features/`.

package/skills/table-state/references/reactivity.md

@@ -0,0 +1,75 @@
+# Ember Table reactivity
+
+Read for Ember subscription boundaries, shared state, or updates that require more than the default rendering behavior.
+
+This reference inherits the version of its owning skill.
+
+## Own shared state with an Ember atom
+
+```gts
+import Component from '@glimmer/component'
+import { on } from '@ember/modifier'
+import {
+  createAtom,
+  rowPaginationFeature,
+  tableFeatures,
+  useTable,
+  type PaginationState,
+} from '@tanstack/ember-table'
+
+const features = tableFeatures({ rowPaginationFeature })
+const columns = [{ accessorKey: 'name' }]
+const data = [{ name: 'Ada' }]
+
+export default class SharedPage extends Component {
+  paginationAtom = createAtom<PaginationState>({ pageIndex: 0, pageSize: 10 })
+  table = useTable(this, () => ({
+    features,
+    columns,
+    data,
+    atoms: { pagination: this.paginationAtom },
+  }))
+
+  get pageNumber() {
+    return this.paginationAtom.get().pageIndex + 1
+  }
+
+  nextPage = () => this.table.nextPage()
+
+  <template>
+    <button type='button' {{on 'click' this.nextPage}}>Page
+      {{this.pageNumber}}</button>
+  </template>
+}
+```
+
+The adapter re-exports `createAtom` with Glimmer-reactive reads. Feature APIs write through to that owner, so omit `onPaginationChange`. Supplying the component owner binds external-atom cleanup to its destruction. Use the one-argument thunk form only when no Ember owner is available.
+
+## Construction-time ownership
+
+The options thunk updates ordinary live options from tracked reads, but features and external atom owners are fixed during construction. Keep them stable. Replacing an `atoms` object in a getter does not swap the table's owners.
+
+## Template tracking is pull-based
+
+Read `table.atoms.<slice>.get()`, `table.store.state.<slice>`, or a Table API inside a template-consumed getter. There is no selector argument or `table.Subscribe`; `table.store.subscribe` is a no-op. Subscribe to a supplied external atom when a separate consumer actually needs push notifications.
+
+`table.getState()` is removed v8 API. Caching a value outside tracked consumption does not establish Glimmer tracking.
+
+## Controlled state pitfalls
+
+Resolve value-or-updater callbacks and assign a fresh tracked value. `this.pagination.pageIndex++` mutates an untracked nested property. A no-op callback freezes the controlled slice. Prefer `table.setPageIndex(...)` to invoke the callback with the feature's update rules.
+
+An external atom wins over controlled state. Writing an internal base atom cannot replace the external value; use the feature API or write the external owner.
+
+## API discovery
+
+Inspect `node_modules/@tanstack/ember-table/declarations/index.d.ts`, `use-table.d.ts`, `signal.d.ts`, and `FlexRender.d.ts`. Core feature APIs are in `node_modules/@tanstack/table-core/dist/features/`.
+
+## Sources
+
+- `TanStack/table:docs/framework/ember/guide/table-state.md`
+- `TanStack/table:examples/ember/basic-external-atoms`
+- `TanStack/table:examples/ember/basic-external-state`
+- `TanStack/table:packages/ember-table/src/use-table.ts`
+- `TanStack/table:packages/ember-table/src/reactivity.ts`
+- `TanStack/table:packages/ember-table/src/signal.ts`