@yoltra/core 0.7.0 → 0.8.0

package/README.es.md

@@ -5,8 +5,10 @@
 > 👉 🇲🇽 Versión en Español  |
 >  [ 🇺🇸 English Versión](./README.md) 
 
-![npm downloads](https://badgen.net/npm/dm/@yoltra/core)
-![License](https://badgen.net/npm/license/@yoltra/core)
+[![versión npm](https://img.shields.io/npm/v/@yoltra/core)](https://www.npmjs.com/package/@yoltra/core)
+[![descargas npm](https://img.shields.io/npm/dm/@yoltra/core)](https://www.npmjs.com/package/@yoltra/core)
+[![tipos](https://img.shields.io/npm/types/@yoltra/core)](https://www.npmjs.com/package/@yoltra/core)
+[![Licencia](https://img.shields.io/npm/l/@yoltra/core)](https://github.com/yoltra/yoltra/blob/main/LICENSE)
 
 **Contenedor de estado orientado a eventos, agnóstico de framework, con suscripciones de grano
 fino por ruta.**
@@ -231,7 +233,8 @@ const adminGuard: MiddlewareSpec<AppState, AppEM> = {
   meta: { type: "middleware", name: "adminGuard" },
 };
 
-// Middleware global: se ejecuta para todos los eventos (sincrono: devuelve un boolean, nunca una Promise)
+// Middleware global: se ejecuta para todos los eventos. Sincrono, nunca una Promise: solo un
+// `false` explicito veta, asi que un middleware que solo observa puede no devolver nada.
 const logger = (state, event) => {
   console.log("Event:", event.channel, event.type);
   return true;
@@ -331,6 +334,25 @@ store.onEvent(
 );
 ```
 
+### Suscriptores de eventos y viaje en el tiempo
+
+**El replay no llama a tus handlers.** Recorrer una línea de tiempo de DevTools vuelve a reducir
+los eventos, así que el estado sigue el recorrido, pero los handlers de `onEvent` permanecen en
+silencio. Antes se ejecutaban igual que con un evento real, así que arrastrar la línea de tiempo
+volvía a publicar a los pares, a escribir en sockets y a disparar analítica por eventos que no
+estaban ocurriendo de nuevo, sin nada dentro del handler que permitiera notar la diferencia.
+
+Un handler que deriva estado de vista puramente del flujo de eventos, y que no hace E/S, puede
+activarlo:
+
+```ts
+store.onEvent("ui", "save", handler, "committed", { duringReplay: true });
+```
+
+`store.isReplaying` existe para lo que deba ramificar en lugar de simplemente omitirse. Los
+suscriptores gruesos de `subscribe` y las suscripciones de `connect` siguen disparándose, porque
+el estado sí cambió y la interfaz tiene que seguir el recorrido.
+
 ---
 
 ## Los commits son atómicos entre slices
@@ -577,6 +599,65 @@ const dispose = store.registerReducer("filters", {
 dispose();
 ```
 
+### Decorar un store, con sus tipos
+
+Una slice agregada en runtime era invisible para el sistema de tipos: `registerReducer`
+recibía un `string` y devolvía un disposer, así que nada aguas abajo sabía que la slice
+existía ni qué forma tenía. `withSlice` devuelve **el mismo store, re-tipado**:
+
+```typescript
+type TransferEM = { transfer: { granted: { id: string } } };
+
+const transfers = defineSlice<TransferEM>()({
+  state: { granted: [] as string[] },
+  when: { keys: [["transfer", "granted"]] },
+  reducer: (s, e) => (e.type === "granted" ? { granted: [...s.granted, e.payload.id] } : s),
+});
+
+const app = store.withSlice("transfers", transfers, { owner: "@scope/transfers" });
+
+app.getState().transfers.granted; // string[]
+app.emit("transfer", "granted", { id: "a1" }); // el canal nuevo ya es emitible
+```
+
+`withMiddleware` y `withEffect` hacen lo mismo para el mapa de eventos. Las llamadas se
+encadenan, y una librería publica un decorador tomando un store y devolviendo otro:
+
+```typescript
+export function withTransfers<R extends string, S extends Record<R, any>, EM extends EventMapBase>(
+  store: StoreInstance<R, S, EM>,
+  config: TransfersConfig,
+) {
+  return store.withSlice("transfers", transfers, { owner: "@scope/transfers" });
+}
+
+// Los decoradores se anidan, en cualquier orden.
+const decorated = withTransfers(withDevtools(store, dtConfig), config);
+```
+
+**Por qué los builders.** El `when` de un spec lleva cadenas de canal y tipo, no tipos de
+payload, así que el mapa de eventos que aporta una decoración no puede inferirse de ahí, y
+TypeScript no tiene inferencia parcial de argumentos de tipo. `defineSlice<EM>()` lo coloca en
+posición de valor, donde la inferencia sí funciona, así que ningún sitio de registro necesita
+un argumento de tipo ni un cast. Una consecuencia que conviene conocer: **una función de
+middleware sin spec nunca puede ampliar el mapa de eventos**, porque el parámetro de evento de
+`MiddlewareFunction` es un tipo mapeado del que no se puede inferir nada de vuelta. Solo la
+forma de spec de `defineMiddleware` puede.
+
+**Es el mismo objeto.** Nada se vuelve a suscribir, ningún estado se mueve, y una llamada
+`store.call()` en vuelo no se ve afectada. Solo cambia el tipo.
+
+**Orden.** Decora en el ámbito del módulo, una vez, antes del primer render. Entre
+`createStore` y la decoración la slice realmente no existe, y un componente que la lea verá
+`undefined` hasta que exista.
+
+**Disposición.** `withSlice` no devuelve disposer a propósito: después de ejecutarlo, el tipo
+ampliado sigue prometiendo una slice que ya no está, y ningún sistema de tipos puede expresar
+"válido hasta esa llamada". Usa `registerSlice` cuando la slice sea tuya y necesites
+desmontarla, y mantén ese disposer privado a la librería. Leer una slice desmontada lanza un
+error con nombre en desarrollo, en lugar de devolver `undefined` desde un tipo que prometía un
+valor.
+
 ---
 
 ## Hot Module Replacement
@@ -605,6 +686,32 @@ if (import.meta.hot) {
 }
 ```
 
+### `replace*` reemplaza lo que tú escribiste, no lo que agregó una librería
+
+Un reducer, middleware o efecto registrado **después** de la construcción, con
+`registerReducer`, `registerMiddleware` o `registerEffect`, sobrevive a una llamada a
+`replace*`. Esos registros nunca formaron parte del conjunto que estás reemplazando: nadie que
+escribe `replaceReducers(myReducers)` quiere decir "y ademas borra la slice que montó devtools,
+junto con su estado".
+
+Antes ocurría lo contrario, lo que hacía que la línea de HMR de arriba borrara la slice de una
+librería y su estado al primer guardado de archivo, sin error y sin advertencia. Es también la
+razón por la que una llamada `store.call()` en vuelo ya no muere a mitad de recarga: su
+listener de respuesta pertenece al propio store.
+
+Pasa `{ scope: "all" }` para el comportamiento anterior, que un arnés de pruebas que reinicia un
+store entre casos sí puede querer:
+
+```typescript
+store.replaceReducers(nextReducers, { scope: "all" });
+store.hotReplace({ reducer: nextReducers, scope: "all" }); // se reenvía a los tres
+```
+
+Una aplicación que declara una slice que una librería ya montó recibe un error que nombra la
+slice, en lugar de una apropiación silenciosa que deja a la librería con un disposer de algo que
+ya no es suyo. En desarrollo, `replace*` registra en nivel debug cuando preservó algo, así que
+"por qué sigue disparándose ese efecto tras la recarga" tiene respuesta.
+
 ---
 
 ## Mejores Prácticas
@@ -667,7 +774,8 @@ store.registerEffect({
 | `store.getState()`                              | Obtener snapshot del estado actual (solo lectura)     |
 | `store.subscribe(listener)`                     | Suscripción gruesa (cualquier cambio de estado)       |
 | `store.connect(spec, handler)`                  | Suscripción de grano fino por ruta con wildcards      |
-| `store.onEvent(channel, type, handler, phase?)` | Suscripción a eventos (committed/uncommitted/all)     |
+| `store.onEvent(channel, type, handler, phase?, options?)` | Suscripción a eventos (committed/uncommitted/written/all). Silenciosa durante el replay salvo `{ duringReplay: true }` |
+| `store.onRegistrationChange(observer, opts?)` | Avisa cuando el store gana o pierde un reducer, middleware o efecto |
 | `store.onEffect(channel, type, handler)`        | Shorthand de efecto para un solo evento               |
 | `store.dispose()`                               | Limpiar timers y recursos                             |
 
@@ -675,6 +783,10 @@ store.registerEffect({
 
 | API                                 | Descripción                               |
 | ----------------------------------- | ----------------------------------------- |
+| `store.registerSlice(name, spec, opts?)` | Agrega un slice en runtime; devuelve el store re-tipado y un disposer |
+| `store.withSlice(name, spec, opts?)` | Igual, devolviendo el store re-tipado para encadenar |
+| `store.withMiddleware(mw)`, `store.withEffect(spec)` | Registra y amplía el mapa de eventos |
+| `defineSlice<EM>()`, `defineMiddleware<EM>()`, `defineEffect<EM>()` | Declara el mapa de eventos que aporta un spec |
 | `store.registerReducer(name, spec)` | Agregar un slice en tiempo de ejecución   |
 | `store.registerMiddleware(fn)`      | Agregar middleware en tiempo de ejecución |
 | `store.registerEffect(spec)`        | Agregar un efecto en tiempo de ejecución  |
@@ -683,10 +795,10 @@ store.registerEffect({
 
 | API                                     | Descripción                                 |
 | --------------------------------------- | ------------------------------------------- |
-| `store.replaceReducers(reducers, opts)` | Reemplazar todos los reducers               |
-| `store.replaceMiddleware(middleware)`   | Reemplazar todos los middleware             |
-| `store.replaceEffects(effects)`         | Reemplazar todos los efectos                |
-| `store.hotReplace(partial)`             | Reemplazar cualquier subconjunto de una vez |
+| `store.replaceReducers(reducers, opts)`     | Reemplaza los reducers del spec; los de runtime sobreviven salvo `{ scope: "all" }` |
+| `store.replaceMiddleware(middleware, opts)` | Reemplaza el middleware del spec; misma regla |
+| `store.replaceEffects(effects, opts)`       | Reemplaza los efectos del spec; misma regla   |
+| `store.hotReplace(partial)`                 | Reemplaza cualquier subconjunto; reenvía `scope` |
 
 ### Helpers
 
@@ -810,9 +922,9 @@ La cifra que importa es lo que importas, no lo que el paquete exporta:
 <!-- size-table:start -->
 | Import | Tamaño | Presupuesto |
 | --- | --- | --- |
-| `{ createStore }` | 8.3 KB | 14 KB |
-| `{ createStore, hydrate, persist }` | 9.7 KB | 16 KB |
-| todo | 11.2 KB | 18 KB |
+| `{ createStore }` | 11.5 KB | 14 KB |
+| `{ createStore, hydrate, persist }` | 12.8 KB | 16 KB |
+| todo | 14.2 KB | 18 KB |
 <!-- size-table:end -->
 
 Estas son cifras de **producción**: lo que públicas una vez que tu empaquetador define
@@ -837,6 +949,10 @@ es algo que nadie escriba.
   Hooks de React y Suspense
 - **[Guia de Inicio Rápido](https://github.com/yoltra/yoltra/blob/main/docs/en/QUICK_START_GUIDE.md)**:
   Cinco pasos hacia una app funcional
+- **[Actualizar a 0.8.0](https://github.com/yoltra/yoltra/blob/main/docs/es/UPGRADE_0.8.md)**:
+  Cinco cambios de comportamiento, y un riesgo si haces rollback
+- **[Guía de Decoración](https://github.com/yoltra/yoltra/blob/main/docs/es/DECORATION_GUIDE.md)**:
+  Agregar una slice, middleware o efecto al store de alguien más, con los tipos
 - **[Arquitectura de Cola de Eventos](https://github.com/yoltra/yoltra/blob/main/docs/en/design/event-queue-architecture.md)**:
   Inmersión técnica profunda
 - **[Comparación de Bibliotecas](https://github.com/yoltra/yoltra/blob/main/docs/en/design/state-management-library-comparison.md)**:

package/README.md

@@ -5,8 +5,10 @@
 > [ 🇲🇽 Versión en Español](./README.es.md) 
 > |   👉 🇺🇸 English Version
 
-![npm downloads](https://badgen.net/npm/dm/@yoltra/core)
-![License](https://badgen.net/npm/license/@yoltra/core)
+[![npm version](https://img.shields.io/npm/v/@yoltra/core)](https://www.npmjs.com/package/@yoltra/core)
+[![npm downloads](https://img.shields.io/npm/dm/@yoltra/core)](https://www.npmjs.com/package/@yoltra/core)
+[![types](https://img.shields.io/npm/types/@yoltra/core)](https://www.npmjs.com/package/@yoltra/core)
+[![License](https://img.shields.io/npm/l/@yoltra/core)](https://github.com/yoltra/yoltra/blob/main/LICENSE)
 
 **Framework-agnostic event-driven state container with fine-grained path subscriptions.**
 
@@ -212,7 +214,10 @@ const globalLogger = {
 ## Middleware
 
 Middleware runs **synchronously, before** reducers and can cancel event propagation (return
-`false` to reject → "uncommitted" event). Async work belongs in effects, not middleware. Supports
+`false` to reject → "uncommitted" event; returning nothing allows it). Async work belongs in
+effects, not middleware. When an event does not commit, `emit` says why: `reason` is
+`"vetoed"`, `"deduped"` or `"cascade"`, and a veto names the middleware in `vetoedBy`, so a
+guard refusing an action is distinguishable from a double-click being collapsed. Supports
 both raw functions (legacy) and `MiddlewareSpec` objects with targeting:
 
 ```typescript
@@ -228,7 +233,8 @@ 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, never a Promise: only an explicit
+// `false` vetoes, so middleware that just observes can return nothing at all.
 const logger = (state, event) => {
   console.log("Event:", event.channel, event.type);
   return true;
@@ -343,6 +349,24 @@ all. `written` is the stricter fact, added rather than substituted, so toasts an
 working unchanged. `all` stays `committed | uncommitted`; folding `written` in would hand existing
 subscribers a second notification per event.
 
+### Event subscribers and time-travel
+
+**Replay does not call your handlers.** Scrubbing a DevTools timeline reduces the events again,
+so state follows the scrub, but `onEvent` handlers stay silent. They used to run exactly as they
+do for a live event, which meant dragging a timeline re-published to peers, re-wrote to sockets
+and re-fired analytics for events that were not happening again, with nothing available inside a
+handler to tell the difference.
+
+A handler that derives view state purely from the event stream, and performs no I/O, can opt in:
+
+```ts
+store.onEvent("ui", "save", handler, "committed", { duringReplay: true });
+```
+
+`store.isReplaying` is there for anything that has to branch rather than simply skip. Coarse
+`subscribe` listeners and `connect` subscriptions keep firing throughout, because the state
+genuinely did change and the UI has to follow the scrub.
+
 ---
 
 ## Commits are atomic across slices
@@ -605,6 +629,63 @@ const dispose = store.registerReducer("filters", {
 dispose();
 ```
 
+### Decorating a store, with its types
+
+A slice added at runtime used to be invisible to the type system: `registerReducer` took a
+plain `string` and returned a bare disposer, so nothing downstream knew the slice existed or
+what shape it had. `withSlice` returns **the same store, re-typed**:
+
+```typescript
+type TransferEM = { transfer: { granted: { id: string } } };
+
+const transfers = defineSlice<TransferEM>()({
+  state: { granted: [] as string[] },
+  when: { keys: [["transfer", "granted"]] },
+  reducer: (s, e) => (e.type === "granted" ? { granted: [...s.granted, e.payload.id] } : s),
+});
+
+const app = store.withSlice("transfers", transfers, { owner: "@scope/transfers" });
+
+app.getState().transfers.granted; // string[]
+app.emit("transfer", "granted", { id: "a1" }); // the new channel is emittable
+```
+
+`withMiddleware` and `withEffect` do the same for the event map. Calls chain, and a library
+publishes a decorator by taking a store and returning one:
+
+```typescript
+export function withTransfers<R extends string, S extends Record<R, any>, EM extends EventMapBase>(
+  store: StoreInstance<R, S, EM>,
+  config: TransfersConfig,
+) {
+  return store.withSlice("transfers", transfers, { owner: "@scope/transfers" });
+}
+
+// Decorators nest, in any order.
+const decorated = withTransfers(withDevtools(store, dtConfig), config);
+```
+
+**Why the builders.** A spec's `when` carries channel and type strings and no payload types,
+so the event map a decoration contributes cannot be inferred from it, and TypeScript has no
+partial type-argument inference. `defineSlice<EM>()` puts it in a value position, where
+inference works, so no registration site needs a type argument or a cast. One consequence
+worth knowing: **a bare middleware function can never widen the event map**, because
+`MiddlewareFunction`'s event parameter is a mapped type nothing can be inferred back out of.
+Only the spec form from `defineMiddleware` can.
+
+**It is the same object.** Nothing re-subscribes, no state moves, and any in-flight
+`store.call()` is unaffected. Only the type changes.
+
+**Ordering.** Decorate at module scope, once, before the first render. Between `createStore`
+and the decoration the slice genuinely does not exist, and a component reading it sees
+`undefined` until it does.
+
+**Disposal.** `withSlice` hands back no disposer on purpose: after one runs, the widened type
+still promises a slice that is gone, and no type system can express "valid until that call".
+Use `registerSlice` when you own the slice and need teardown, and keep that disposer private
+to the library. Reading a disposed slice throws a named error in development rather than
+returning `undefined` from a type that promised a value.
+
 ---
 
 ## Hot Module Replacement
@@ -633,6 +714,30 @@ if (import.meta.hot) {
 }
 ```
 
+### `replace*` replaces what you authored, not what a library added
+
+A reducer, middleware or effect registered **after** construction, with `registerReducer`,
+`registerMiddleware` or `registerEffect`, survives a `replace*` call. Those registrations were
+never part of the set you are replacing: nobody writing `replaceReducers(myReducers)` means "and
+also delete the slice devtools mounted, along with its state".
+
+This used to go the other way, which made the HMR line above delete a library's slice and its
+state on the first file save, with no error and no warning. It is also why an in-flight
+`store.call()` no longer dies mid-reload: its reply listener belongs to the store itself.
+
+Pass `{ scope: "all" }` for the old wholesale behaviour, which a test harness resetting a store
+between cases may genuinely want:
+
+```typescript
+store.replaceReducers(nextReducers, { scope: "all" });
+store.hotReplace({ reducer: nextReducers, scope: "all" }); // forwards to all three
+```
+
+An application that authors a slice a library already mounted gets an error naming the slice,
+rather than a silent takeover that leaves the library holding a disposer for something no longer
+its own. In development, `replace*` logs at debug level when it preserved anything, so "why is
+that effect still firing after a reload" has an answer.
+
 ---
 
 ## Best Practices
@@ -694,7 +799,8 @@ store.registerEffect({
 | `store.getState()`                              | Get current readonly state snapshot            |
 | `store.subscribe(listener)`                     | Coarse subscription (any state change)         |
 | `store.connect(spec, handler)`                  | Fine-grained path subscription with wildcards  |
-| `store.onEvent(channel, type, handler, phase?)` | Event subscription (committed/uncommitted/all) |
+| `store.onEvent(channel, type, handler, phase?, options?)` | Event subscription (committed/uncommitted/written/all). Silent during replay unless `{ duringReplay: true }` |
+| `store.onRegistrationChange(observer, opts?)` | Fires when the store gains or loses a reducer, middleware or effect |
 | `store.onEffect(channel, type, handler)`        | Single-event effect shorthand                  |
 | `store.dispose()`                               | Cleanup timers and resources                   |
 
@@ -702,6 +808,10 @@ store.registerEffect({
 
 | API                                 | Description               |
 | ----------------------------------- | ------------------------- |
+| `store.registerSlice(name, spec, opts?)` | Add a slice at runtime; returns the widened store plus a disposer |
+| `store.withSlice(name, spec, opts?)` | Same, returning the widened store for chaining |
+| `store.withMiddleware(mw)`, `store.withEffect(spec)` | Register and widen the event map |
+| `defineSlice<EM>()`, `defineMiddleware<EM>()`, `defineEffect<EM>()` | Declare the event map a spec contributes |
 | `store.registerReducer(name, spec)` | Add a slice at runtime    |
 | `store.registerMiddleware(fn)`      | Add middleware at runtime |
 | `store.registerEffect(spec)`        | Add an effect at runtime  |
@@ -710,10 +820,10 @@ store.registerEffect({
 
 | API                                     | Description                |
 | --------------------------------------- | -------------------------- |
-| `store.replaceReducers(reducers, opts)` | Replace all reducers       |
-| `store.replaceMiddleware(middleware)`   | Replace all middleware     |
-| `store.replaceEffects(effects)`         | Replace all effects        |
-| `store.hotReplace(partial)`             | Replace any subset at once |
+| `store.replaceReducers(reducers, opts)`   | Replace spec reducers; runtime ones survive unless `{ scope: "all" }` |
+| `store.replaceMiddleware(middleware, opts)` | Replace spec middleware; same rule |
+| `store.replaceEffects(effects, opts)`       | Replace spec effects; same rule    |
+| `store.hotReplace(partial)`                 | Replace any subset at once; forwards `scope` |
 
 ### Helpers
 
@@ -830,9 +940,9 @@ The number that matters is what you import, not what the package exports:
 <!-- 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 |
+| `{ createStore }` | 11.5 KB | 14 KB |
+| `{ createStore, hydrate, persist }` | 12.8 KB | 16 KB |
+| everything | 14.2 KB | 18 KB |
 <!-- size-table:end -->
 
 These are **production** figures: what you ship once your bundler defines
@@ -861,6 +971,10 @@ stops a runaway from hanging the tab.
   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
+- **[Upgrading to 0.8.0](https://github.com/yoltra/yoltra/blob/main/docs/en/UPGRADE_0.8.md)**:
+  Five behaviour changes, and one hazard if you roll back
+- **[Decoration Guide](https://github.com/yoltra/yoltra/blob/main/docs/en/DECORATION_GUIDE.md)**:
+  Adding a slice, middleware or effect to somebody else's store, with the types
 - **[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)**:

package/dist/types/index.d.ts

@@ -17,7 +17,8 @@ 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, 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 { defineSlice, defineMiddleware, defineEffect } from './types.js';
+export type { Prettify, Merge, WidenNames, WidenState, EventMapCarrier, EMAddOf, Decoration, Decorated, StoreDecorator, Origin, RegistrationChange, RegistrationObserver, ReplaceScope, EmptyEventMap, NotCommittedReason, StateOfSpec, SatisfiesSlices, DecoratableStore, WidenedSlice, StoreDecoration, 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

@@ -20,7 +20,7 @@ export interface PersistenceAdapter {
     remove(key: string): void | Promise<void>;
 }
 /** Where a failure happened, so a handler can tell a bad write from a bad payload. */
-export type PersistencePhase = "read" | "write" | "decode" | "migrate";
+export type PersistencePhase = "read" | "write" | "decode" | "migrate" | "encode";
 /** Shared configuration. */
 export interface PersistOptions {
     /** Storage key. */
@@ -120,4 +120,4 @@ export declare function persist(store: PersistableStore, options: PersistOptions
  *
  * @public
  */
-export declare function dehydrate(store: Pick<PersistableStore, "getState">, options: Pick<PersistOptions, "version" | "slices">): string;
+export declare function dehydrate(store: Pick<PersistableStore, "getState">, options: Pick<PersistOptions, "version" | "slices" | "onError">): string;