@tanstack/table-core 9.0.0-alpha.41 → 9.0.0-alpha.43

package/dist/store-reactivity-bindings.cjs

@@ -0,0 +1,36 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _tanstack_store = require("@tanstack/store");
+
+//#region src/store-reactivity-bindings.ts
+/**
+* TanStack Store–based reactivity for vanilla / non-framework use of `constructTable`,
+* with `createOptionsStore: true` so `table.optionsStore` is available for subscriptions.
+*
+* @example
+* ```ts
+* import { constructTable, tableFeatures } from '@tanstack/table-core'
+* import { storeReactivityBindings } from '@tanstack/table-core/store-reactivity-bindings'
+*
+* const table = constructTable({
+*   _features: tableFeatures({ coreReativityFeature: storeReactivityBindings() }),
+*   // ...
+* })
+* ```
+*/
+function storeReactivityBindings() {
+	return {
+		createOptionsStore: true,
+		batch: _tanstack_store.batch,
+		untrack: (fn) => fn(),
+		createReadonlyAtom: (fn, options) => {
+			return (0, _tanstack_store.createAtom)(() => fn(), { compare: options === null || options === void 0 ? void 0 : options.compare });
+		},
+		createWritableAtom: (value, options) => {
+			return (0, _tanstack_store.createAtom)(value, { compare: options === null || options === void 0 ? void 0 : options.compare });
+		}
+	};
+}
+
+//#endregion
+exports.storeReactivityBindings = storeReactivityBindings;
+//# sourceMappingURL=store-reactivity-bindings.cjs.map

package/dist/store-reactivity-bindings.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-reactivity-bindings.cjs","names":[],"sources":["../src/store-reactivity-bindings.ts"],"sourcesContent":["import { batch, createAtom } from '@tanstack/store'\nimport type { TableReactivityBindings } from './core/reactivity/coreReactivityFeature.types'\n\n/**\n * TanStack Store–based reactivity for vanilla / non-framework use of `constructTable`,\n * with `createOptionsStore: true` so `table.optionsStore` is available for subscriptions.\n *\n * @example\n * ```ts\n * import { constructTable, tableFeatures } from '@tanstack/table-core'\n * import { storeReactivityBindings } from '@tanstack/table-core/store-reactivity-bindings'\n *\n * const table = constructTable({\n *   _features: tableFeatures({ coreReativityFeature: storeReactivityBindings() }),\n *   // ...\n * })\n * ```\n */\nexport function storeReactivityBindings(): TableReactivityBindings {\n  return {\n    createOptionsStore: true,\n    batch,\n    untrack: (fn) => fn(),\n    createReadonlyAtom: (fn, options) => {\n      return createAtom(() => fn(), {\n        compare: options?.compare,\n      })\n    },\n    createWritableAtom: (value, options) => {\n      return createAtom(value, {\n        compare: options?.compare,\n      })\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkBA,SAAgB,0BAAmD;AACjE,QAAO;EACL,oBAAoB;EACpB;EACA,UAAU,OAAO,IAAI;EACrB,qBAAqB,IAAI,YAAY;AACnC,gDAAwB,IAAI,EAAE,EAC5B,2DAAS,QAAS,SACnB,CAAC;;EAEJ,qBAAqB,OAAO,YAAY;AACtC,0CAAkB,OAAO,EACvB,2DAAS,QAAS,SACnB,CAAC;;EAEL"}

package/dist/store-reactivity-bindings.d.cts

@@ -0,0 +1,22 @@
+import { TableReactivityBindings } from "./core/reactivity/coreReactivityFeature.types.cjs";
+
+//#region src/store-reactivity-bindings.d.ts
+/**
+ * TanStack Store–based reactivity for vanilla / non-framework use of `constructTable`,
+ * with `createOptionsStore: true` so `table.optionsStore` is available for subscriptions.
+ *
+ * @example
+ * ```ts
+ * import { constructTable, tableFeatures } from '@tanstack/table-core'
+ * import { storeReactivityBindings } from '@tanstack/table-core/store-reactivity-bindings'
+ *
+ * const table = constructTable({
+ *   _features: tableFeatures({ coreReativityFeature: storeReactivityBindings() }),
+ *   // ...
+ * })
+ * ```
+ */
+declare function storeReactivityBindings(): TableReactivityBindings;
+//#endregion
+export { storeReactivityBindings };
+//# sourceMappingURL=store-reactivity-bindings.d.cts.map

package/dist/store-reactivity-bindings.d.ts

@@ -0,0 +1,22 @@
+import { TableReactivityBindings } from "./core/reactivity/coreReactivityFeature.types.js";
+
+//#region src/store-reactivity-bindings.d.ts
+/**
+ * TanStack Store–based reactivity for vanilla / non-framework use of `constructTable`,
+ * with `createOptionsStore: true` so `table.optionsStore` is available for subscriptions.
+ *
+ * @example
+ * ```ts
+ * import { constructTable, tableFeatures } from '@tanstack/table-core'
+ * import { storeReactivityBindings } from '@tanstack/table-core/store-reactivity-bindings'
+ *
+ * const table = constructTable({
+ *   _features: tableFeatures({ coreReativityFeature: storeReactivityBindings() }),
+ *   // ...
+ * })
+ * ```
+ */
+declare function storeReactivityBindings(): TableReactivityBindings;
+//#endregion
+export { storeReactivityBindings };
+//# sourceMappingURL=store-reactivity-bindings.d.ts.map

package/dist/store-reactivity-bindings.js

@@ -0,0 +1,35 @@
+import { batch, createAtom } from "@tanstack/store";
+
+//#region src/store-reactivity-bindings.ts
+/**
+* TanStack Store–based reactivity for vanilla / non-framework use of `constructTable`,
+* with `createOptionsStore: true` so `table.optionsStore` is available for subscriptions.
+*
+* @example
+* ```ts
+* import { constructTable, tableFeatures } from '@tanstack/table-core'
+* import { storeReactivityBindings } from '@tanstack/table-core/store-reactivity-bindings'
+*
+* const table = constructTable({
+*   _features: tableFeatures({ coreReativityFeature: storeReactivityBindings() }),
+*   // ...
+* })
+* ```
+*/
+function storeReactivityBindings() {
+	return {
+		createOptionsStore: true,
+		batch,
+		untrack: (fn) => fn(),
+		createReadonlyAtom: (fn, options) => {
+			return createAtom(() => fn(), { compare: options === null || options === void 0 ? void 0 : options.compare });
+		},
+		createWritableAtom: (value, options) => {
+			return createAtom(value, { compare: options === null || options === void 0 ? void 0 : options.compare });
+		}
+	};
+}
+
+//#endregion
+export { storeReactivityBindings };
+//# sourceMappingURL=store-reactivity-bindings.js.map

package/dist/store-reactivity-bindings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-reactivity-bindings.js","names":[],"sources":["../src/store-reactivity-bindings.ts"],"sourcesContent":["import { batch, createAtom } from '@tanstack/store'\nimport type { TableReactivityBindings } from './core/reactivity/coreReactivityFeature.types'\n\n/**\n * TanStack Store–based reactivity for vanilla / non-framework use of `constructTable`,\n * with `createOptionsStore: true` so `table.optionsStore` is available for subscriptions.\n *\n * @example\n * ```ts\n * import { constructTable, tableFeatures } from '@tanstack/table-core'\n * import { storeReactivityBindings } from '@tanstack/table-core/store-reactivity-bindings'\n *\n * const table = constructTable({\n *   _features: tableFeatures({ coreReativityFeature: storeReactivityBindings() }),\n *   // ...\n * })\n * ```\n */\nexport function storeReactivityBindings(): TableReactivityBindings {\n  return {\n    createOptionsStore: true,\n    batch,\n    untrack: (fn) => fn(),\n    createReadonlyAtom: (fn, options) => {\n      return createAtom(() => fn(), {\n        compare: options?.compare,\n      })\n    },\n    createWritableAtom: (value, options) => {\n      return createAtom(value, {\n        compare: options?.compare,\n      })\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,SAAgB,0BAAmD;AACjE,QAAO;EACL,oBAAoB;EACpB;EACA,UAAU,OAAO,IAAI;EACrB,qBAAqB,IAAI,YAAY;AACnC,UAAO,iBAAiB,IAAI,EAAE,EAC5B,2DAAS,QAAS,SACnB,CAAC;;EAEJ,qBAAqB,OAAO,YAAY;AACtC,UAAO,WAAW,OAAO,EACvB,2DAAS,QAAS,SACnB,CAAC;;EAEL"}

package/dist/types/TableFeatures.d.cts

@@ -8,7 +8,7 @@ import { StockFeatures } from "../features/stockFeatures.cjs";
 import { Table_Internal } from "./Table.cjs";
 
 //#region src/types/TableFeatures.d.ts
-type ExtractFeatureTypes<TKey extends keyof FeatureConstructors, TFeatures extends TableFeatures> = UnionToIntersection<{ [K in keyof TFeatures]: TFeatures[K] extends TableFeature<infer FeatureConstructorOptions> ? TKey extends keyof FeatureConstructorOptions ? FeatureConstructorOptions[TKey] : never : any }[keyof TFeatures]>;
+type ExtractFeatureTypes<TKey extends keyof FeatureConstructors, TFeatures extends TableFeatures> = UnionToIntersection<{ [K in keyof TFeatures]: K extends 'coreReativityFeature' ? never : TFeatures[K] extends TableFeature<infer FeatureConstructorOptions> ? TKey extends keyof FeatureConstructorOptions ? FeatureConstructorOptions[TKey] : never : any }[keyof TFeatures]>;
 interface FeatureConstructors {
   CachedRowModel?: any;
   Cell?: any;

package/dist/types/TableFeatures.d.ts

@@ -8,7 +8,7 @@ import { StockFeatures } from "../features/stockFeatures.js";
 import { Table_Internal } from "./Table.js";
 
 //#region src/types/TableFeatures.d.ts
-type ExtractFeatureTypes<TKey extends keyof FeatureConstructors, TFeatures extends TableFeatures> = UnionToIntersection<{ [K in keyof TFeatures]: TFeatures[K] extends TableFeature<infer FeatureConstructorOptions> ? TKey extends keyof FeatureConstructorOptions ? FeatureConstructorOptions[TKey] : never : any }[keyof TFeatures]>;
+type ExtractFeatureTypes<TKey extends keyof FeatureConstructors, TFeatures extends TableFeatures> = UnionToIntersection<{ [K in keyof TFeatures]: K extends 'coreReativityFeature' ? never : TFeatures[K] extends TableFeature<infer FeatureConstructorOptions> ? TKey extends keyof FeatureConstructorOptions ? FeatureConstructorOptions[TKey] : never : any }[keyof TFeatures]>;
 interface FeatureConstructors {
   CachedRowModel?: any;
   Cell?: any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/table-core",
-  "version": "9.0.0-alpha.41",
+  "version": "9.0.0-alpha.43",
   "description": "Headless UI for building powerful tables & datagrids for TS/JS.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -38,10 +38,18 @@
       "import": "./dist/flex-render.js",
       "require": "./dist/flex-render.cjs"
     },
+    "./reactivity": {
+      "import": "./dist/reactivity.js",
+      "require": "./dist/reactivity.cjs"
+    },
     "./static-functions": {
       "import": "./dist/static-functions.js",
       "require": "./dist/static-functions.cjs"
     },
+    "./store-reactivity-bindings": {
+      "import": "./dist/store-reactivity-bindings.js",
+      "require": "./dist/store-reactivity-bindings.cjs"
+    },
     "./package.json": "./package.json"
   },
   "sideEffects": false,

package/src/core/coreFeatures.ts

@@ -4,8 +4,10 @@ import { coreHeadersFeature } from './headers/coreHeadersFeature'
 import { coreRowModelsFeature } from './row-models/coreRowModelsFeature'
 import { coreRowsFeature } from './rows/coreRowsFeature'
 import { coreTablesFeature } from './table/coreTablesFeature'
+import type { TableReactivityBindings } from '../reactivity'
 
 export interface CoreFeatures {
+  coreReativityFeature?: TableReactivityBindings
   coreCellsFeature: typeof coreCellsFeature
   coreColumnsFeature: typeof coreColumnsFeature
   coreHeadersFeature: typeof coreHeadersFeature

package/src/core/reactivity/coreReactivityFeature.types.ts

@@ -0,0 +1,41 @@
+import type { Atom, AtomOptions, ReadonlyAtom } from '@tanstack/store'
+
+export interface TableAtomOptions<T> extends AtomOptions<T> {
+  /**
+   * A debug name for the atom, useful for debugging.
+   */
+  debugName: string
+}
+
+/**
+ * Framework reactivity bindings used by table-core.
+ *
+ * Adapters (React, Solid, Vue, etc.) provide concrete implementations so
+ * core features can create derived/writable atoms and integrate with their
+ * scheduling primitives.
+ */
+export interface TableReactivityBindings {
+  createOptionsStore: boolean
+  /**
+   * Creates a writable atom with an initial value.
+   */
+  createWritableAtom: <T>(
+    initialValue: T,
+    options?: TableAtomOptions<T>,
+  ) => Atom<T>
+  /**
+   * Creates a readonly/derived atom from a compute function.
+   */
+  createReadonlyAtom: <T>(
+    fn: () => T,
+    options?: TableAtomOptions<T>,
+  ) => ReadonlyAtom<T>
+  /**
+   * Evaluates a function without tracking reactive dependencies.
+   */
+  untrack: <T>(fn: () => T) => T
+  /**
+   * Batches reactive updates to avoid intermediate recomputation.
+   */
+  batch: (fn: () => void) => void
+}

package/src/core/reactivity/coreReactivityFeature.utils.ts

@@ -0,0 +1,29 @@
+import type { Atom, ReadonlyAtom, ReadonlyStore, Store } from '@tanstack/store'
+
+/**
+ * Converts a writable atom to the store-compatible shape expected by core.
+ */
+export function atomToStore<T>(atom: Atom<T>): Store<T>
+/**
+ * Converts a readonly atom to a readonly store-compatible shape.
+ */
+export function atomToStore<T>(atom: ReadonlyAtom<T>): ReadonlyStore<T>
+/**
+ * Bridges atom instances to the `Store`/`ReadonlyStore` API by exposing
+ * a `state` getter backed by `atom.get()`, and wiring `setState` for
+ * writable atoms.
+ */
+export function atomToStore<T>(
+  atom: Atom<T> | ReadonlyAtom<T>,
+): Store<T> | ReadonlyStore<T> {
+  const store: Store<T> = atom as Store<T>
+  Object.defineProperty(atom, 'state', {
+    get() {
+      return atom.get()
+    },
+  })
+  if ('set' in atom) {
+    store.setState = atom.set.bind(atom)
+  }
+  return store
+}

package/src/core/table/constructTable.ts

@@ -1,6 +1,7 @@
-import { createAtom, createStore } from '@tanstack/store'
 import { coreFeatures } from '../coreFeatures'
 import { cloneState } from '../../utils'
+import { atomToStore } from '../reactivity/coreReactivityFeature.utils'
+import { table_syncExternalStateToBaseAtoms } from './coreTablesFeature.utils'
 import type { RowData } from '../../types/type-utils'
 import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
 import type { Table, Table_Internal } from '../../types/Table'
@@ -21,16 +22,13 @@ export function constructTable<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(tableOptions: TableOptions<TFeatures, TData>): Table<TFeatures, TData> {
+  const _reactivity = tableOptions._features.coreReativityFeature!
+
   const table = {
+    _reactivity,
     _features: { ...coreFeatures, ...tableOptions._features },
     _rowModels: {},
     _rowModelFns: {},
-    get options() {
-      return this.optionsStore.state
-    },
-    set options(value) {
-      this.optionsStore.setState(() => value)
-    },
     baseAtoms: {},
     atoms: {},
   } as Table_Internal<TFeatures, TData>
@@ -41,10 +39,26 @@ export function constructTable<
     return Object.assign(obj, feature.getDefaultTableOptions?.(table))
   }, {}) as TableOptions<TFeatures, TData>
 
-  table.optionsStore = createStore({
-    ...defaultOptions,
-    ...tableOptions,
-  })
+  const mergedOptions = { ...defaultOptions, ...tableOptions }
+
+  if (_reactivity.createOptionsStore) {
+    // @ts-ignore - direct set
+    table.optionsStore = _reactivity.createWritableAtom<
+      TableOptions<TFeatures, TData>
+    >(mergedOptions, { debugName: 'table/optionsStore' })
+    Object.defineProperty(table, 'options', {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return table.optionsStore!.get()
+      },
+      set(value) {
+        table.optionsStore!.set(() => value) // or your real update shape
+      },
+    })
+  } else {
+    table.options = mergedOptions
+  }
 
   table.initialState = getInitialTableState(
     table._features,
@@ -57,31 +71,40 @@ export function constructTable<
 
   for (const key of stateKeys) {
     // create writable base atom
-    table.baseAtoms[key] = createAtom(table.initialState[key]) as any
-
-    // create readonly derived atom: on each get(), read current options (state, then external atom, then base)
-    ;(table.atoms as any)[key] = createAtom(() => {
-      // Reading optionsStore.state keeps this reactive to setOptions
-      const opts = table.optionsStore.state
-      const state = opts.state
-      if (key in (state ?? {})) {
-        return state![key]
-      }
-      const externalAtom = opts.atoms?.[key]
-      if (externalAtom) {
-        return externalAtom.get()
-      }
-      return table.baseAtoms[key].get()
-    })
+    table.baseAtoms[key] = _reactivity.createWritableAtom(
+      table.initialState[key],
+      {
+        debugName: `table/baseAtoms/${key}`,
+      },
+    ) as any
+
+    // create readonly derived atom: on each get(), read either external atom or base atom
+    ;(table.atoms as any)[key] = _reactivity.createReadonlyAtom(
+      () => {
+        const externalAtom = table.options.atoms?.[key]
+        if (externalAtom) {
+          return externalAtom.get()
+        }
+        return table.baseAtoms[key].get()
+      },
+      { debugName: `table/atoms/${key}` },
+    )
   }
 
-  table.store = createStore(() => {
-    const snapshot = {} as TableState<TFeatures>
-    for (const key of stateKeys) {
-      snapshot[key] = table.atoms[key].get()
-    }
-    return snapshot
-  })
+  table_syncExternalStateToBaseAtoms(table)
+
+  table.store = atomToStore(
+    _reactivity.createReadonlyAtom(
+      () => {
+        const snapshot = {} as TableState<TFeatures>
+        for (const key of stateKeys) {
+          snapshot[key] = table.atoms[key].get()
+        }
+        return snapshot
+      },
+      { debugName: 'table/store' },
+    ),
+  )
 
   if (
     process.env.NODE_ENV === 'development' &&
@@ -98,7 +121,8 @@ export function constructTable<
 
   Row Models: ${rowModels.length ? rowModels.join('\n              ') : '(none)'}
 
-  States:     ${states.join('\n              ')}`,
+  States:     ${states.join('\n              ')}\n`,
+      { table },
     )
   }
 

package/src/core/table/coreTablesFeature.types.ts

@@ -1,4 +1,5 @@
-import type { Atom, ReadonlyAtom, ReadonlyStore, Store } from '@tanstack/store'
+import type { TableReactivityBindings } from '../reactivity/coreReactivityFeature.types'
+import type { Atom, ReadonlyAtom, ReadonlyStore } from '@tanstack/store'
 import type { CoreFeatures } from '../coreFeatures'
 import type { RowModelFns } from '../../types/RowModelFns'
 import type { RowData, Updater } from '../../types/type-utils'
@@ -67,11 +68,11 @@ export interface TableOptions_Table<
   /**
    * The features that you want to enable for the table.
    */
-  _features: TFeatures
+  readonly _features: TFeatures
   /**
    * The row model options that you want to enable for the table.
    */
-  _rowModels?: CreateRowModels_All<TFeatures, TData>
+  readonly _rowModels?: CreateRowModels_All<TFeatures, TData>
   /**
    * Optionally, provide your own external writable atoms for individual state slices.
    * When an atom is provided for a given slice, it takes precedence over `options.state[key]`
@@ -79,35 +80,35 @@ export interface TableOptions_Table<
    * still routed through the internal base atom; consumers are responsible for
    * mirroring changes back to their external atom via the corresponding `onXChange` callback.
    */
-  atoms?: ExternalAtoms<TFeatures>
+  readonly atoms?: ExternalAtoms<TFeatures>
   /**
    * Set this option to override any of the `autoReset...` feature options.
    */
-  autoResetAll?: boolean
+  readonly autoResetAll?: boolean
   /**
    * The data for the table to display. When the `data` option changes reference, the table will reprocess the data.
    */
-  data: ReadonlyArray<TData>
+  readonly data: ReadonlyArray<TData>
   /**
    * Use this option to optionally pass initial state to the table. This state will be used when resetting various table states either automatically by the table (eg. `options.autoResetPageIndex`) or via functions like `table.resetRowSelection()`. Most reset function allow you optionally pass a flag to reset to a blank/default state instead of the initial state.
    * Table state will not be reset when this object changes, which also means that the initial state object does not need to be stable.
    */
-  initialState?: Partial<TableState<TFeatures>>
+  readonly initialState?: Partial<TableState<TFeatures>>
   /**
    * This option is used to optionally implement the merging of table options.
    */
-  mergeOptions?: (
+  readonly mergeOptions?: (
     defaultOptions: TableOptions<TFeatures, TData>,
     options: Partial<TableOptions<TFeatures, TData>>,
   ) => TableOptions<TFeatures, TData>
   /**
    * You can pass any object to `options.meta` and access it anywhere the `table` is available via `table.options.meta`.
    */
-  meta?: TableMeta<TFeatures, TData>
+  readonly meta?: TableMeta<TFeatures, TData>
   /**
    * Pass in individual self-managed state to the table.
    */
-  state?: Partial<TableState<TFeatures>>
+  readonly state?: Partial<TableState<TFeatures>>
 }
 
 export interface Table_CoreProperties<
@@ -115,9 +116,9 @@ export interface Table_CoreProperties<
   TData extends RowData,
 > {
   /**
-   * The features that are enabled for the table.
+   * Table reactivity bindings for interacting with TanStack Store.
    */
-  _features: Partial<CoreFeatures> & TFeatures
+  readonly _reactivity: TableReactivityBindings
   /**
    * Prototype cache for Cell objects - shared by all cells in this table
    */
@@ -126,6 +127,10 @@ export interface Table_CoreProperties<
    * Prototype cache for Column objects - shared by all columns in this table
    */
   _columnPrototype?: object
+  /**
+   * The features that are enabled for the table.
+   */
+  readonly _features: Partial<CoreFeatures> & TFeatures
   /**
    * Prototype cache for Header objects - shared by all headers in this table
    */
@@ -133,43 +138,46 @@ export interface Table_CoreProperties<
   /**
    * The row model processing functions that are used to process the data by features.
    */
-  _rowModelFns: RowModelFns<TFeatures, TData>
+  readonly _rowModelFns: RowModelFns<TFeatures, TData>
   /**
    * The row models that are enabled for the table.
    */
-  _rowModels: CachedRowModels<TFeatures, TData>
+  readonly _rowModels: CachedRowModels<TFeatures, TData>
   /**
    * Prototype cache for Row objects - shared by all rows in this table
    */
   _rowPrototype?: object
-  /**
-   * The internal writable atoms for each `TableState` slice. This is the library's
-   * single write surface — all state mutations from features land here.
-   */
-  baseAtoms: BaseAtoms<TFeatures>
   /**
    * The readonly derived atoms for each `TableState` slice. Each derives from
    * its corresponding `baseAtom` plus, optionally, a per-slice external atom or
    * external state value (precedence: external atom > external state > base atom).
    */
-  atoms: Atoms<TFeatures>
+  readonly atoms: Atoms<TFeatures>
   /**
-   * The base store for the table options.
+   * The internal writable atoms for each `TableState` slice. This is the library's
+   * single write surface — all state mutations from features land here.
    */
-  optionsStore: Store<TableOptions<TFeatures, TData>>
+  readonly baseAtoms: BaseAtoms<TFeatures>
   /**
    * This is the resolved initial state of the table.
    */
-  initialState: TableState<TFeatures>
+  readonly initialState: TableState<TFeatures>
   /**
    * A read-only reference to the table's current options.
    */
   readonly options: TableOptions<TFeatures, TData>
+  /**
+   * Writable atom for table options. Only created when `createOptionsStore` is true
+   * on `coreReativityFeature` (e.g. Lit, Vue, Solid). React/Preact use `createOptionsStore: false`:
+   * options are held as plain data with a lightweight revision + subscribe source; there is
+   * no writable atom backing the full options object. Use {@link getTableOptionsStore} to subscribe.
+   */
+  readonly optionsStore?: Atom<TableOptions<TFeatures, TData>> | undefined
   /**
    * The readonly flat store for the table state. Derives from `table.atoms`
    * only; never reads external state directly.
    */
-  store: ReadonlyStore<TableState<TFeatures>>
+  readonly store: ReadonlyStore<TableState<TFeatures>>
 }
 
 export interface Table_Table<

package/src/core/table/coreTablesFeature.utils.ts

@@ -1,16 +1,39 @@
-import { batch } from '@tanstack/store'
 import { cloneState, functionalUpdate } from '../../utils'
 import type { RowData, Updater } from '../../types/type-utils'
 import type { TableFeatures } from '../../types/TableFeatures'
 import type { Table_Internal } from '../../types/Table'
 import type { TableOptions } from '../../types/TableOptions'
 
+export function table_syncExternalStateToBaseAtoms<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): void {
+  const state = table.options.state
+  if (!state) {
+    return
+  }
+
+  table._reactivity.batch(() => {
+    for (const key in state) {
+      const baseAtom = (table.baseAtoms as Record<string, any>)[key]
+      if (!baseAtom) {
+        continue
+      }
+
+      const externalState = state[key as keyof typeof state]
+      if (externalState !== baseAtom.get()) {
+        baseAtom.set(() => externalState)
+      }
+    }
+  })
+}
+
 export function table_reset<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>): void {
   const snap = cloneState(table.initialState)
-  batch(() => {
+  table._reactivity.batch(() => {
     for (const key of Object.keys(snap) as Array<keyof typeof snap>) {
       ;(table.baseAtoms as any)[key].set(snap[key] as any)
     }
@@ -43,5 +66,10 @@ export function table_setOptions<
 ): void {
   const newOptions = functionalUpdate(updater, table.options)
   const mergedOptions = table_mergeOptions(table, newOptions)
-  table.optionsStore.setState(() => mergedOptions)
+  if (table.optionsStore) {
+    table.optionsStore.set(() => mergedOptions)
+  } else {
+    table.options = mergedOptions
+  }
+  table_syncExternalStateToBaseAtoms(table)
 }

package/src/index.ts

@@ -71,9 +71,6 @@ export * from './fns/sortFns'
 
 export * from './features/stockFeatures'
 
-// tableReactivityFeature
-export * from './features/table-reactivity/tableReactivityFeature'
-
 // columnFacetingFeature
 export * from './features/column-faceting/columnFacetingFeature'
 export * from './features/column-faceting/columnFacetingFeature.types'

package/src/reactivity.ts

@@ -0,0 +1,2 @@
+export * from './core/reactivity/coreReactivityFeature.types'
+export * from './core/reactivity/coreReactivityFeature.utils'

package/src/store-reactivity-bindings.ts

@@ -0,0 +1,35 @@
+import { batch, createAtom } from '@tanstack/store'
+import type { TableReactivityBindings } from './core/reactivity/coreReactivityFeature.types'
+
+/**
+ * TanStack Store–based reactivity for vanilla / non-framework use of `constructTable`,
+ * with `createOptionsStore: true` so `table.optionsStore` is available for subscriptions.
+ *
+ * @example
+ * ```ts
+ * import { constructTable, tableFeatures } from '@tanstack/table-core'
+ * import { storeReactivityBindings } from '@tanstack/table-core/store-reactivity-bindings'
+ *
+ * const table = constructTable({
+ *   _features: tableFeatures({ coreReativityFeature: storeReactivityBindings() }),
+ *   // ...
+ * })
+ * ```
+ */
+export function storeReactivityBindings(): TableReactivityBindings {
+  return {
+    createOptionsStore: true,
+    batch,
+    untrack: (fn) => fn(),
+    createReadonlyAtom: (fn, options) => {
+      return createAtom(() => fn(), {
+        compare: options?.compare,
+      })
+    },
+    createWritableAtom: (value, options) => {
+      return createAtom(value, {
+        compare: options?.compare,
+      })
+    },
+  }
+}