Feature not supported in current reactivity implementation

Error message

Feature not supported in current reactivity implementation

What it means

renderPhaseReactivity in packages/table-core/src/core/reactivity/renderPhaseReactivity.ts returns bindings whose addSubscription throws. This render-phase reactivity model recomputes atoms during render and does not support external subscription registration. It is shared by the react, preact, lit, and octane adapters.

Source

Thrown at packages/table-core/src/core/reactivity/renderPhaseReactivity.ts:70

 * @example
 * ```ts
 * import { batch, createAtom } from '@tanstack/react-store'
 *
 * export const reactReactivity = () =>
 *   renderPhaseReactivity({ createAtom, batch })
 * ```
 */
export function renderPhaseReactivity(
  primitives: RenderPhaseReactivityPrimitives,
): RenderPhaseReactivityBindings {
  const { createAtom, batch } = primitives
  const commitAtom = createAtom(0)

  return {
    createOptionsStore: false,
    wrapExternalAtoms: false,
    addSubscription: () => {
      throw new Error(
        'Feature not supported in current reactivity implementation',
      )
    },
    unmount: () => {
      throw new Error(
        'Feature not supported in current reactivity implementation',
      )
    },
    schedule: primitives.schedule ?? ((fn) => queueMicrotask(fn)),
    batch,
    untrack: (fn) => fn(),
    createReadonlyAtom: <T>(fn: () => T, atomOptions?: TableAtomOptions<T>) => {
      const compare = atomOptions?.compare ?? Object.is
      let hasSnapshot = false
      let snapshot: T

      const getSnapshot = () => {
        const nextSnapshot = fn()

View on GitHub (pinned to d01c01bedb)

Solutions

Avoid addSubscription with render-phase bindings; read atoms during render so they are tracked automatically.
Use a reactivity implementation that supports subscriptions if the feature requires them.
Supply custom TableReactivityBindings overriding addSubscription with a supported implementation.

Example fix

// before
bindings.addSubscription(() => log(atom.get()))
// after
// track reads during render instead
const value = atom.get() // re-renders when atom changes

Defensive patterns

Strategy: validation

Validate before calling

if (!('addSubscriptionSupported' in bindings) || bindings.addSubscription === undefined) {
  // skip subscription-based path
}

Type guard

function canSubscribe(b: TableReactivityBindings): boolean {
  try { return b.addSubscription.length >= 0 && !isThrowingStub(b.addSubscription) } catch { return false }
}

Try / catch

try {
  bindings.addSubscription(cb)
} catch (e) {
  if ((e as Error).message.includes('Feature not supported')) {
    // switch to render-phase tracking: read the atom during render
  } else throw e
}

Prevention

In render-phase frameworks (React/Preact/Lit/Octane), track atoms by reading them during render
Do not port store-adapter subscription code to render-phase adapters unchanged
Keep a capability matrix of the reactivity adapters your features support

When it happens

Trigger: Any code path calling bindings.addSubscription(...) on bindings produced by renderPhaseReactivity, e.g. a feature that expects subscription-capable reactivity.

Common situations: Enabling a feature written against store-based bindings with the render-phase (React/Preact/Lit/Octane) adapters; framework-agnostic plugin code registering subscriptions.

Related errors

AI-assisted analysis of TanStack/table@d01c01bedb (2026-08-28). Data as JSON: /api/errors/d047291fa2a91d10. Report an issue: GitHub.