@tanstack/svelte-table 9.0.0-beta.59 → 9.0.0-beta.60

package/dist/createTable.svelte.d.ts

@@ -1,47 +1,38 @@
-import type { RowData, Table, TableFeatures, TableOptions, TableState } from '@tanstack/table-core';
-export type SvelteTable<TFeatures extends TableFeatures, TData extends RowData, TSelected = TableState<TFeatures>> = Omit<Table<TFeatures, TData>, 'store'> & {
-    /**
-     * @deprecated Prefer `table.state` for render reads,
-     * `table.atoms.<slice>.get()` for slice snapshots, or
-     * `useSelector(table.store, selector)` for explicit subscriptions.
-     * `table.store.state` is a current-value snapshot and is easy to misuse in
-     * render code.
-     */
-    readonly store: Table<TFeatures, TData>['store'];
-    /**
-     * The selected state of the table. This state may not match the structure of
-     * the full table state because it is selected by the selector function that
-     * you pass as the 2nd argument to `createTable`.
-     *
-     * @example
-     * const table = createTable(options, (state) => ({ globalFilter: state.globalFilter })) // only globalFilter is part of the selected state
-     *
-     * console.log(table.state.globalFilter)
-     */
-    readonly state: Readonly<TSelected>;
-};
+import type { RowData, Table, TableFeatures, TableOptions } from '@tanstack/table-core';
+/**
+ * A Svelte-aware TanStack Table instance.
+ *
+ * Table APIs and `table.atoms.<slice>.get()` reads participate in Svelte
+ * dependency tracking when used in templates, `$derived`, or `$effect`.
+ */
+export type SvelteTable<TFeatures extends TableFeatures, TData extends RowData> = Table<TFeatures, TData>;
 /**
  * Creates a Svelte 5 table instance backed by rune-aware TanStack Store atoms.
  *
- * The optional selector projects from `table.store`; the selected value is
- * exposed on `table.state`. The adapter syncs options in `$effect.pre`, so
- * reactive option getters and external `$state` values are applied before DOM
- * updates read table APIs such as `getRowModel()`.
+ * Read a specific state slice with `table.atoms.<slice>.get()` and read the
+ * complete state with `table.store.get()`. Those reads participate in Svelte
+ * dependency tracking when they run in a template, `$derived`, or `$effect`.
+ * The adapter syncs options in `$effect.pre`, so reactive option getters and
+ * external `$state` values are applied before DOM updates read table APIs such
+ * as `getRowModel()`.
  *
  * @example
  * ```svelte
  * <script lang="ts">
- *   const table = createTable(
- *     {
- *       features,
- *       columns,
- *       data,
+ *   const table = createTable({
+ *     features,
+ *     columns,
+ *     get data() {
+ *       return data
  *     },
- *     (state) => ({ pagination: state.pagination }),
- *   )
+ *   })
+ *
+ *   const pagination = $derived(table.atoms.pagination.get())
+ *   const stateJson = $derived(JSON.stringify(table.store.get(), null, 2))
  * </script>
  *
- * {table.state.pagination.pageIndex}
+ * <span>Page {pagination.pageIndex + 1}</span>
+ * <pre>{stateJson}</pre>
  * ```
  */
-export declare function createTable<TFeatures extends TableFeatures, TData extends RowData, TSelected = TableState<TFeatures>>(tableOptions: TableOptions<TFeatures, TData>, selector?: (state: TableState<TFeatures>) => TSelected): SvelteTable<TFeatures, TData, TSelected>;
+export declare function createTable<TFeatures extends TableFeatures, TData extends RowData>(tableOptions: TableOptions<TFeatures, TData>): SvelteTable<TFeatures, TData>;

package/dist/createTable.svelte.js

@@ -1,33 +1,37 @@
 import { constructTable } from '@tanstack/table-core';
-import { useSelector } from '@tanstack/svelte-store';
 import { untrack } from 'svelte';
 import { flatMerge, mergeObjects } from './merge-objects';
 import { svelteReactivity } from './reactivity.svelte';
 /**
  * Creates a Svelte 5 table instance backed by rune-aware TanStack Store atoms.
  *
- * The optional selector projects from `table.store`; the selected value is
- * exposed on `table.state`. The adapter syncs options in `$effect.pre`, so
- * reactive option getters and external `$state` values are applied before DOM
- * updates read table APIs such as `getRowModel()`.
+ * Read a specific state slice with `table.atoms.<slice>.get()` and read the
+ * complete state with `table.store.get()`. Those reads participate in Svelte
+ * dependency tracking when they run in a template, `$derived`, or `$effect`.
+ * The adapter syncs options in `$effect.pre`, so reactive option getters and
+ * external `$state` values are applied before DOM updates read table APIs such
+ * as `getRowModel()`.
  *
  * @example
  * ```svelte
  * <script lang="ts">
- *   const table = createTable(
- *     {
- *       features,
- *       columns,
- *       data,
+ *   const table = createTable({
+ *     features,
+ *     columns,
+ *     get data() {
+ *       return data
  *     },
- *     (state) => ({ pagination: state.pagination }),
- *   )
+ *   })
+ *
+ *   const pagination = $derived(table.atoms.pagination.get())
+ *   const stateJson = $derived(JSON.stringify(table.store.get(), null, 2))
  * </script>
  *
- * {table.state.pagination.pageIndex}
+ * <span>Page {pagination.pageIndex + 1}</span>
+ * <pre>{stateJson}</pre>
  * ```
  */
-export function createTable(tableOptions, selector) {
+export function createTable(tableOptions) {
     // 1. Merge reactivity into options using mergeObjects (preserves getters)
     const mergedOptions = mergeObjects(tableOptions, {
         features: {
@@ -66,14 +70,5 @@ export function createTable(tableOptions, selector) {
             });
         });
     });
-    // 5. State selector
-    const stateStore = useSelector(table.store, selector);
-    Object.defineProperty(table, 'state', {
-        get() {
-            return stateStore.current;
-        },
-        configurable: true,
-        enumerable: true,
-    });
     return table;
 }

package/dist/createTableHook.svelte.d.ts

@@ -1,7 +1,7 @@
 import FlexRenderSvelte from './FlexRender.svelte';
 import type { SvelteTable } from './createTable.svelte';
 import type { Component, Snippet } from 'svelte';
-import type { AccessorFn, AccessorFnColumnDef, AccessorKeyColumnDef, Cell, CellContext, CellData, Column, ColumnDef, DeepKeys, DeepValue, DisplayColumnDef, GroupColumnDef, Header, IdentifiedColumnDef, NoInfer, Row, RowData, Table, TableFeatures, TableOptions, TableState } from '@tanstack/table-core';
+import type { AccessorFn, AccessorFnColumnDef, AccessorKeyColumnDef, Cell, CellContext, CellData, Column, ColumnDef, DeepKeys, DeepValue, DisplayColumnDef, GroupColumnDef, Header, IdentifiedColumnDef, NoInfer, Row, RowData, Table, TableFeatures, TableOptions } from '@tanstack/table-core';
 export type ComponentType<T extends Record<string, any>> = Component<T>;
 /**
  * Enhanced CellContext with pre-bound cell components.
@@ -112,9 +112,10 @@ export type CreateTableHookOptions<TFeatures extends TableFeatures, TTableCompon
     headerComponents?: THeaderComponents;
 };
 /**
- * Extended table API returned by createAppTable with all App wrapper components.
+ * Svelte-aware table returned by `createAppTable`, extended with the registered
+ * table components and the `App*` context wrappers.
  */
-export type AppSvelteTable<TFeatures extends TableFeatures, TData extends RowData, TSelected, TTableComponents extends Record<string, ComponentType<any>>, TCellComponents extends Record<string, ComponentType<any>>, THeaderComponents extends Record<string, ComponentType<any>>> = SvelteTable<TFeatures, TData, TSelected> & NoInfer<TTableComponents> & {
+export type AppSvelteTable<TFeatures extends TableFeatures, TData extends RowData, TTableComponents extends Record<string, ComponentType<any>>, TCellComponents extends Record<string, ComponentType<any>>, THeaderComponents extends Record<string, ComponentType<any>>> = SvelteTable<TFeatures, TData> & NoInfer<TTableComponents> & {
     /**
      * Root wrapper component that provides table context.
      * @example
@@ -200,20 +201,18 @@ export interface CreateTableHookResult<TFeatures extends TableFeatures, TTableCo
     /**
      * Creates a table with the `App*` wrapper components and registered
      * `tableComponents` attached. `TData` is inferred from the `data` option.
+     *
+     * Read table state with `table.atoms.<slice>.get()` or `table.store.get()`.
+     * These reads participate in Svelte dependency tracking inside templates,
+     * `$derived`, and `$effect`.
      */
-    createAppTable: <TData extends RowData, TSelected = TableState<TFeatures>>(tableOptions: Omit<TableOptions<TFeatures, TData>, 'features'>, selector?: (state: TableState<TFeatures>) => TSelected) => AppSvelteTable<TFeatures, TData, TSelected, TTableComponents, TCellComponents, THeaderComponents>;
+    createAppTable: <TData extends RowData>(tableOptions: Omit<TableOptions<TFeatures, TData>, 'features'>) => AppSvelteTable<TFeatures, TData, TTableComponents, TCellComponents, THeaderComponents>;
     /**
      * Reads the table provided by the nearest `<table.AppTable>`. This is the same
      * extended instance `createAppTable` returns, so the `App*` components and your
      * `tableComponents` are available on it.
-     *
-     * Pass `TSelected` to match the selector you gave `createAppTable`, so
-     * `table.state` is typed as the selected slice. It cannot be inferred
-     * automatically (context does not carry the provider's generics), so it
-     * defaults to the full table state, which is correct for the common case of
-     * `createAppTable` without a selector.
      */
-    useTableContext: <TData extends RowData = RowData, TSelected = TableState<TFeatures>>() => AppSvelteTable<TFeatures, TData, TSelected, TTableComponents, TCellComponents, THeaderComponents>;
+    useTableContext: <TData extends RowData = RowData>() => AppSvelteTable<TFeatures, TData, TTableComponents, TCellComponents, THeaderComponents>;
     /**
      * Reads the cell provided by the nearest `<table.AppCell>`, extended with your
      * `cellComponents` and a context-bound `FlexRender`.

package/dist/createTableHook.svelte.js

@@ -109,10 +109,10 @@ export function createTableHook({ tableComponents, cellComponents, headerCompone
      *
      * TFeatures is already known from the createTableHook call; TData is inferred from the data prop.
      */
-    function createAppTable(tableOptions, selector) {
+    function createAppTable(tableOptions) {
         // Merge default options with provided options (provided takes precedence)
         const mergedTableOptions = mergeObjects(defaultTableOptions, tableOptions);
-        const table = createTable(mergedTableOptions, selector);
+        const table = createTable(mergedTableOptions);
         // Build cellComponents with FlexRender included
         const cellComponentsWithFlexRender = {
             FlexRender: FlexRenderSvelte,

package/dist/index.d.ts

@@ -5,5 +5,4 @@ export { createTableHook } from './createTableHook.svelte';
 export type { AppCellContext, AppColumnDefBase, AppColumnDefTemplate, AppColumnHelper, AppDisplayColumnDef, AppGroupColumnDef, AppHeaderContext, AppSvelteTable, ComponentType, CreateTableHookOptions, CreateTableHookResult, } from './createTableHook.svelte';
 export { createTableState } from './createTableState.svelte';
 export { default as FlexRender } from './FlexRender.svelte';
-export { subscribeTable, type SubscribeSource } from './subscribe';
 export { renderComponent, renderSnippet } from './render-component';

package/dist/index.js

@@ -3,5 +3,4 @@ export { createTable } from './createTable.svelte';
 export { createTableHook } from './createTableHook.svelte';
 export { createTableState } from './createTableState.svelte';
 export { default as FlexRender } from './FlexRender.svelte';
-export { subscribeTable } from './subscribe';
 export { renderComponent, renderSnippet } from './render-component';

package/dist/reactivity.svelte.d.ts

@@ -4,6 +4,8 @@ import type { TableReactivityBindings } from '@tanstack/table-core/reactivity';
  *
  * Table state atoms are backed by TanStack Store atoms. The options store stays
  * framework-native because row-model APIs read `table.options` directly during
- * render. Readonly table atoms bridge Store dependency tracking into `$derived.by`.
+ * render. Readonly table atoms bridge Store dependency tracking into
+ * `$derived.by`, so their `.get()` methods participate in Svelte dependency
+ * tracking when called in templates, `$derived`, or `$effect`.
  */
 export declare function svelteReactivity(): TableReactivityBindings;

package/dist/reactivity.svelte.js

@@ -36,7 +36,9 @@ function createRuneWritableAtom(initialValue) {
  *
  * Table state atoms are backed by TanStack Store atoms. The options store stays
  * framework-native because row-model APIs read `table.options` directly during
- * render. Readonly table atoms bridge Store dependency tracking into `$derived.by`.
+ * render. Readonly table atoms bridge Store dependency tracking into
+ * `$derived.by`, so their `.get()` methods participate in Svelte dependency
+ * tracking when called in templates, `$derived`, or `$effect`.
  */
 export function svelteReactivity() {
     return {
@@ -66,6 +68,9 @@ export function svelteReactivity() {
             });
             return {
                 get: () => {
+                    // Both reads are load-bearing: the Store read preserves dependency
+                    // tracking between table atoms, while touching `value` registers the
+                    // current Svelte reactive scope with the rune-backed bridge.
                     const currentValue = storeAtom.get();
                     value;
                     return currentValue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/svelte-table",
-  "version": "9.0.0-beta.59",
+  "version": "9.0.0-beta.60",
   "description": "Headless UI for building powerful tables & datagrids for Svelte.",
   "author": "Tanner Linsley",
   "license": "MIT",

package/skills/create-table-hook/SKILL.md

@@ -6,7 +6,7 @@ metadata:
   type: framework
   library: '@tanstack/svelte-table'
   framework: svelte
-  library_version: '9.0.0-beta.59'
+  library_version: '9.0.0-beta.60'
 requires:
   - '@tanstack/table-core#core'
   - getting-started

package/skills/getting-started/SKILL.md

@@ -6,7 +6,7 @@ metadata:
   type: framework
   library: '@tanstack/svelte-table'
   framework: svelte
-  library_version: '9.0.0-beta.59'
+  library_version: '9.0.0-beta.60'
 requires:
   - '@tanstack/table-core#core'
   - '@tanstack/table-core#table-features'

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

@@ -1,12 +1,12 @@
 ---
 name: migrate-v8-to-v9
 description: >
-  Complete Svelte v8-to-v9 migration reference: Svelte 5, createTable, explicit features and row-model slots, atom/rune state, rendering helpers, prototype methods, type generics, sorting, sizing, selection, and logical pinning.
+  Complete Svelte v8-to-v9 migration reference: Svelte 5, createTable, beta.59 selector removal, explicit features and row-model slots, atom/rune state, rendering helpers, prototype methods, type generics, sorting, sizing, selection, and logical pinning.
 metadata:
   type: lifecycle
   library: '@tanstack/svelte-table'
   framework: svelte
-  library_version: '9.0.0-beta.59'
+  library_version: '9.0.0-beta.60'
 requires:
   - '@tanstack/table-core#migrate-v8-to-v9'
   - getting-started
@@ -50,7 +50,7 @@ const table = createTable({
 
 | v8                                           | v9                                                         |
 | -------------------------------------------- | ---------------------------------------------------------- |
-| `createSvelteTable(options)`                 | `createTable(options, selector?)`                          |
+| `createSvelteTable(options)`                 | `createTable(options)`                                     |
 | All features bundled                         | Required `features: tableFeatures({...})`                  |
 | `getCoreRowModel()` option                   | Remove; the core row model is automatic                    |
 | `get*RowModel()` table options               | `create*RowModel()` slots in `tableFeatures`               |
@@ -78,9 +78,10 @@ Factories take no arguments. Register `filterFns`, `sortFns`, and `aggregationFn
 ## Svelte State Migration
 
 - Reactive option inputs must remain live: use getters for rune values such as `data` and controlled state slices.
-- `table.getState().sorting` becomes `table.state.sorting`, `table.store.state.sorting`, or the narrow `table.atoms.sorting.get()`.
-- `table.state` contains all registered state by default. Pass a second-argument selector to `createTable` only to narrow its reactive surface.
-- `subscribeTable(table.atoms.pagination, selector?)` exposes `.current` for fine-grained template subscriptions.
+- `table.getState().sorting` becomes the narrow `table.atoms.sorting.get()` read. Use `table.store.get()` when code intentionally needs the complete state.
+- Table atom, store, and API reads become reactive inside templates, `$derived`, `$derived.by`, and `$effect`; use native `$derived` values for projections.
+- Starting in beta.59, remove second-argument selectors from `createTable` and `createAppTable`, replace `table.state`, and remove `subscribeTable` / `SubscribeSource` imports.
+- `SvelteTable` now has two generic parameters, `AppSvelteTable` has five, and `useTableContext` no longer accepts a selected-state generic.
 - For Svelte-owned controlled slices, use `createTableState` and matching `onSortingChange`, `onPaginationChange`, and other per-slice callbacks.
 - For shared ownership, provide atoms created by `@tanstack/svelte-store` through `atoms`. Never provide both `atoms.pagination` and `state.pagination`.
 - Subscribe to `table.store` to observe every state change. Do not port the removed top-level `onStateChange`.
@@ -173,6 +174,10 @@ Register both the feature and its `create*RowModel()` slot. Leaving `get*RowMode
 
 Use `get data() { return data }`; a one-time `data` snapshot does not remain reactive.
 
+### HIGH: Keeping beta.58 Svelte selectors
+
+Remove second arguments from `createTable` and `createAppTable`, replace selected `table.state` reads with `table.atoms.<slice>.get()` or `table.store.get()`, and remove `subscribeTable`, `SubscribeSource`, and selected-state generic parameters. Beta.59 intentionally has no compatibility layer for these APIs.
+
 ### HIGH: Destructuring instance methods
 
 Keep calls bound to row/cell/column/header instances; shallow copies do not contain prototype methods.
@@ -184,6 +189,7 @@ Keep calls bound to row/cell/column/header instances; shallow copies do not cont
 - [ ] Explicit features, row models, and function registries are in `tableFeatures`.
 - [ ] `getCoreRowModel` and the separate `rowModels` shape are removed.
 - [ ] Reactive inputs and controlled slices use getters/runes; state reads use v9 surfaces.
+- [ ] Svelte creation selectors, `table.state`, `subscribeTable`, `SubscribeSource`, and selected-state generic parameters are removed.
 - [ ] `onStateChange` is replaced; atom/state ownership does not overlap.
 - [ ] Rendering uses `FlexRender`, `renderComponent`, or `renderSnippet`.
 - [ ] Prototype method calls, pinning, sizing/resizing, sorting, row, and selection semantics are audited.

package/skills/table-state/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: table-state
 description: >
-  Use Svelte 5 rune-backed table.atoms/store and selected table.state, reactive option getters, controlled $state slices, value-or-updater callbacks, external atoms, and auto-reset behavior without snapshot mismatches.
+  Use Svelte 5 rune-aware table atoms and stores, $derived projections, reactive option getters, controlled $state or createTableState slices, external atoms, and auto-reset behavior without broad invalidation or snapshot mismatches.
 metadata:
   type: framework
   library: '@tanstack/svelte-table'
   framework: svelte
-  library_version: '9.0.0-beta.59'
+  library_version: '9.0.0-beta.60'
 requires:
   - '@tanstack/table-core#core'
   - getting-started
@@ -15,6 +15,7 @@ sources:
   - 'TanStack/table:docs/framework/svelte/guide/pagination.md'
   - 'TanStack/table:examples/svelte/basic-external-state'
   - 'TanStack/table:packages/svelte-table/src/createTable.svelte.ts'
+  - 'TanStack/table:packages/svelte-table/src/createTableState.svelte.ts'
 ---
 
 This skill builds on `@tanstack/table-core#core` and `getting-started`. Read them first for table ownership and Svelte construction.
@@ -26,13 +27,14 @@ TanStack Table is primarily a state coordinator. Keep state internal unless anot
 - `table.baseAtoms` are internal writable atoms initialized from resolved initial state.
 - `table.atoms` are readonly derived atoms for the active owner of each registered slice.
 - `table.store` is the readonly flat store assembled from those atoms.
-- `table.state` is only the result selected by the second `createTable` argument.
 
-Svelte 5 backs these surfaces with runes and synchronizes reactive options before DOM updates. Only registered features create state and types. If pagination is missing, register `rowPaginationFeature`; do not add a cast or an ad hoc state field. Keep `features` and `columns` stable and pass changing `data` through a getter.
+The Svelte adapter bridges TanStack Store dependency tracking into Svelte runes. `table.atoms.<slice>.get()`, `table.store.get()`, and table APIs become reactive when called in a template, `$derived`, `$derived.by`, or `$effect`. Outside those contexts they return current snapshots.
+
+Only registered features create state and types. If pagination is missing, register `rowPaginationFeature`; do not add a cast or ad hoc state field. Keep `features` and `columns` stable and pass changing `data` through a getter.
 
 ## Setup
 
-Keep state internal unless another subsystem needs to own it. Select only render state that the component needs.
+Keep state internal unless another subsystem needs to own it. Read only the state slices a component needs.
 
 ```svelte
 <script lang="ts">
@@ -45,25 +47,36 @@ Keep state internal unless another subsystem needs to own it. Select only render
   const features = tableFeatures({ rowPaginationFeature })
   const columns = [{ accessorKey: 'name' }]
   let data = $state([{ name: 'Ada' }])
-  const table = createTable(
-    {
-      features,
-      columns,
-      get data() {
-        return data
-      },
+
+  const table = createTable({
+    features,
+    columns,
+    get data() {
+      return data
     },
-    (state) => ({ pagination: state.pagination }),
-  )
+  })
+
+  const pagination = $derived(table.atoms.pagination.get())
 </script>
 
 <button onclick={() => table.nextPage()} disabled={!table.getCanNextPage()}>
-  Page {table.state.pagination.pageIndex + 1}
+  Page {pagination.pageIndex + 1}
 </button>
 ```
 
 ## Core Patterns
 
+### Read narrow or complete state
+
+```ts
+const pagination = $derived(table.atoms.pagination.get())
+const pageIndex = $derived(table.atoms.pagination.get().pageIndex)
+const rows = $derived(table.getRowModel().rows)
+const stateJson = $derived(JSON.stringify(table.store.get(), null, 2))
+```
+
+Use atom reads for normal UI. A `table.store.get()` read intentionally re-runs for any registered state change, so reserve it for debug output, persistence, or computations that need the whole state.
+
 ### Control a slice with value-or-updater semantics
 
 ```ts
@@ -75,20 +88,41 @@ const updatePagination = (next: Updater<PaginationState>) => {
 }
 ```
 
-Pass `get state() { return { pagination } }` and `onPaginationChange: updatePagination` to `createTable`.
+Pass a getter-backed `state.pagination` and `onPaginationChange: updatePagination` to `createTable`.
 
-### Subscribe narrowly outside selected table.state
+### Reduce boilerplate with `createTableState`
 
 ```ts
-import { subscribeTable } from '@tanstack/svelte-table'
-
-const pageIndex = subscribeTable(
-  table.atoms.pagination,
-  (value) => value.pageIndex,
-)
+import {
+  createTable,
+  createTableState,
+  rowPaginationFeature,
+  tableFeatures,
+  type PaginationState,
+} from '@tanstack/svelte-table'
+
+const features = tableFeatures({ rowPaginationFeature })
+const columns = [{ accessorKey: 'name' }]
+const data = [{ name: 'Ada' }]
+const [pagination, setPagination] = createTableState<PaginationState>({
+  pageIndex: 0,
+  pageSize: 20,
+})
+
+const table = createTable({
+  features,
+  columns,
+  data,
+  state: {
+    get pagination() {
+      return pagination()
+    },
+  },
+  onPaginationChange: setPagination,
+})
 ```
 
-Read `pageIndex.current` in rune-tracked Svelte code. Use feature APIs for writes; `baseAtoms` is a low-level escape hatch.
+For better or worse, this resembles a small React `useState` hook: `pagination()` reads the current rune-backed value, while `setPagination` accepts either a value or a functional updater and can be passed directly to `onPaginationChange`.
 
 ## Choose State Ownership
 
@@ -96,10 +130,12 @@ Use one owner per slice:
 
 - Prefer internal state plus feature APIs for table-local interaction.
 - Use `initialState` for starting/reset values; changing it later does not reset state.
-- Prefer a stable external atom in `atoms` for state shared with Query, routing, or another component. Do not also add its change callback.
-- Use a `$state` value exposed through a `state` getter plus the matching callback for simple controlled state. Always resolve value-or-updater semantics.
+- Use Svelte `$state`, a getter-backed `state` entry, and the matching callback for normal Svelte-owned controlled state.
+- Use a stable external atom in `atoms` for state shared as a raw TanStack Store atom. Do not also add its change callback.
 
-External atoms win over controlled `state`, which syncs into the internal base atom. Avoid multiple owners. The global v8 `onStateChange` option is gone; subscribe to `table.store` if all state changes must be observed.
+External atoms win over controlled `state`, which syncs into the internal base atom. Avoid multiple owners. The global v8 `onStateChange` option is gone; subscribe to `table.store` if every state change must be observed imperatively.
+
+When code outside the table consumes a raw external atom, use `useSelector` from `@tanstack/svelte-store`. Inside table-driven UI, read the rune-aware `table.atoms.<slice>.get()` wrapper.
 
 ## Initialize, Update, and Reset
 
@@ -115,6 +151,26 @@ Feature resets use `table.initialState` unless `true` requests the feature defau
 
 ## Common Mistakes
 
+### HIGH Keeping removed adapter selectors
+
+Wrong:
+
+```ts
+const table = createTable(options, (state) => state.pagination)
+const pageIndex = table.state.pageIndex
+```
+
+Correct:
+
+```ts
+const table = createTable(options)
+const pagination = $derived(table.atoms.pagination.get())
+```
+
+Starting in beta.59, `createTable` and `createAppTable` take only options, `table.state` is absent, and `subscribeTable` and `SubscribeSource` are no longer exported. Use native tracked Svelte reads and `$derived` projections.
+
+Source: `docs/framework/svelte/guide/migrating.md`
+
 ### HIGH Controlling without writing back
 
 Wrong:
@@ -127,8 +183,10 @@ Correct:
 
 ```ts
 const options = {
-  get state() {
-    return { pagination }
+  state: {
+    get pagination() {
+      return pagination
+    },
   },
   onPaginationChange: updatePagination,
 }
@@ -138,24 +196,21 @@ A controlled slice is frozen unless every updater is resolved into the owning ru
 
 Source: `docs/framework/svelte/guide/table-state.md`
 
-### HIGH Reading snapshots outside tracking
+### HIGH Snapshotting outside tracking
 
 Wrong:
 
 ```ts
-const pageIndex = table.store.state.pagination.pageIndex
+const pageIndex = table.store.get().pagination.pageIndex
 ```
 
-Correct:
+Correct inside a component:
 
 ```ts
-const pageIndex = subscribeTable(
-  table.atoms.pagination,
-  (value) => value.pageIndex,
-)
+const pageIndex = $derived(table.atoms.pagination.get().pageIndex)
 ```
 
-`store.state` is a current snapshot; it does not create a future Svelte update outside a tracked scope.
+The first line is only a current snapshot when it runs outside a template or rune. The second line is a narrow native Svelte derivation.
 
 Source: `packages/svelte-table/src/createTable.svelte.ts`
 
@@ -171,8 +226,10 @@ Correct:
 
 ```ts
 const options = {
-  get state() {
-    return { pagination }
+  state: {
+    get pagination() {
+      return pagination
+    },
   },
 }
 ```
@@ -202,4 +259,4 @@ Source: `docs/framework/svelte/guide/pagination.md`
 
 ## API Discovery
 
-Inspect `node_modules/@tanstack/svelte-table/dist/createTable.svelte.d.ts`, `createTableState.svelte.d.ts`, and `subscribe.d.ts`; inspect registered state slices in the matching core feature source.
+Inspect `node_modules/@tanstack/svelte-table/dist/createTable.svelte.d.ts`, `createTableHook.svelte.d.ts`, and `createTableState.svelte.d.ts`; inspect registered state slices in the matching core feature source.

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

@@ -6,7 +6,7 @@ metadata:
   type: composition
   library: '@tanstack/svelte-table'
   framework: svelte
-  library_version: '9.0.0-beta.59'
+  library_version: '9.0.0-beta.60'
 requires:
   - '@tanstack/table-core#client-vs-server'
   - getting-started
@@ -52,8 +52,10 @@ const table = createTable({
     return dataQuery.data?.rowCount ?? 0
   },
   manualPagination: true,
-  get state() {
-    return { pagination }
+  state: {
+    get pagination() {
+      return pagination
+    },
   },
   onPaginationChange: (next) => {
     pagination = typeof next === 'function' ? next(pagination) : next

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

@@ -6,7 +6,7 @@ metadata:
   type: composition
   library: '@tanstack/svelte-table'
   framework: svelte
-  library_version: '9.0.0-beta.59'
+  library_version: '9.0.0-beta.60'
 requires:
   - '@tanstack/table-core#core'
   - getting-started

package/dist/subscribe.d.ts

@@ -1,24 +0,0 @@
-import { useSelector } from '@tanstack/svelte-store';
-import type { Atom, ReadonlyAtom, ReadonlyStore, Store } from '@tanstack/svelte-store';
-export type SubscribeSource<TValue> = Atom<TValue> | ReadonlyAtom<TValue> | Store<TValue> | ReadonlyStore<TValue>;
-/**
- * Creates a fine-grained Svelte subscription to a TanStack Store source.
- *
- * Pass a table atom or store and optionally project it with a selector. The
- * returned selector store exposes `.current`, making it useful for reading
- * focused table state outside the broad `createTable` selector.
- *
- * @example
- * ```svelte
- * <script lang="ts">
- *   const selected = subscribeTable(
- *     table.atoms.rowSelection,
- *     (rowSelection) => rowSelection[row.id],
- *   )
- * </script>
- *
- * <input type="checkbox" checked={!!selected.current} />
- * ```
- */
-export declare function subscribeTable<TSourceValue>(source: SubscribeSource<TSourceValue>): ReturnType<typeof useSelector<TSourceValue>>;
-export declare function subscribeTable<TSourceValue, TSelected>(source: SubscribeSource<TSourceValue>, selector: (state: TSourceValue) => TSelected): ReturnType<typeof useSelector<TSourceValue, TSelected>>;

package/dist/subscribe.js

@@ -1,4 +0,0 @@
-import { shallow, useSelector } from '@tanstack/svelte-store';
-export function subscribeTable(source, selector) {
-    return useSelector(source, selector, { compare: shallow });
-}