@yoltra/core 0.5.0 → 0.6.0

package/README.es.md

@@ -36,7 +36,7 @@ emit(channel, type, payload)
   │
   │  ══ fase de reduccion SINCRONA — corre antes de que emit() retorne ══
   ├─ 1. Middleware ─── Hooks pre-reducer sincronos (devolver false para rechazar → evento "no confirmado")
-  ├─ 2. Reducers ─── Actualizaciones de estado sincronas, deteccion de cambios de grano fino por ruta
+  ├─ 2. Reducers ─── Cada slice que aplica se prepara, y todas se confirman bajo una sola raiz
   ├─ 3. Suscriptores de eventos ─── Notificaciones de eventos confirmados/no confirmados
   ├─ 4. Suscriptores gruesos ─── Listeners externos del store (useSyncExternalStore, etc.), si el estado cambio
   │
@@ -276,6 +276,213 @@ store.onEvent(
 
 ---
 
+## Los commits son atomicos entre slices
+
+Un evento que toca varias slices las escribe todas y despues notifica. Nadie observa un evento
+aplicado a medias: un suscriptor de una slice que lee `getState()` ve todas las demas slices del
+mismo evento ya aplicadas.
+
+Esto importa sobre todo donde un cambio se usa como senal para volver a leer, que es lo que hacen
+los hooks de React.
+
+---
+
+## Rechazar una escritura
+
+Un reducer devuelve `Rejected(reason)` en lugar de estado para declinar. **Se rechaza el evento
+completo**: ninguna slice escribe, no se emite ninguna notificacion de cambio, y quien llamo sabe
+por que.
+
+```typescript
+import { createStore, Rejected } from "@yoltra/core";
+
+const store = createStore({
+  name: "plan",
+  reducer: {
+    plan: {
+      state: { steps: [], version: 1 },
+      when: { keys: [["plan", "patch"]] },
+      reducer: (state, event) =>
+        event.payload.expectedVersion === state.version
+          ? { ...state, steps: event.payload.steps, version: state.version + 1 }
+          : Rejected(`escritura obsoleta: esperaba v${event.payload.expectedVersion}`),
+    },
+  },
+  onRejected: (rejection, event, slice) => metrics.increment("write.refused", { slice }),
+});
+
+const result = await store.emit("plan", "patch", { steps, expectedVersion: 1 });
+
+result.committed; // true — el middleware lo permitio
+result.written; // false — pero no se escribio nada
+result.rejected?.reason;
+```
+
+Rechazar **no** es lo mismo que devolver el estado sin cambios, que es indistinguible de "este
+evento no me concierne". Tampoco es lo mismo que lanzar: un reducer que lanza tiene un bug, asi
+que su slice queda aislada y las demas si escriben, mientras que un reducer que rechaza ha tomado
+una decision a la que cede el evento entero.
+
+`emit` resuelve a un `EmitResult` cuando terminan los efectos:
+
+| | |
+|---|---|
+| `committed` | el middleware no lo veto |
+| `written` | un reducer cambio el estado de verdad |
+| `rejected` | presente cuando un reducer rechazo, con su `reason` |
+
+La fase `written` de `onEvent` reporta lo mismo a los suscriptores. `committed` sigue
+significando **no vetado** y no se estrecho a proposito: se dispara para todo evento que el
+middleware permite, incluidos todos los eventos de un store sin reducers — la forma que toma un
+bus de notificaciones o de analitica.
+
+---
+
+## Peticion y respuesta — `store.call()`
+
+Todo consumidor de un bus de eventos acaba escribiendo peticion/respuesta a mano: generar un id,
+suscribirse, emparejar, expirar, desuscribirse. Son unas ochenta lineas y siempre traen los
+mismos dos bugs: la suscripcion sobrevive a la llamada, y `Quien Responde` que olvida devolver el
+id produce un timeout sin nada a lo que apuntar.
+
+```typescript
+const res = await store.call("rpc", "ask", { q: "quien?" }, { reply: ["rpc", "answer"] });
+res.payload.text;
+```
+
+`Quien Responde` no hace nada especial. Responde con el `emit` que recibio, y la marca causal del
+store correlaciona ambos: **no hay id que generar, devolver ni olvidar**.
+
+```typescript
+store.registerEffect({
+  when: { keys: [["rpc", "ask"]] },
+  effect: async (event, _get, emit) => {
+    await emit("rpc", "answer", await lookup(event.payload.q));
+  },
+});
+```
+
+### Una llamada resuelve al evento, no al payload
+
+Porque muchas veces quien llama no sabe *cual* respuesta va a recibir. `reply` nombra los tipos
+**terminales**, y el evento trae el discriminante:
+
+```typescript
+const res = await store.call("rpc", "ask", { q }, { reply: ["rpc", ["answer", "error"]] });
+
+switch (res.type) {
+  case "answer": return res.payload.text;
+  case "error": throw new Error(res.payload.reason);
+}
+```
+
+### El progreso se transmite, y el productor espera
+
+Cualquier evento correlacionado que **no** sea terminal es progreso. Itera la llamada para
+consumirlo:
+
+```typescript
+const call = store.call("job", "start", { id }, { reply: ["job", "done"], highWaterMark: 4 });
+
+for await (const step of call) await render(step.payload);
+const { payload } = await call;
+```
+
+La contrapresion es real, no un buffer con limite. `emit` resuelve solo cuando terminan sus
+efectos, y el colector es un efecto que no retorna hasta que el consumidor tomo el elemento — asi
+que un `Quien Responde` que escribe `await emit("job", "tick", chunk)` **va al ritmo del lector**.
+
+La contrapresion entra en juego **cuando empiezas a iterar**. Una llamada que solo se espera con
+`await` nunca extrae nada, asi que bloquear a su productor causaria un interbloqueo de la propia
+llamada: el progreso que nadie lee impediria que se enviara el evento terminal. Por eso el
+progreso no iterado se almacena hasta `highWaterMark` y despues se cuenta en `call.dropped`.
+
+### Retroceso
+
+| | |
+|---|---|
+| `timeoutMs` | **Inactividad**, no total: todo evento correlacionado lo reinicia, incluido el progreso. Por defecto 30s. |
+| `signal` | Un `AbortSignal`, para una fecha limite real o una accion cancelada. |
+| `call.cancel(reason)` | Deja de escuchar y liquida la llamada. |
+
+Termine como termine, la suscripcion se elimina y se libera cualquier productor detenido por la
+contrapresion. Un `Quien Responde` atascado es peor que el buffer sin limite que esto reemplazo.
+
+---
+
+## Leer un valor al suscribirse
+
+`connect` empieza en "de ahora en adelante", asi que la primera lectura habia que repetirla en
+otro lado — la misma ruta en dos sitios, libres de divergir:
+
+```typescript
+store.connect({ reducer: "todos", property: "items.0.title" }, render, { immediate: true });
+```
+
+El primer cambio sintetico trae `oldValue: undefined` y **sin procedencia**, porque ningun evento
+lo causo. React no lo necesita: `useSyncExternalStore` ya lee una instantanea al montar.
+
+---
+
+## De donde vino un cambio
+
+Un `Change` nombra el evento que lo causo, asi que un suscriptor ya no tiene que duplicar la causa
+dentro del estado:
+
+```typescript
+store.connect({ reducer: "orders", property: "status" }, (change) => {
+  audit.record(change.path, change.newValue, {
+    causedBy: change.eventId,
+    via: `${change.channel}/${change.type}`,
+  });
+});
+```
+
+La procedencia esta **ausente** cuando ningun evento causo el cambio — un salto de time-travel de
+DevTools, o la entrega `immediate` de arriba. La ausencia es la senal, en vez de un id inventado.
+
+---
+
+## Proteccion contra cascadas (activada por defecto)
+
+Dos consumidores conectados entre si — un suscriptor que emite lo que su propio reducer atiende, o
+dos slices que atienden los eventos de la otra — producen una cadena de eventos sin final. La cola
+de reduccion se drena de forma **sincrona**, asi que eso no es un programa lento: es una pestana
+congelada, o un core al 100%, sin error ni stack al que apuntar.
+
+Por eso cada evento lleva su posicion causal, y el store se niega a extender una cadena mas alla
+de un tope:
+
+```typescript
+const store = createStore({
+  name: "app",
+  reducer: { ... },
+
+  // Por defecto 64. Acotado configures o no: un fallo tan grave no deberia exigir
+  // configuracion para evitarse. Usa Infinity para renunciar a el conscientemente.
+  maxReduceDepth: 64,
+
+  onCascade: ({ event, depth, chain }) => {
+    report(`cascada en ${event.channel}/${event.type}, profundidad ${depth}`, chain);
+  },
+});
+```
+
+Un evento emitido mientras se atiende otro esta un nivel mas abajo que su causa, y lleva
+`parentId` y `depth` para que el ciclo sea legible despues. Ambos campos estan **ausentes** en un
+evento raiz, asi que los eventos que emite tu aplicacion siguen siendo identicos byte a byte.
+
+Superar el tope no lanza. El emit ofensor se rechaza, lo ya confirmado se mantiene, y `onCascade`
+(mas un error en consola) lo nombra — lanzar apareceria en el suscriptor o efecto que casualmente
+estuviera emitiendo, que es justo el fallo inatribuible que el tope existe para evitar.
+
+**Una rafaga ancha no es una cascada.** Un evento cuyo suscriptor emite quinientos hermanos es una
+forma legitima; la profundidad es lo que la distingue de un ciclo, y un bucle normal de
+`store.emit` nunca acumula profundidad. `maxTransitionsPerDrain` acota el *ancho* y por eso viene
+desactivado.
+
+---
+
 ## Deduplicacion de Eventos (opt-in)
 
 La deduplicacion esta **desactivada por defecto** — yoltra nunca descarta en silencio eventos
@@ -434,12 +641,12 @@ store.registerEffect({
 
 ## Rendimiento
 
-| Metrica               | Valor                                     |
-| --------------------- | ----------------------------------------- |
-| **Tamano del bundle** | ~8KB (minificado + gzipped)               |
-| **Tree-shakeable**    | Si (modulos ES)                           |
-| **Dependencias**      | Cero                                      |
-| **TypeScript**        | Definiciones de tipos completas incluidas |
+| Metrica               | Valor                                       |
+| --------------------- | ------------------------------------------- |
+| **Tamano del bundle** | 9.2 KB para el store (minificado + gzipped) |
+| **Tree-shakeable**    | Si (modulos ES)                             |
+| **Dependencias**      | Cero                                        |
+| **TypeScript**        | Definiciones de tipos completas incluidas   |
 
 ---
 

package/README.md

@@ -36,7 +36,7 @@ emit(channel, type, payload)
   │
   │  ══ SYNCHRONOUS reduce phase — runs before emit() returns ══
   ├─ 1. Middleware ─── Synchronous pre-reducer hooks (return false to reject → "uncommitted" event)
-  ├─ 2. Reducers ─── Synchronous state updates, fine-grained path change detection
+  ├─ 2. Reducers ─── Every matching slice staged, then all committed under one root
   ├─ 3. Event subscribers ─── Committed/uncommitted event notifications
   ├─ 4. Coarse subscribers ─── External store listeners (useSyncExternalStore, etc.), if state changed
   │
@@ -316,7 +316,17 @@ store.onEvent(
   "uncommitted",
 );
 
-// All events — both committed and uncommitted
+// Written events — state actually changed. Fires after the commit, so getState() is current.
+store.onEvent(
+  "plan",
+  "patch",
+  (event, getState) => {
+    console.log("applied:", getState().plan);
+  },
+  "written",
+);
+
+// All events — both committed and uncommitted (not written; see below)
 store.onEvent(
   "ui",
   "action",
@@ -327,6 +337,185 @@ 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
+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.
+
+---
+
+## 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
+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.
+
+---
+
+## Refusing a write
+
+A reducer returns `Rejected(reason)` instead of state to decline. **The whole event is rejected**:
+no slice writes, no change notification fires, and the caller is told why.
+
+```typescript
+import { createStore, Rejected } from "@yoltra/core";
+
+const store = createStore({
+  name: "plan",
+  reducer: {
+    plan: {
+      state: { steps: [], version: 1 },
+      when: { keys: [["plan", "patch"]] },
+      reducer: (state, event) =>
+        event.payload.expectedVersion === state.version
+          ? { ...state, steps: event.payload.steps, version: state.version + 1 }
+          : Rejected(`stale write: expected v${event.payload.expectedVersion}, have v${state.version}`),
+    },
+  },
+  onRejected: (rejection, event, slice) => metrics.increment("write.refused", { slice }),
+});
+
+const result = await store.emit("plan", "patch", { steps, expectedVersion: 1 });
+
+result.committed; // true — middleware allowed it
+result.written; // false — but nothing was written
+result.rejected?.reason; // "stale write: expected v1, have v3"
+```
+
+Refusing is **not** the same as returning the state unchanged, which is indistinguishable from
+"this event did not concern me". It is also not the same as throwing: a reducer that throws has a
+bug, so its slice is isolated and every other slice still commits, while a reducer that refuses
+has made a decision and the whole event yields to it.
+
+`emit` resolves to an `EmitResult` once effects have run:
+
+| | |
+|---|---|
+| `committed` | middleware did not veto |
+| `written` | a reducer actually changed state |
+| `rejected` | present when a reducer refused, carrying `reason` |
+
+---
+
+## 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
+subscription outlives the call, and a responder that forgets to echo the id produces a timeout
+with nothing to point at.
+
+```typescript
+const res = await store.call("rpc", "ask", { q: "who?" }, { reply: ["rpc", "answer"] });
+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**:
+
+```typescript
+store.registerEffect({
+  when: { keys: [["rpc", "ask"]] },
+  effect: async (event, _get, emit) => {
+    await emit("rpc", "answer", await lookup(event.payload.q));
+  },
+});
+```
+
+### A call resolves to the event, not the payload
+
+Because a caller often cannot know *which* reply it will get. `reply` names the **terminal**
+types, and the event carries the discriminant:
+
+```typescript
+const res = await store.call("rpc", "ask", { q }, { reply: ["rpc", ["answer", "error"]] });
+
+switch (res.type) {
+  case "answer": return res.payload.text;
+  case "error": throw new Error(res.payload.reason);
+}
+```
+
+### Progress streams, and the producer waits
+
+Any correlated event that is **not** terminal is progress. Iterate the call to consume it:
+
+```typescript
+const call = store.call("job", "start", { id }, {
+  reply: ["job", "done"],
+  highWaterMark: 4,
+});
+
+for await (const step of call) await render(step.payload);
+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 —
+so a responder writing `await emit("job", "tick", chunk)` is **paced by the reader**:
+
+```typescript
+effect: async (_event, _get, emit) => {
+  for (const chunk of chunks) {
+    await emit("job", "tick", chunk); // waits here while the consumer is behind
+  }
+  await emit("job", "done", { ok: true });
+}
+```
+
+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
+terminal event from ever being sent. Un-iterated progress therefore buffers to `highWaterMark`
+and is then counted on `call.dropped` rather than blocking.
+
+### Giving up
+
+| | |
+|---|---|
+| `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
+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 —
+the same path in two places, free to drift:
+
+```typescript
+store.connect({ reducer: "todos", property: "items.0.title" }, render, { immediate: true });
+```
+
+The synthetic first change has `oldValue: undefined` and **no provenance**, because no event
+caused it. For a wildcard pattern, which has no single current value, the slice root is delivered
+with `path: ""`.
+
+React does not need this: `useSyncExternalStore` already reads a snapshot on mount.
+
+---
+
+## Where a change came from
+
+A `Change` names the event that caused it, so a subscriber no longer has to mirror the cause into
+state and keep it in two places:
+
+```typescript
+store.connect({ reducer: "orders", property: "status" }, (change) => {
+  audit.record(change.path, change.newValue, {
+    causedBy: change.eventId,
+    via: `${change.channel}/${change.type}`,
+  });
+});
+```
+
+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)
@@ -350,6 +539,57 @@ 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
+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.
+
+Every event therefore carries its causal position, and the store refuses to extend a chain past a
+ceiling:
+
+```typescript
+const store = createStore({
+  name: "app",
+  reducer: { ... },
+
+  // 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,
+
+  onCascade: ({ event, depth, chain }) => {
+    report(`cascade at ${event.channel}/${event.type}, depth ${depth}`, chain);
+  },
+});
+```
+
+An event emitted while another is being handled is one deeper than its cause, and carries
+`parentId` and `depth` so the cycle is legible after the fact:
+
+```typescript
+store.onEvent("plan", "patch", (event) => {
+  event.depth;     // 0 for an event emitted by application code
+  event.parentId;  // undefined at depth 0; the causing event's id below it
+});
+```
+
+Both fields are **absent** on a root event rather than present as `0`/`undefined`, so events your
+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
+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
+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.
+
+---
+
 ## Dynamic Reducers
 
 Add or remove reducer slices at runtime:
@@ -575,7 +815,7 @@ individual fields edited is better off as an array today.
 
 | Metric             | Value                                     |
 | ------------------ | ----------------------------------------- |
-| **Bundle size**    | 6.7 KB for the store (minified + gzipped) |
+| **Bundle size**    | 9.2 KB for the store (minified + gzipped) |
 | **Tree-shakeable** | Yes (ES modules)                          |
 | **Dependencies**   | Zero                                      |
 | **TypeScript**     | Full type definitions included            |
@@ -586,16 +826,21 @@ would — tree-shaken, minified, gzipped — and fails when it exceeds the budge
 
 The number that matters is what you import, not what the package exports:
 
-| Import                              | Size   |
-| ----------------------------------- | ------ |
-| `{ createStore }`                   | 6.7 KB |
-| `{ createStore, hydrate, persist }` | 8.2 KB |
-| everything                          | 9.5 KB |
-
-Persistence and the entity adapter cost nothing to anyone who does not import them — the
-first row has not moved as either was added, which is the tree-shaking claim being checked
-rather than repeated. The last row is a growth tripwire; `import * as all` is not something
-anybody writes.
+| Import                              | Size    | Budget |
+| ----------------------------------- | ------- | ------ |
+| `{ createStore }`                   | 9.2 KB  | 14 KB  |
+| `{ createStore, hydrate, persist }` | 10.7 KB | 16 KB  |
+| everything                          | 12.1 KB | 18 KB  |
+
+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
+past the store. The last row is a growth tripwire; `import * as all` is not something anybody
+writes.
+
+The first row moves only when the store itself grows, and it has: bounding cascades, staging
+commits so they apply atomically, and `store.call()` are all store machinery rather than
+opt-in modules, so they are paid by everyone. That is the honest trade for a default that
+stops a runaway from hanging the tab.
 
 ---
 

package/dist/types/index.d.ts

@@ -9,10 +9,15 @@ export { EventBus } from './eventBus/EventBus.js';
 export { LooseEventBus } from './eventBus/LooseEventBus.js';
 export { Reducer } from './reducer/Reducer.js';
 export { Store, createStore, typedEvents } from './store/Store.js';
+export { Rejected, isRejected } from './store/rejection.js';
+export { CallAbortedError, CallTimeoutError } from './store/call.js';
+export type { CallHandle, CallOptions, ReplySpec } from './store/call.js';
+export type { Rejection } from './store/rejection.js';
 export { detectChangedProps } from './utils/detectChangedProps.js';
 export { freezeState } from './utils/immutability.js';
+export type { AliasWatch } from './utils/immutability.js';
 export { eventKeys } from './types.js';
-export type { EventMapBase, EventKey, Event, EventUnion, Change, Emit, EmitOptions, EventMeta, InstrumentedEvent, InstrumentationObserver, Unsubscribe, StoreSpec, StoreInstance, ReducerSpec, ReducerFunction, ReducersMapAny, StateFromReducers, EMFromReducersStrict, EffectSpec, EffectFunction, MiddlewareFunction, MiddlewareSpec, MiddlewareInput, DeepReadonly, DeepRO, Primitive, RootValue, Path, PathValue, WithGlob, Dotted, EventPhase, EventSubscriptionHandler, NarrowedEventHandler, When, EventFromWhen, EventConsumerType, EventConsumerMeta, } from './types.js';
+export type { EventMapBase, EventKey, Event, EventUnion, Change, Emit, EmitOptions, EmitResult, ConnectOptions, EventMeta, InstrumentedEvent, CascadeInfo, InstrumentationObserver, Unsubscribe, StoreSpec, StoreInstance, ReducerSpec, ReducerFunction, ReducersMapAny, StateFromReducers, EMFromReducersStrict, EffectSpec, EffectFunction, MiddlewareFunction, MiddlewareSpec, MiddlewareInput, DeepReadonly, DeepRO, Primitive, RootValue, Path, PathValue, WithGlob, Dotted, EventPhase, NotifiedPhase, EventSubscriptionHandler, NarrowedEventHandler, When, EventFromWhen, EventConsumerType, EventConsumerMeta, } from './types.js';
 export { createEntityAdapter } from './entity/entityAdapter.js';
 export type { EntityAdapter, EntityAdapterOptions, EntityId, EntityState, EntityUpdate, } from './entity/entityAdapter.js';
 export { decodeState, encodeState, encodeStateBounded } from './serialize/codec.js';

package/dist/types/persistence/persist.d.ts

@@ -84,10 +84,6 @@ export interface Hydration {
 export declare function hydrate(options: PersistOptions & {
     readonly source?: string;
 }): Promise<Hydration>;
-/** A reducer spec, as far as hydration cares: something carrying an initial `state`. */
-interface HasState {
-    state: unknown;
-}
 /**
  * Replaces each reducer's initial state with what was restored for it.
  *
@@ -97,7 +93,9 @@ interface HasState {
  *
  * @public
  */
-export declare function withHydration<R extends Record<string, HasState>>(reducers: R, hydration: Hydration): R;
+export declare function withHydration<R extends Record<string, {
+    state: unknown;
+}>>(reducers: R, hydration: Hydration): R;
 /** The store surface persistence needs, which is two methods wide. */
 export interface PersistableStore {
     getState(): unknown;
@@ -123,4 +121,3 @@ export declare function persist(store: PersistableStore, options: PersistOptions
  * @public
  */
 export declare function dehydrate(store: Pick<PersistableStore, "getState">, options: Pick<PersistOptions, "version" | "slices">): string;
-export {};

package/dist/types/reducer/Reducer.d.ts

@@ -1,4 +1,5 @@
 import { EventMapBase, EventUnion, ReducerFunction } from '../types.js';
+import { Rejection } from '../store/rejection.js';
 /**
  * Thin wrapper around a pure reducer function (stateful event consumer):
  * given a state `S` and an event (from {@link EventUnion | `EventUnion<EM>`}),
@@ -68,7 +69,7 @@ export declare class Reducer<S, EM extends EventMapBase = EventMapBase> {
      *
      * @param state  - Current state.
      * @param event - An event drawn from {@link EventUnion | `EventUnion<EM>`}.
-     * @returns The next state produced by the underlying reducer function.
+     * @returns The next state, or a {@link Rejection} if the reducer refused the write.
      *
      * @example
      * ```ts
@@ -77,5 +78,5 @@ export declare class Reducer<S, EM extends EventMapBase = EventMapBase> {
      *
      * @public
      */
-    reduce(state: S, event: EventUnion<EM>): S;
+    reduce(state: S, event: EventUnion<EM>): S | Rejection;
 }