Store<EM extends EventMapBase, R extends string, S extends Record<R, any>>

new<EM, R, S>(spec): Store<EM, R, S>

Creates a store from a StoreSpec.

Type parameters

Parameters

Returns

Store<EM, R, S>

__devtoolsIntrospect(): { atomic: { property: string; reducer: string }[]; coarse: number; dedupHits: number; effects: { channel: string; description?: string; name?: string; type: string }[]; event: { channel: string; phase: string; type: string }[]; middleware: { description?: string; name?: string; when?: unknown }[]; queueDepth: number; reducers: { name: string; when: undefined | When<EM> }[] }

Returns a structured introspection snapshot for DevTools UIs.

Returns

{ atomic: { property: string; reducer: string }[]; coarse: number; dedupHits: number; effects: { channel: string; description?: string; name?: string; type: string }[]; event: { channel: string; phase: string; type: string }[]; middleware: { description?: string; name?: string; when?: unknown }[]; queueDepth: number; reducers: { name: string; when: undefined | When<EM> }[] }

buildAncestorPaths(path): string[]

Builds ancestor paths for a dotted path. For "a.b.c", returns ["a", "a.b", "a.b.c"]. Leading dots are trimmed.

Parameters

Returns

string[] — Array of ancestor paths.

Store.buildAncestorPaths('x.y.z'); // ['x','x.y','x.y.z']

call<C, T>(channel, type, payload, opts): CallHandle<EventUnion<EM>, EventUnion<EM>>

Sends a request and waits for the reply, correlating the two automatically.

Type parameters

Parameters

Returns

CallHandle<EventUnion<EM>, EventUnion<EM>> — A CallHandle: await it for the terminal reply, or for await it for progress events as they arrive.

// Survives a job that streams for minutes; fails a responder that goes quiet for 5s.
await store.call("job", "start", { id }, { reply: ["job", "done"], timeoutMs: 5_000 });

const call = store.call("rpc", "ask", { q }, { reply: ["rpc", "answer"] });
useEffect(() => () => call.cancel("unmounted"), [call]);

connect(spec, h, options?): () => void

Connects a **fine-grained** listener to a dotted path under a slice.

Parameters

Returns

() => void — Unsubscribe function.

const off = store.connect(
  { reducer: 'todos', property: 'items.0.title' },
  (chg) => console.log('title changed:', chg.newValue)
);
off();

// Listen to any item title change
const off = store.connect(
  { reducer: 'todos', property: 'items.*.title' },
  (chg) => console.log('some title changed')
);

dispose(): void

Cleanup resources (timers, etc.) when disposing the store. Call this if you're dynamically creating/destroying stores.

Returns

void

const store = createStore({ ... });
// later
store.dispose();

emit<C, T>(channel, type, payload, opts?): Promise<EmitResult>

Emits a typed event (channel, type, payload). Events are queued and processed **sequentially** (FIFO). **Pipeline per event:** the *reduce phase* (steps 1-4) runs **synchronously**, so getState() reflects the change as soon as emit() returns; the *effect phase* (step 5) runs afterwards, asynchronously. 1. **Deduplication** (opt-in) - Skip when content-dedup is enabled (dedupWindowMs > 0) or a matching dedupKey recurs; off by default 2. **Middleware** (sync) - Pre-reducer hooks; may cancel by returning false 3. **Reducers** (sync) - every matching slice is *staged*; nothing is written yet, so a refusal from the last reducer still stops the first one's write 4. **Commit + subscribers** (sync) - all staged slices are assigned under one new root, then event subscribers (committed, then written when state actually changed), then coarse listeners 5. **Effects** (async) - side-effects keyed by (channel, type); the returned promise resolves once they complete **Change Detection**: Uses reference equality (===) on this.state to determine if any slice changed. Works because the commit builds a new state reference via shallow spread when any slice changes.

Type parameters

Parameters

Returns

Promise<EmitResult> — A promise that resolves once this event's effects have finished. State is already updated synchronously before emit() returns.

await store.emit('ui', 'increment', 1);

store.registerMiddleware((state, event) => {
  if (event.type === 'dangerous') return false; // cancel
  return true; // allow
});

await store.emit('ui', 'dangerous', null); // cancelled, no state change

getState(): DeepReadonly<S>

Returns the current immutable state snapshot.

Returns

DeepReadonly<S> — Deep-readonly state object.

const state = store.getState();
console.log(state.counter.value);

hotReplace(partial): void

Convenience API to replace **any subset** of store parts (HMR patterns).

Parameters

Returns

void

store.hotReplace({
  reducer: newReducers,
  middleware: newMiddleware,
  effects: newEffects,
  preserveState: true
});

instrument(observer): Unsubscribe

Registers an instrumentation observer. See StoreInstance.instrument.

Parameters

Returns

Unsubscribe

onEffect<C, T>(channel, type, handler): () => void

Convenience helper to register an **effect** filtered by a single (channel, type) pair.

Type parameters

Parameters

Returns

() => void — Unsubscribe/teardown function.

const off = store.onEffect('ui', 'increment', async (n, get, emit) => {
  if (n > 10) await emit('ui', 'increment', -10);
});
// later
off();

onEvent<C, T>(channel, type, handler, phase): Unsubscribe

Subscribe to events by channel and type. Event subscriptions are intended for the View layer (e.g., React components) to react to events without affecting the event flow. They are fire-and-forget and cannot cancel event propagation. **Phases:** - 'committed' (default): Events that passed middleware and reached reducers. Notified after reducers, before effects. - 'uncommitted': Events rejected by middleware. Notified immediately after rejection. - 'all': Both committed and uncommitted events. Handler receives the phase parameter to distinguish between the two.

Type parameters

Parameters

Returns

Unsubscribe — Unsubscribe function.

const off = store.onEvent('ui', 'save', (event, getState, emit, phase) => {
  console.log('Save committed:', event.payload);
});
off();

store.onEvent('ui', 'delete', (event, getState, emit, phase) => {
  console.log('Delete was rejected by middleware');
}, 'uncommitted');

store.onEvent('ui', 'action', (event, getState, emit, phase) => {
  console.log('Action:', phase); // 'committed' or 'uncommitted'
}, 'all');

registerEffect(spec): () => void

Register a post-reducer effect (sees final state). Returns an unsubscribe.

Parameters

Returns

() => void

registerMiddleware(mw): Unsubscribe

Registers a middleware (runs **before** reducers).

Parameters

Returns

Unsubscribe — Unsubscribe function that removes this middleware.

const off = store.registerMiddleware((state, event) => {
  console.log('Event:', event.channel, event.type, event.payload);
  return true; // allow
});
off();

store.registerMiddleware((state, event) => {
  if (event.type === 'forbidden') return false; // cancel
  return true;
});

registerReducer(name, spec): () => void

Dynamically **adds** a named slice reducer at runtime.

Parameters

Returns

() => void — Disposer function that **removes** the slice (and its state).

const dispose = store.registerReducer('filters', {
  state: { q: '' },
  events: [['ui', 'setQuery']],
  reducer(s, evt) {
    return evt.type === 'setQuery' ? { q: evt.payload } : s;
  }
});
// Later:
dispose();

replaceEffects(next): void

Replaces all registered **effects** (HMR-friendly).

Parameters

Returns

void

if (import.meta.hot) {
  import.meta.hot.accept('./effects', (newModule) => {
    store.replaceEffects(newModule.effects);
  });
}

replaceMiddleware(next): void

Replaces the **entire** middleware pipeline (HMR-friendly).

Parameters

Returns

void

if (import.meta.hot) {
  import.meta.hot.accept('./middleware', (newModule) => {
    store.replaceMiddleware(newModule.middleware);
  });
}

replaceReducers(next, opts): void

Replaces the entire **reducer set** (HMR-friendly).

Parameters

Returns

void

if (import.meta.hot) {
  import.meta.hot.accept('./reducers', (newModule) => {
    store.replaceReducers(newModule.reducers, { preserveState: true });
  });
}

subscribe(fn): () => void

Subscribes to **coarse-grained** commits (called once per successful event, only if state changed). **Use Case**: React's useSyncExternalStore or similar external store integrations.

Parameters

Returns

() => void — Unsubscribe function.

const off = store.subscribe(() => console.log('state committed'));
// Later:
off();