@tanstack/svelte-table 9.0.0-beta.7 → 9.0.0-beta.71

package/README.md

@@ -35,14 +35,18 @@
 >
 > - [Angular Table](https://tanstack.com/table/alpha/docs/framework/angular/angular-table)
 > - [Lit Table](https://tanstack.com/table/alpha/docs/framework/lit/lit-table)
+> - [Octane Table](https://tanstack.com/table/beta/docs/framework/octane/quick-start)
+> - [Preact Table](https://tanstack.com/table/beta/docs/framework/preact/quick-start)
 > - [React Table](https://tanstack.com/table/alpha/docs/framework/react/react-table)
 > - [Solid Table](https://tanstack.com/table/alpha/docs/framework/solid/solid-table)
 > - [Svelte Table](https://tanstack.com/table/alpha/docs/framework/svelte/svelte-table)
 > - [Vue Table](https://tanstack.com/table/alpha/docs/framework/vue/vue-table)
+> - [Alpine Table](https://tanstack.com/table/alpha/docs/framework/alpine/alpine-table)
+> - [Ember Table](https://tanstack.com/table/alpha/docs/framework/ember/ember-table)
 
 A headless table library for building powerful datagrids with full control over markup, styles, and behavior.
 
-- Framework‑agnostic core with bindings for React, Vue & Solid
+- Framework-agnostic core with bindings for React, Preact, Octane, Vue, Solid, Svelte, Angular, Ember, Lit, and Alpine
 - 100% customizable — bring your own UI, components, and styles
 - Sorting, filtering, grouping, aggregation & row selection
 - Lightweight, virtualizable & server‑side friendly

package/dist/FlexRender.svelte

@@ -61,8 +61,22 @@
   // or the legacy content/context props.
   const resolved = $derived.by(() => {
     if ('cell' in props && props.cell) {
+      const columnDef = props.cell.column.columnDef
+      const groupingCell = props.cell as typeof props.cell & {
+        getIsAggregated?: () => boolean
+        getIsPlaceholder?: () => boolean
+      }
+      const groupingColumnDef = columnDef as typeof columnDef & {
+        aggregatedCell?: typeof columnDef.cell
+      }
+      const content = groupingCell.getIsAggregated?.()
+        ? (groupingColumnDef.aggregatedCell ?? columnDef.cell)
+        : groupingCell.getIsPlaceholder?.()
+          ? undefined
+          : columnDef.cell
+
       return {
-        content: props.cell.column.columnDef.cell,
+        content,
         context: props.cell.getContext(),
       }
     }

package/dist/createTable.svelte.d.ts

@@ -1,48 +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,
- *       rowModels: {},
- *       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,38 +1,41 @@
 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,
- *       rowModels: {},
- *       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: {
-            coreReativityFeature: svelteReactivity(),
+            coreReactivityFeature: svelteReactivity(),
             ...tableOptions.features,
         },
     });
@@ -48,32 +51,24 @@ export function createTable(tableOptions, selector) {
     // inside createTableState), the effect re-runs and calls setOptions.
     // Use $effect.pre so the table sees updated options BEFORE the DOM renders,
     // ensuring getRowModel() returns current data (not stale, one-frame-behind data).
-    // The reactive reads (state getters, data getter) happen OUTSIDE untrack
-    // so they become dependencies. The setOptions call is INSIDE untrack so
-    // option writes do not subscribe this effect to table internals.
+    // Reactive option getters and nested state keys are read OUTSIDE untrack so
+    // they become dependencies. The setOptions call is INSIDE untrack so option
+    // writes do not subscribe this effect to table internals.
     $effect.pre(() => {
-        // Read reactive getters to create $effect dependencies on external state
-        const state = mergedOptions.state;
+        // Resolve every option outside untrack so getter-backed data, columns,
+        // callbacks, metadata, and state become dependencies of this effect.
+        const nextOptions = flatMerge(mergedOptions);
+        const state = nextOptions.state;
         if (state) {
             for (const key in state) {
                 void state[key];
             }
         }
-        void mergedOptions.data;
         untrack(() => {
             table.setOptions((prev) => {
-                return flatMerge(prev, mergedOptions);
+                return flatMerge(prev, nextOptions);
             });
         });
     });
-    // 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.
@@ -55,7 +55,7 @@ export type AppGroupColumnDef<TFeatures extends TableFeatures, TData extends Row
     cell?: AppColumnDefTemplate<AppCellContext<TFeatures, TData, unknown, TCellComponents>>;
     header?: AppColumnDefTemplate<AppHeaderContext<TFeatures, TData, unknown, THeaderComponents>>;
     footer?: AppColumnDefTemplate<AppHeaderContext<TFeatures, TData, unknown, THeaderComponents>>;
-    columns?: Array<ColumnDef<TFeatures, TData, unknown>>;
+    columns?: ReadonlyArray<ColumnDef<TFeatures, TData, unknown>>;
 };
 /**
  * Enhanced column helper with pre-bound components in cell/header/footer contexts.
@@ -66,7 +66,7 @@ export type AppColumnHelper<TFeatures extends TableFeatures, TData extends RowDa
      * Creates a data column definition with an accessor key or function.
      * The cell, header, and footer contexts include pre-bound components.
      */
-    accessor: <TAccessor extends AccessorFn<TData> | DeepKeys<TData>, TValue extends TAccessor extends AccessorFn<TData, infer TReturn> ? TReturn : TAccessor extends DeepKeys<TData> ? DeepValue<TData, TAccessor> : never>(accessor: TAccessor, column: TAccessor extends AccessorFn<TData> ? AppColumnDefBase<TFeatures, TData, TValue, TCellComponents, THeaderComponents> & {
+    accessor: <TAccessor extends AccessorFn<TData> | DeepKeys<TData>, TValue extends (TAccessor extends AccessorFn<TData, infer TReturn> ? TReturn : TAccessor extends DeepKeys<TData> ? DeepValue<TData, TAccessor> : never)>(accessor: TAccessor, column: TAccessor extends AccessorFn<TData> ? AppColumnDefBase<TFeatures, TData, TValue, TCellComponents, THeaderComponents> & {
         id: string;
     } : AppColumnDefBase<TFeatures, TData, TValue, TCellComponents, THeaderComponents>) => TAccessor extends AccessorFn<TData> ? AccessorFnColumnDef<TFeatures, TData, TValue> : AccessorKeyColumnDef<TFeatures, TData, TValue>;
     /**
@@ -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
@@ -189,6 +190,45 @@ export type AppSvelteTable<TFeatures extends TableFeatures, TData extends RowDat
      */
     FlexRender: typeof FlexRenderSvelte;
 };
+export interface CreateTableHookResult<TFeatures extends TableFeatures, TTableComponents extends Record<string, ComponentType<any>>, TCellComponents extends Record<string, ComponentType<any>>, THeaderComponents extends Record<string, ComponentType<any>>> {
+    /** The features object that was passed to `createTableHook`. */
+    appFeatures: TFeatures;
+    /**
+     * A column helper pre-bound to `TFeatures` and the registered components, so
+     * the cell/header/footer render props expose the bound components.
+     */
+    createAppColumnHelper: <TData extends RowData>() => AppColumnHelper<TFeatures, TData, TCellComponents, THeaderComponents>;
+    /**
+     * 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>(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.
+     */
+    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`.
+     */
+    useCellContext: <TValue extends CellData = CellData>() => Cell<TFeatures, any, TValue> & TCellComponents & {
+        FlexRender: typeof FlexRenderSvelte;
+    };
+    /**
+     * Reads the header provided by the nearest `<table.AppHeader>` /
+     * `<table.AppFooter>`, extended with your `headerComponents` and a
+     * context-bound `FlexRender`.
+     */
+    useHeaderContext: <TValue extends CellData = CellData>() => Header<TFeatures, any, TValue> & THeaderComponents & {
+        FlexRender: typeof FlexRenderSvelte;
+    };
+}
 /**
  * Creates a custom table hook with pre-bound components for composition.
  *
@@ -213,23 +253,16 @@ export type AppSvelteTable<TFeatures extends TableFeatures, TData extends RowDat
  *     rowPaginationFeature,
  *     rowSortingFeature,
  *     columnFilteringFeature,
- *   }),
- *   rowModels: {
  *     paginatedRowModel: createPaginatedRowModel(),
- *     sortedRowModel: createSortedRowModel(sortFns),
- *     filteredRowModel: createFilteredRowModel(filterFns),
- *   },
+ *     sortedRowModel: createSortedRowModel(),
+ *     filteredRowModel: createFilteredRowModel(),
+ *     sortFns,
+ *     filterFns,
+ *   }),
  *   tableComponents: { PaginationControls, RowCount },
  *   cellComponents: { TextCell, NumberCell },
  *   headerComponents: { SortIndicator, ColumnFilter },
  * })
  * ```
  */
-export declare function createTableHook<TFeatures extends TableFeatures, const TTableComponents extends Record<string, ComponentType<any>>, const TCellComponents extends Record<string, ComponentType<any>>, const THeaderComponents extends Record<string, ComponentType<any>>>({ tableComponents, cellComponents, headerComponents, ...defaultTableOptions }: CreateTableHookOptions<TFeatures, TTableComponents, TCellComponents, THeaderComponents>): {
-    appFeatures: TFeatures;
-    createAppColumnHelper: <TData extends RowData>() => AppColumnHelper<TFeatures, TData, TCellComponents, THeaderComponents>;
-    createAppTable: <TData extends RowData, TSelected = TableState<TFeatures>>(tableOptions: Omit<TableOptions<TFeatures, TData>, "features" | "rowModels">, selector?: (state: TableState<TFeatures>) => TSelected) => AppSvelteTable<TFeatures, TData, TSelected, TTableComponents, TCellComponents, THeaderComponents>;
-    useTableContext: <TData extends RowData = RowData>() => SvelteTable<TFeatures, TData>;
-    useCellContext: <TValue extends CellData = unknown>() => Cell<TFeatures, any, TValue>;
-    useHeaderContext: <TValue extends CellData = unknown>() => Header<TFeatures, any, TValue>;
-};
+export declare function createTableHook<TFeatures extends TableFeatures, const TTableComponents extends Record<string, ComponentType<any>>, const TCellComponents extends Record<string, ComponentType<any>>, const THeaderComponents extends Record<string, ComponentType<any>>>({ tableComponents, cellComponents, headerComponents, ...defaultTableOptions }: CreateTableHookOptions<TFeatures, TTableComponents, TCellComponents, THeaderComponents>): CreateTableHookResult<TFeatures, TTableComponents, TCellComponents, THeaderComponents>;

package/dist/createTableHook.svelte.js

@@ -34,12 +34,12 @@ import FlexRenderSvelte from './FlexRender.svelte';
  *     rowPaginationFeature,
  *     rowSortingFeature,
  *     columnFilteringFeature,
- *   }),
- *   rowModels: {
  *     paginatedRowModel: createPaginatedRowModel(),
- *     sortedRowModel: createSortedRowModel(sortFns),
- *     filteredRowModel: createFilteredRowModel(filterFns),
- *   },
+ *     sortedRowModel: createSortedRowModel(),
+ *     filteredRowModel: createFilteredRowModel(),
+ *     sortFns,
+ *     filterFns,
+ *   }),
  *   tableComponents: { PaginationControls, RowCount },
  *   cellComponents: { TextCell, NumberCell },
  *   headerComponents: { SortIndicator, ColumnFilter },
@@ -65,6 +65,9 @@ export function createTableHook({ tableComponents, cellComponents, headerCompone
             throw new Error('`useTableContext` must be used within an `AppTable` component. ' +
                 'Make sure your component is wrapped with `<table.AppTable>...</table.AppTable>`.');
         }
+        // `<table.AppTable>` provides the extended table (the App* wrapper
+        // components and `tableComponents` are Object.assign-ed onto the same
+        // instance `createAppTable` returns), so this asserts the runtime shape.
         return table;
     }
     /**
@@ -78,6 +81,9 @@ export function createTableHook({ tableComponents, cellComponents, headerCompone
             throw new Error('`useCellContext` must be used within an `AppCell` component. ' +
                 'Make sure your component is wrapped with `<table.AppCell cell={cell}>...</table.AppCell>`.');
         }
+        // `<table.AppCell>` Object.assign-es `cellComponents` and `FlexRender` onto
+        // the same cell instance it puts in context, so this asserts the runtime
+        // shape.
         return cell;
     }
     /**
@@ -90,6 +96,8 @@ export function createTableHook({ tableComponents, cellComponents, headerCompone
         if (!header) {
             throw new Error('`useHeaderContext` must be used within an `AppHeader` or `AppFooter` component.');
         }
+        // `<table.AppHeader>` / `<table.AppFooter>` Object.assign `headerComponents`
+        // and `FlexRender` onto the same header instance they put in context.
         return header;
     }
     /**
@@ -101,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,
@@ -124,7 +132,7 @@ export function createTableHook({ tableComponents, cellComponents, headerCompone
             setContext(tableContextKey, table);
             return AppTableSvelte(internal, { ...props });
         });
-        const AppCell = ((internal, { children, cell, ...rest }) => {
+        const AppCell = ((internal, { children, cell }) => {
             setContext(cellContextKey, cell);
             return AppCellSvelte(internal, {
                 cell,
@@ -132,7 +140,7 @@ export function createTableHook({ tableComponents, cellComponents, headerCompone
                 children,
             });
         });
-        const AppHeader = ((internal, { children, header, ...rest }) => {
+        const AppHeader = ((internal, { children, header }) => {
             setContext(headerContextKey, header);
             return AppHeaderSvelte(internal, {
                 header,
@@ -141,7 +149,7 @@ export function createTableHook({ tableComponents, cellComponents, headerCompone
             });
         });
         // AppFooter reuses AppHeaderSvelte (footers use Header type in table-core)
-        const AppFooter = ((internal, { children, header, ...rest }) => {
+        const AppFooter = ((internal, { children, header }) => {
             setContext(headerContextKey, header);
             return AppHeaderSvelte(internal, {
                 header,

package/dist/experimental-worker-plugin.d.ts

@@ -0,0 +1 @@
+export * from '@tanstack/table-core/experimental-worker-plugin';

package/dist/experimental-worker-plugin.js

@@ -0,0 +1 @@
+export * from '@tanstack/table-core/experimental-worker-plugin';

package/dist/index.d.ts

@@ -2,8 +2,7 @@ export * from '@tanstack/table-core';
 export { createTable } from './createTable.svelte';
 export type { SvelteTable } from './createTable.svelte';
 export { createTableHook } from './createTableHook.svelte';
-export type { AppCellContext, AppColumnDefBase, AppColumnDefTemplate, AppColumnHelper, AppDisplayColumnDef, AppGroupColumnDef, AppHeaderContext, AppSvelteTable, ComponentType, CreateTableHookOptions, } 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/dist/render-component.js

@@ -15,6 +15,8 @@
  * ```
  * */
 export class RenderComponentConfig {
+    component;
+    props;
     constructor(component, props) {
         this.component = component;
         this.props = props;
@@ -36,6 +38,8 @@ export class RenderComponentConfig {
  * ```
  * */
 export class RenderSnippetConfig {
+    snippet;
+    params;
     constructor(snippet, params) {
         this.snippet = snippet;
         this.params = params;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/svelte-table",
-  "version": "9.0.0-beta.7",
+  "version": "9.0.0-beta.71",
   "description": "Headless UI for building powerful tables & datagrids for Svelte.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -36,6 +36,11 @@
       "svelte": "./dist/static-functions.js",
       "import": "./dist/static-functions.js"
     },
+    "./experimental-worker-plugin": {
+      "types": "./dist/experimental-worker-plugin.d.ts",
+      "svelte": "./dist/experimental-worker-plugin.js",
+      "import": "./dist/experimental-worker-plugin.js"
+    },
     "./flex-render": {
       "types": "./dist/flex-render.d.ts",
       "svelte": "./dist/flex-render.js",
@@ -44,30 +49,32 @@
     "./package.json": "./package.json"
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=20"
   },
   "files": [
     "dist",
-    "src",
     "skills"
   ],
   "dependencies": {
     "@tanstack/svelte-store": "^0.12.0",
-    "@tanstack/table-core": "9.0.0-beta.7"
+    "@tanstack/table-core": "9.0.0-beta.71"
   },
   "devDependencies": {
     "@sveltejs/package": "^2.5.8",
-    "@sveltejs/vite-plugin-svelte": "^7.1.2",
-    "eslint-plugin-svelte": "^3.19.0",
-    "svelte": "^5.56.2",
-    "svelte-check": "^4.6.0"
+    "@sveltejs/vite-plugin-svelte": "^7.2.0",
+    "@testing-library/svelte": "^5.4.2",
+    "eslint-plugin-svelte": "^3.22.0",
+    "svelte": "^5.56.8",
+    "svelte-check": "^4.7.4"
   },
   "peerDependencies": {
     "svelte": "^5.0.0"
   },
   "scripts": {
     "clean": "rimraf ./build && rimraf ./dist",
-    "test:eslint": "eslint ./src",
+    "test:eslint": "eslint ./src ./tests",
+    "test:lib": "vitest --passWithNoTests",
+    "test:lib:dev": "pnpm test:lib --watch",
     "test:types": "svelte-check --tsconfig ./tsconfig.json",
     "test:build": "publint --strict",
     "build": "svelte-package --input ./src --output ./dist"