@yoltra/core 0.6.0 → 0.7.0

package/README.md

@@ -34,7 +34,7 @@ emit(channel, type, payload)
   │
   ├─ 0. Dedup (opt-in) ─── Skip a duplicate only when dedupWindowMs > 0 or a dedupKey is given
   │
-  │  ══ SYNCHRONOUS reduce phase — runs before emit() returns ══
+  │  ══ SYNCHRONOUS reduce phase: runs before emit() returns ══
   ├─ 1. Middleware ─── Synchronous pre-reducer hooks (return false to reject → "uncommitted" event)
   ├─ 2. Reducers ─── Every matching slice staged, then all committed under one root
   ├─ 3. Event subscribers ─── Committed/uncommitted event notifications
@@ -43,11 +43,11 @@ emit(channel, type, payload)
   └─ 5. Effects ─── ASYNC side-effects, one independent task per event (keyed for O(1) lookup)
 ```
 
-The reduce phase (1–4) is **synchronous**, so `getState()` is correct the instant `emit()` returns
-— even with middleware. Effects (5) run afterward as an independent async task; the promise from
+The reduce phase (1–4) is **synchronous**, so `getState()` is correct the instant `emit()` returns,
+even with middleware. Effects (5) run afterward as an independent async task; the promise from
 `emit()` resolves when that event's effects finish. Every stage is hook-able, and
-`store.instrument()` exposes the whole flow — changed leaf paths, reduce timing, committed/rejected
-phase — to the DevTools with no `as any`. See the
+`store.instrument()` exposes the whole flow (changed leaf paths, reduce timing, committed/rejected
+phase) to the DevTools with no `as any`. See the
 [Event Pipeline Architecture](../../docs/en/design/event-queue-architecture.md) for the full model.
 
 ---
@@ -71,17 +71,17 @@ Subscribe to exact state paths using dotted notation. Supports `*` (one segment)
 or more segments) wildcards:
 
 ```typescript
-// Exact path — fires when items[0].title changes
+// Exact path: fires when items[0].title changes
 store.connect({ reducer: "todos", property: "items.0.title" }, (change) =>
   console.log("title:", change.oldValue, "→", change.newValue),
 );
 
-// Single-segment wildcard — fires when ANY item's title changes
+// Single-segment wildcard: fires when ANY item's title changes
 store.connect({ reducer: "todos", property: "items.*.title" }, (change) =>
   console.log("some title changed at", change.path),
 );
 
-// Deep wildcard — fires when anything under items changes
+// Deep wildcard: fires when anything under items changes
 store.connect({ reducer: "todos", property: "items.**" }, (change) =>
   console.log("items tree changed at", change.path),
 );
@@ -108,7 +108,7 @@ await store.emit("auth", "login", { token: "abc123" });
 store.getState().token; // "abc123"
 ```
 
-Such a slice has no property beneath it, so its changes are reported at the **slice root** —
+Such a slice has no property beneath it, so its changes are reported at the **slice root**,
 the empty path. Subscribe to it with `property: ""`:
 
 ```typescript
@@ -117,20 +117,20 @@ store.connect({ reducer: "token", property: "" }, (change) =>
 );
 ```
 
-The types know the difference. `property` on a root-value slice accepts `""` and nothing else —
-there is no key to address — and the value comes back correctly typed:
+The types know the difference. `property` on a root-value slice accepts `""` and nothing else,
+because there is no key to address, and the value comes back correctly typed:
 
 ```typescript
 const token = useAtomicProp({ reducer: "token", property: "" }); // string | null
 ```
 
-### `""` versus `"**"` — watching a whole slice
+### `""` versus `"**"`: watching a whole slice
 
 Two subscriptions sound alike and are not:
 
 | Pattern | Fires when |
 |---|---|
-| `""` | the slice's **whole value** is replaced — a primitive changes, a `Map` is rebuilt, an object slice becomes `null` |
+| `""` | the slice's **whole value** is replaced: a primitive changes, a `Map` is rebuilt, an object slice becomes `null` |
 | `"**"` | **anything** in the slice changes, at any depth. Matches the root too, since `**` matches zero segments |
 | `"*"` | one level down, exactly. Never matches the root |
 
@@ -140,7 +140,7 @@ because such a slice reports its changes at their leaves.
 
 `Map` and `Set` are compared by reference, not by entry: a reducer returning a new `Map` is a
 change, mutating one in place is not. That follows from the immutability contract rather than
-being a special case — build a new collection instead of mutating the stored one. It is also why
+being a special case. Build a new collection instead of mutating the stored one. It is also why
 they have no paths beneath them: `"byId"` is subscribable, `"byId.get"` is not, and the types
 say so.
 
@@ -169,7 +169,7 @@ type AppEM = {
   system: { init: void; shutdown: void };
 };
 
-// Match specific event keys (recommended — preserves type correlation)
+// Match specific event keys (recommended: preserves type correlation)
 const counterReducer = {
   state: { value: 0 },
   when: {
@@ -218,7 +218,7 @@ both raw functions (legacy) and `MiddlewareSpec` objects with targeting:
 ```typescript
 import type { MiddlewareSpec } from "@yoltra/core";
 
-// Targeted middleware — only runs for admin channel events
+// Targeted middleware: only runs for admin channel events
 const adminGuard: MiddlewareSpec<AppState, AppEM> = {
   when: { channel: "admin" },
   middleware: (state, event) => {
@@ -228,7 +228,7 @@ const adminGuard: MiddlewareSpec<AppState, AppEM> = {
   meta: { type: "middleware", name: "adminGuard" },
 };
 
-// Global middleware — runs for all events (synchronous: return a boolean, never a Promise)
+// Global middleware: runs for all events (synchronous: return a boolean, never a Promise)
 const logger = (state, event) => {
   console.log("Event:", event.channel, event.type);
   return true;
@@ -301,12 +301,12 @@ Subscribe to events (not state) from the view layer. Useful for notifications, a
 responding to rejected events:
 
 ```typescript
-// Committed events (default) — events that passed middleware
+// Committed events (default): events that passed middleware
 const off = store.onEvent("ui", "save", (event, getState, emit, phase) => {
   console.log("Save committed:", event.payload);
 });
 
-// Uncommitted events — events rejected by middleware
+// Uncommitted events: events rejected by middleware
 store.onEvent(
   "ui",
   "delete",
@@ -316,7 +316,7 @@ store.onEvent(
   "uncommitted",
 );
 
-// Written events — state actually changed. Fires after the commit, so getState() is current.
+// Written events: state actually changed. Fires after the commit, so getState() is current.
 store.onEvent(
   "plan",
   "patch",
@@ -326,7 +326,7 @@ store.onEvent(
   "written",
 );
 
-// All events — both committed and uncommitted (not written; see below)
+// All events: both committed and uncommitted (not written; see below)
 store.onEvent(
   "ui",
   "action",
@@ -338,7 +338,7 @@ store.onEvent(
 ```
 
 `committed` means **not vetoed**, and always has: it fires for every event middleware let through,
-whether or not a reducer wrote anything — including every event in a store with no reducers at
+whether or not a reducer wrote anything, including every event in a store with no reducers at
 all. `written` is the stricter fact, added rather than substituted, so toasts and analytics keep
 working unchanged. `all` stays `committed | uncommitted`; folding `written` in would hand existing
 subscribers a second notification per event.
@@ -348,7 +348,7 @@ subscribers a second notification per event.
 ## Commits are atomic across slices
 
 An event that touches several slices writes all of them, then notifies. Nothing observes a
-half-applied event — a subscriber to one slice reading `getState()` sees every other slice of the
+half-applied event. A subscriber to one slice reading `getState()` sees every other slice of the
 same event already applied.
 
 That matters most where a change is used as a signal to re-read, which is what the React hooks do.
@@ -380,8 +380,8 @@ const store = createStore({
 
 const result = await store.emit("plan", "patch", { steps, expectedVersion: 1 });
 
-result.committed; // true — middleware allowed it
-result.written; // false — but nothing was written
+result.committed; // true: middleware allowed it
+result.written; // false: nothing was written
 result.rejected?.reason; // "stale write: expected v1, have v3"
 ```
 
@@ -400,10 +400,10 @@ has made a decision and the whole event yields to it.
 
 ---
 
-## Request and reply — `store.call()`
+## Request and reply: `store.call()`
 
 Every event-bus consumer eventually writes request/reply by hand: mint an id, subscribe, match,
-time out, unsubscribe. It is about eighty lines and it has the same two bugs every time — the
+time out, unsubscribe. It is about eighty lines and it has the same two bugs every time: the
 subscription outlives the call, and a responder that forgets to echo the id produces a timeout
 with nothing to point at.
 
@@ -413,7 +413,7 @@ res.payload.text;
 ```
 
 The responder does nothing special. It replies through the `emit` it was handed, and the store's
-causal stamp correlates the two — **there is no id to mint, echo, or forget**:
+causal stamp correlates the two, and **there is no id to mint, echo, or forget**:
 
 ```typescript
 store.registerEffect({
@@ -453,7 +453,7 @@ const { payload } = await call;
 ```
 
 The backpressure is real, not a buffer with a limit. `emit` resolves only once its effects have
-run, and the collector is an effect that does not return until the consumer has taken the item —
+run, and the collector is an effect that does not return until the consumer has taken the item,
 so a responder writing `await emit("job", "tick", chunk)` is **paced by the reader**:
 
 ```typescript
@@ -466,7 +466,7 @@ effect: async (_event, _get, emit) => {
 ```
 
 Backpressure engages **once you begin iterating**. A call that is only awaited never pulls, so
-blocking its producer would deadlock the call itself — progress nobody reads would stop the
+blocking its producer would deadlock the call itself: progress nobody reads would stop the
 terminal event from ever being sent. Un-iterated progress therefore buffers to `highWaterMark`
 and is then counted on `call.dropped` rather than blocking.
 
@@ -474,17 +474,17 @@ and is then counted on `call.dropped` rather than blocking.
 
 | | |
 |---|---|
-| `timeoutMs` | **Idle**, not total — every correlated event resets it, progress included. A job that streams for two minutes will not fail a thirty-second call. Default 30s. |
+| `timeoutMs` | **Idle**, not total: every correlated event resets it, progress included. A job that streams for two minutes will not fail a thirty-second call. Default 30s. |
 | `signal` | An `AbortSignal`, for a real deadline or a cancelled action. |
 | `call.cancel(reason)` | Stops listening and settles. Safe to call twice. |
 
-However a call ends — resolved, timed out, aborted — the subscription is removed and any producer
+However a call ends, whether resolved, timed out or aborted, the subscription is removed and any producer
 parked on backpressure is released. A wedged responder is worse than the unbounded buffer this
 replaced.
 
 ## Reading a value as you subscribe
 
-`connect` starts at "from now on", so a subscriber's first read had to repeat the path elsewhere —
+`connect` starts at "from now on", so a subscriber's first read had to repeat the path elsewhere:
 the same path in two places, free to drift:
 
 ```typescript
@@ -513,14 +513,14 @@ store.connect({ reducer: "orders", property: "status" }, (change) => {
 });
 ```
 
-Provenance is **absent** when no event caused the change — a DevTools time-travel jump, or the
+Provenance is **absent** when no event caused the change: a DevTools time-travel jump, or the
 `immediate` delivery above. Absence is the signal, rather than a fabricated id.
 
 ---
 
 ## Event Deduplication (opt-in)
 
-Deduplication is **off by default** — Yoltra never silently drops legitimate rapid-fire identical
+Deduplication is **off by default**. Yoltra never silently drops legitimate rapid-fire identical
 events (double-clicks, repeated `+1`). Opt in only when you actually want coalescing:
 
 ```typescript
@@ -533,7 +533,7 @@ const store = createStore({
   dedupWindowMs: 100, // default: 0 (disabled)
 });
 
-// Identity-based: dedupe by an explicit key — e.g. a React Strict Mode double-invoke in an effect.
+// Identity-based: dedupe by an explicit key, e.g. a React Strict Mode double-invoke in an effect.
 await store.emit("analytics", "pageView", { page }, { dedupKey: `pageView:${page}` });
 ```
 
@@ -541,8 +541,8 @@ await store.emit("analytics", "pageView", { page }, { dedupKey: `pageView:${page
 
 ## Cascade protection (on by default)
 
-Two consumers wired into each other — a subscriber that emits what its own reducer answers, or
-two slices that answer each other's events — produce an event chain with no end. The reduce queue
+Two consumers wired into each other, whether a subscriber that emits what its own reducer answers or
+two slices that answer each other's events, produce an event chain with no end. The reduce queue
 drains **synchronously**, so that is not a slow program: it is a frozen tab, or a pinned core,
 with no error and no stack to point at.
 
@@ -554,7 +554,7 @@ const store = createStore({
   name: "app",
   reducer: { ... },
 
-  // Defaults to 64. Bounded whether or not you configure it — a failure mode this bad
+  // Defaults to 64. Bounded whether or not you configure it. A failure mode this bad
   // should not require configuration to avoid. Set Infinity to opt out and own it.
   maxReduceDepth: 64,
 
@@ -578,13 +578,13 @@ Both fields are **absent** on a root event rather than present as `0`/`undefined
 application emits stay byte-identical to before this existed.
 
 Breaching does not throw. The offending emit is refused, everything already committed stands, and
-`onCascade` (plus a console error) names it — a throw would surface in whichever subscriber or
+`onCascade` (plus a console error) names it. A throw would surface in whichever subscriber or
 effect happened to be emitting, which is the same unattributable failure the ceiling exists to
 prevent.
 
 **A wide burst is not a cascade.** One event whose subscriber fans out to five hundred siblings
 is a legitimate shape; depth is what separates it from a cycle, and a plain loop of `store.emit`
-never accumulates depth at all — each call drains to completion before the next, so every one is
+never accumulates depth at all, because each call drains to completion before the next, so every one is
 a root. `maxTransitionsPerDrain` bounds burst *width* and is off by default for that reason; the
 event that starts a drain is never refused by it.
 
@@ -639,13 +639,13 @@ if (import.meta.hot) {
 
 ### State is synchronous; `await` only for effects
 
-The reduce phase is synchronous, so state reflects your event the moment `emit()` returns — no
+The reduce phase is synchronous, so state reflects your event the moment `emit()` returns, with no
 `await` needed to read it back. Await `emit()` when you also want _this event's_ effects to have
 finished:
 
 ```typescript
 emit("todo", "add", todo);
-store.getState(); // Already reflects the new todo — no await required
+store.getState(); // Already reflects the new todo. No await required
 
 await emit("todo", "save", todo); // resolves once save's effects complete
 ```
@@ -749,7 +749,7 @@ that never happened.
 
 **Nothing throws on boot.** A missing, unparseable or unmigratable payload falls back to your
 declared defaults and reports through `onError`. A store that will not start because storage
-holds stale JSON is worse than one that starts fresh — and a full disk should not take down a
+holds stale JSON is worse than one that starts fresh, and a full disk should not take down a
 page, so write failures are reported the same way rather than raised.
 
 **Version mismatches are refused, not trusted.** Reducers change, and a snapshot written
@@ -767,7 +767,7 @@ For a server render, `dehydrate(store, { version })` produces the payload and
 ## Lists that reorder
 
 Path notification is positional for arrays. `items.0.title` names a *slot*, not a thing, so
-`unshift`, `splice(0, 1)` and `sort` move nearly every element into a different slot — and the
+`unshift`, `splice(0, 1)` and `sort` move nearly every element into a different slot, and the
 diff correctly reports that nearly every leaf changed. Inserting one row at the front of a
 thousand wakes a thousand subscribers.
 
@@ -790,7 +790,7 @@ todos.idsPath;                 // "ids"
 `entities.abc.title` survives insert, remove and reorder. A list container subscribes to `ids`
 and reorders its children; rows subscribe to their own entity and stay asleep through a sort.
 
-`ids` is still an array, so a reorder still reports `ids.0`, `ids.1` and so on — that cost is
+`ids` is still an array, so a reorder still reports `ids.0`, `ids.1` and so on. That cost is
 confined, not removed. What you get is cost proportional to what actually changed.
 
 For a small list that only ever grows at the end, `items.0.title` is fine and simpler. The
@@ -803,8 +803,8 @@ normalised, and the array reports roughly a thousand changed paths against two.
 case the adapter is for.
 
 A single-field update runs the other way: 20 µs for the array against 470 µs normalised.
-`detectChangedProps` indexes an array but enumerates an object's keys — building two key
-arrays and a `Set` per comparison — so a wide entity map is more expensive to walk even when
+`detectChangedProps` indexes an array but enumerates an object's keys, building two key
+arrays and a `Set` per comparison, so a wide entity map is more expensive to walk even when
 almost nothing in it moved. The numbers are in `benchmarks/`, and closing that gap is tracked
 work rather than a property of normalising as such.
 
@@ -813,24 +813,33 @@ individual fields edited is better off as an array today.
 
 ## Performance
 
-| Metric             | Value                                     |
-| ------------------ | ----------------------------------------- |
-| **Bundle size**    | 9.2 KB for the store (minified + gzipped) |
-| **Tree-shakeable** | Yes (ES modules)                          |
-| **Dependencies**   | Zero                                      |
-| **TypeScript**     | Full type definitions included            |
+| Metric             | Value                                  |
+| ------------------ | -------------------------------------- |
+| **Bundle size**    | Measured every build, see table below |
+| **Tree-shakeable** | Yes (ES modules)                       |
+| **Dependencies**   | Zero                                   |
+| **TypeScript**     | Full type definitions included         |
 
 Bundle size is checked, not asserted: `rush size` bundles the package the way a consumer
-would — tree-shaken, minified, gzipped — and fails when it exceeds the budget declared in
-`package.json`.
+would (tree-shaken, minified, gzipped) and fails when it exceeds the budget declared in
+`package.json`. The table below is written by that same check, so it cannot drift from what
+was measured; editing it by hand fails CI.
 
 The number that matters is what you import, not what the package exports:
 
-| Import                              | Size    | Budget |
-| ----------------------------------- | ------- | ------ |
-| `{ createStore }`                   | 9.2 KB  | 14 KB  |
-| `{ createStore, hydrate, persist }` | 10.7 KB | 16 KB  |
-| everything                          | 12.1 KB | 18 KB  |
+<!-- size-table:start -->
+| Import | Size | Budget |
+| --- | --- | --- |
+| `{ createStore }` | 8.3 KB | 14 KB |
+| `{ createStore, hydrate, persist }` | 9.7 KB | 16 KB |
+| everything | 11.2 KB | 18 KB |
+<!-- size-table:end -->
+
+These are **production** figures: what you ship once your bundler defines
+`NODE_ENV=production` and the development-only guards drop out. The budget column is the
+ceiling `rush size` enforces, and it is checked against a development build instead, which is
+the larger of the two: dev-only code cannot grow unnoticed just because it never reaches a
+user. So the headroom implied here is deliberately conservative.
 
 The **gap between rows** is the tree-shaking claim, and it is what to watch: persistence adds
 1.5 KB to the people who import it and nothing to anyone else, and the whole barrel is 2.9 KB
@@ -846,27 +855,27 @@ stops a runaway from hanging the tab.
 
 ## Documentation
 
-- **[yoltra Root README](../../README.md)** — Overview and
+- **[yoltra Root README](../../README.md)**: Overview and
   quick start
-- **[@yoltra/react](../react/README.md)** —
+- **[@yoltra/react](../react/README.md)**:
   React hooks and Suspense
-- **[Quick Start Guide](https://github.com/yoltra/yoltra/blob/main/docs/en/QUICK_START_GUIDE.md)**
-  — Five steps to a working app
-- **[Event Queue Architecture](https://github.com/yoltra/yoltra/blob/main/docs/en/design/event-queue-architecture.md)**
-  — Technical deep-dive
-- **[Library Comparison](https://github.com/yoltra/yoltra/blob/main/docs/en/design/state-management-library-comparison.md)**
-  — Architectural comparison
+- **[Quick Start Guide](https://github.com/yoltra/yoltra/blob/main/docs/en/QUICK_START_GUIDE.md)**:
+  Five steps to a working app
+- **[Event Queue Architecture](https://github.com/yoltra/yoltra/blob/main/docs/en/design/event-queue-architecture.md)**:
+  Technical deep-dive
+- **[Library Comparison](https://github.com/yoltra/yoltra/blob/main/docs/en/design/state-management-library-comparison.md)**:
+  Architectural comparison
 
 ---
 
 ## Examples
 
-- **[Todo App](https://github.com/yoltra/yoltra/blob/main/examples/v0/yoltra-in-react)** — Full
+- **[Todo App](https://github.com/yoltra/yoltra/blob/main/examples/v0/yoltra-in-react)**: Full
   CRUD with performance profiling · [▶ Open the live demo](https://yoltra.dev/en/demos/in-react)
-- **[Kinetic Logo](https://github.com/yoltra/yoltra/blob/main/examples/v0/yoltra-kinetic-logo)**
-  — 3000 circles with physics simulation · [▶ Open the live demo](https://yoltra.dev/en/demos/kinetic-logo)
-- **[Next.js Integration](https://github.com/yoltra/yoltra/blob/main/examples/v0/yoltra-in-nextjs)**
-  — Pages Router, client-side state + theme switcher · [▶ Open the live demo](https://yoltra.dev/en/demos/in-nextjs)
+- **[Kinetic Logo](https://github.com/yoltra/yoltra/blob/main/examples/v0/yoltra-kinetic-logo)**:
+  3000 circles with physics simulation · [▶ Open the live demo](https://yoltra.dev/en/demos/kinetic-logo)
+- **[Next.js Integration](https://github.com/yoltra/yoltra/blob/main/examples/v0/yoltra-in-nextjs)**:
+  Pages Router, client-side state + theme switcher · [▶ Open the live demo](https://yoltra.dev/en/demos/in-nextjs)
 
 ---
 
@@ -879,10 +888,10 @@ stops a runaway from hanging the tab.
 
 ## Status
 
-**Release Candidate** — APIs are stable, used in production, minor changes possible before v1.0.
+**Release Candidate**. APIs are stable, used in production, minor changes possible before v1.0.
 
 ---
 
 ## License
 
-**MIT** — Free to use in commercial and open-source projects.
+**MIT**. Free to use in commercial and open-source projects.

package/dist/types/store/Store.d.ts

@@ -337,42 +337,6 @@ export declare class Store<EM extends EventMapBase, R extends string, S extends
      * @internal
      */
     private reportCascade;
-    /**
-     * Checks if an event matches a `When` matcher.
-     *
-     * @param when - The When matcher (or undefined for "all events").
-     * @param event - The event to check.
-     * @returns `true` if the event matches, `false` otherwise.
-     *
-     * @remarks
-     * - `undefined` or missing `when` matches ALL events.
-     * - `{ any: true }` matches ALL events.
-     * - `{ keys: [...] }` matches if event's `[channel, type]` is in the array.
-     * - `{ channel: 'x' }` matches if event's channel equals 'x'.
-     * - `{ channels: ['x', 'y'] }` matches if event's channel is in the array.
-     *
-     * @internal
-     */
-    private matchesWhen;
-    /**
-     * Extracts the middleware function from a MiddlewareInput.
-     * Handles both raw functions (legacy) and MiddlewareSpec objects.
-     *
-     * @param input - MiddlewareInput (function or spec).
-     * @returns The middleware function.
-     *
-     * @internal
-     */
-    private getMiddlewareFunction;
-    /**
-     * Gets the `when` matcher from a MiddlewareInput.
-     *
-     * @param input - MiddlewareInput (function or spec).
-     * @returns The `when` matcher, or `undefined` for raw functions (match all).
-     *
-     * @internal
-     */
-    private getMiddlewareWhen;
     /**
      * Invokes all registered **effects** for a given event.
      * Handles both key-based effects (O(1) lookup) and pattern-based effects (runtime matching).
@@ -942,13 +906,7 @@ export declare class Store<EM extends EventMapBase, R extends string, S extends
      * the terminal event from ever being sent. Un-iterated progress therefore buffers to
      * `highWaterMark` and is then counted on {@link CallHandle.dropped} rather than blocking.
      *
-     * **This is a local primitive.** A reply cannot reach it from a federated peer: the federation
-     * envelope carries neither `meta` nor `parentId`, and ingress namespaces the channel, so
-     * neither correlation nor the reply route survives the hop. That is not an oversight to route
-     * around — federation answers cross-node request/reply with typed peer *queries*, which are
-     * gated by a responder policy that may concede or deny. A call that federated silently would
-     * turn that access decision into an accident of which channel someone named. Ask a peer with a
-     * query; use `call` within a process.
+     * **This is a local primitive.**
      *
      * @example Timeout is idle, not total
      * ```ts
@@ -1086,15 +1044,6 @@ export declare class Store<EM extends EventMapBase, R extends string, S extends
      * @internal
      */
     private unmountSlice;
-    /**
-     * Normalizes event targeting from `when` to an array of EventKeys.
-     *
-     * @param spec - Object with an optional `when` matcher.
-     * @returns Array of `[channel, type]` pairs.
-     *
-     * @internal
-     */
-    private normalizeEventKeys;
     /**
      * Reads a dotted path from an object (supports numeric array indices via string keys).
      *
@@ -1102,6 +1051,10 @@ export declare class Store<EM extends EventMapBase, R extends string, S extends
      * @param path - Dotted path; leading dot is ignored.
      * @returns The value at the path, or `undefined`.
      *
+     * @remarks
+     * A member rather than a bare import: a test replaces this on the instance to count how many
+     * walks describing a change costs, which only works while the callers go through `this`.
+     *
      * @internal
      */
     private getAtPath;

package/dist/types/store/matching.d.ts

@@ -0,0 +1,49 @@
+import { EventKey, EventMapBase, EventUnion, MiddlewareFunction, MiddlewareInput, When } from '../types.js';
+/**
+ * Checks if an event matches a `When` matcher.
+ *
+ * @param when - The When matcher (or undefined for "all events").
+ * @param event - The event to check.
+ * @returns `true` if the event matches, `false` otherwise.
+ *
+ * @remarks
+ * - `undefined` or missing `when` matches ALL events.
+ * - `{ any: true }` matches ALL events.
+ * - `{ keys: [...] }` matches if event's `[channel, type]` is in the array.
+ * - `{ channel: 'x' }` matches if event's channel equals 'x'.
+ * - `{ channels: ['x', 'y'] }` matches if event's channel is in the array.
+ *
+ * @internal
+ */
+export declare function matchesWhen<EM extends EventMapBase>(when: When<EM> | undefined, event: EventUnion<EM>): boolean;
+/**
+ * Extracts the middleware function from a MiddlewareInput.
+ * Handles both raw functions (legacy) and MiddlewareSpec objects.
+ *
+ * @param input - MiddlewareInput (function or spec).
+ * @returns The middleware function.
+ *
+ * @internal
+ */
+export declare function getMiddlewareFunction<St, EM extends EventMapBase>(input: MiddlewareInput<St, EM>): MiddlewareFunction<St, EM>;
+/**
+ * Gets the `when` matcher from a MiddlewareInput.
+ *
+ * @param input - MiddlewareInput (function or spec).
+ * @returns The `when` matcher, or `undefined` for raw functions (match all).
+ *
+ * @internal
+ */
+export declare function getMiddlewareWhen<St, EM extends EventMapBase>(input: MiddlewareInput<St, EM>): When<EM> | undefined;
+/**
+ * Normalizes event targeting from `when` to an array of EventKeys.
+ *
+ * @param spec - Object with an optional `when` matcher.
+ * @returns Array of `[channel, type]` pairs.
+ *
+ * @internal
+ */
+export declare function normalizeEventKeys<EM extends EventMapBase>(spec: {
+    when?: When<EM>;
+    events?: ReadonlyArray<EventKey<EM>>;
+}): ReadonlyArray<EventKey<EM>>;

package/dist/types/store/paths.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Reading and expanding dotted state paths.
+ *
+ * @remarks
+ * Moved out of `Store.ts` unchanged. Neither function touched an instance field.
+ *
+ * `Store` still exposes both as members, and deliberately so. `Store.buildAncestorPaths` is
+ * public API that appears in the committed reference, and `getAtPath` is replaced on the
+ * instance by a test that counts the walks a change description costs, so the internal callers
+ * have to keep reaching it through `this`.
+ *
+ * @module
+ */
+/**
+ * Reads a dotted path from an object (supports numeric array indices via string keys).
+ *
+ * @param obj - Root object (slice or value).
+ * @param path - Dotted path; leading dot is ignored.
+ * @returns The value at the path, or `undefined`.
+ *
+ * @internal
+ */
+export declare function getAtPath(obj: any, path: string): any;
+/**
+ * Builds ancestor paths for a dotted path.
+ *
+ * For `"a.b.c"`, returns `["a", "a.b", "a.b.c"]`. Leading dots are trimmed.
+ *
+ * @param path - Dotted path string.
+ * @returns Array of ancestor paths.
+ *
+ * @example
+ * ```ts
+ * buildAncestorPaths('x.y.z'); // ['x','x.y','x.y.z']
+ * ```
+ *
+ * @public
+ */
+export declare function buildAncestorPaths(path: string): string[];

package/dist/types/store/performCall.d.ts

@@ -0,0 +1,15 @@
+import { DeepReadonly, EffectSpec, EmitOptions, EmitResult, EventMapBase, EventUnion } from '../types.js';
+import { CallHandle, CallOptions } from './call.js';
+/**
+ * What `performCall` needs from the store.
+ *
+ * @remarks
+ * Three members, named rather than structural over the whole class, because three is few enough
+ * that naming them documents the coupling instead of hiding it.
+ */
+export interface CallDeps<St, EM extends EventMapBase> {
+    readonly idFactory: () => string;
+    readonly registerEffect: (spec: EffectSpec<DeepReadonly<St>, EM>) => () => void;
+    readonly emit: <C extends keyof EM & string, T extends keyof EM[C] & string>(channel: C, type: T, payload: EM[C][T], opts?: EmitOptions) => Promise<EmitResult>;
+}
+export declare function performCall<St, EM extends EventMapBase, C extends keyof EM & string, T extends keyof EM[C] & string>(deps: CallDeps<St, EM>, channel: C, type: T, payload: EM[C][T], opts: CallOptions<EM>): CallHandle<EventUnion<EM>, EventUnion<EM>>;

package/dist/types/store/rejection.d.ts

@@ -6,8 +6,8 @@
  *
  * @remarks
  * `Symbol.for` rather than `Symbol()`, so the brand survives two copies of this package meeting
- * at runtime — a duplicated dependency, a federated bundle, a consumer that pinned an older
- * minor. With a unique symbol the check would silently answer `false` across that boundary and a
+ * at runtime — a duplicated dependency, a bundle that inlined a second copy, a consumer that
+ * pinned an older minor. With a unique symbol the check would silently answer `false` across that boundary and a
  * refusal would read as ordinary state, which is the failure this whole feature exists to end.
  *
  * @internal