@systemfsoftware/xstate-store 0.0.0-stage → 5.0.0-beta.6

package/dist/index.d.ts

@@ -0,0 +1,147 @@
+import { $ as StoreSchemas, A as ResolveStoreEventPayloadMap, B as StoreContext, C as InputFromStoreLogicCreator, D as ReducerAtom, E as ReadonlyAtom, F as SpecificStoreConfig, G as StoreFromStoreLogicCreator, H as StoreEffectEnqueue, I as StandardSchemaMap, J as StoreInspectedEventEvent, K as StoreInspectedActionEvent, L as Store, M as Selection, N as Selector, O as ResolveStoreContext, P as SnapshotFromStore, Q as StoreLogicCreator, R as StoreAssigner, S as InputFromAtomConfig, T as Readable, U as StoreExtension, V as StoreEffect, W as StoreFromStoreConfig, X as StoreInspectionEvent, Y as StoreInspectedSnapshotEvent, Z as StoreLogic, _ as EventObject, a as AnyStoreConfig, at as TriggerObject, b as InferSchemaOutput, c as AtomConfig, d as CanObject, et as StoreSelectorsConfig, f as ContextFromStoreConfig, g as EventFromStoreConfig, h as EventFromStore, i as AnyStore, it as Subscription, j as ResolvedStoreSelectors, k as ResolveStoreEmittedPayloadMap, l as AtomOptions, m as EnqueueObject, n as AnyAtom, nt as StoreWithSelectors, o as AnyStoreLogicCreator, ot as ValueFromAtomConfig, p as EmitsFromStoreConfig, q as StoreInspectedActorEvent, r as AnyAtomConfig, rt as Subscribable, s as Atom, st as StandardSchemaV1, t as ActorRefLike, tt as StoreSnapshot, u as BaseAtom, v as EventPayloadMap, w as Observer, x as InferSchemaPayloadMap, y as ExtractEvents, z as StoreConfig } from "./types-0n0RpfhK.js";
+import { ActorLogic } from "@systemfsoftware/xstate";
+/** Returns `true` if `value` is an atom (has `get` and `subscribe` methods). */
+export declare function isAtom(value: unknown): value is AnyAtom;
+/** The current state of an async atom. */
+type AsyncAtomState<Data, Error = unknown> = {
+  status: 'pending';
+} | {
+  status: 'done';
+  data: Data;
+} | {
+  status: 'error';
+  error: Error;
+};
+/** Options passed to an async atom getter. */
+interface AsyncAtomOptions {
+  /** Signal aborted when the async atom recomputes before this run settles. */
+  signal: AbortSignal;
+}
+/**
+ * Creates a read-only atom whose value is loaded from an async getter.
+ *
+ * The getter receives an `AbortSignal`; when the async atom recomputes, the
+ * previous signal is aborted and stale resolutions are ignored.
+ */
+export declare function createAsyncAtom<T>(getValue: (options: AsyncAtomOptions) => Promise<T>, options?: AtomOptions<AsyncAtomState<T>>): ReadonlyAtom<AsyncAtomState<T>>;
+/**
+ * Creates an atom.
+ *
+ * Pass a value for a writable atom or a getter for a computed read-only atom.
+ */
+export declare function createAtom<T>(getValue: (prev?: T) => T, options?: AtomOptions<T>): ReadonlyAtom<T>;
+export declare function createAtom<T>(initialValue: T, options?: AtomOptions<T>): Atom<T>;
+/**
+ * Creates an inert atom config that can be instantiated later.
+ *
+ * Useful for framework hooks that need to create a stable local atom from
+ * component input.
+ */
+export declare function createAtomConfig<T, TInput>(getInitialValue: (input: TInput) => T, options?: AtomOptions<T>): AtomConfig<T, TInput>;
+export declare function createAtomConfig<T>(initialValue: T, options?: AtomOptions<T>): AtomConfig<T, undefined>;
+/** Creates an atom whose updates are handled by a reducer function. */
+export declare function createReducerAtom<TState, TEvent>(initialValue: TState, reducer: (state: TState, event: TEvent) => TState, options?: AtomOptions<TState>): ReducerAtom<TState, TEvent>;
+type TransitionsFromEventPayloadMap<TEventPayloadMap extends EventPayloadMap, TContext extends StoreContext, TEmitted extends EventObject> = { [K in keyof TEventPayloadMap & string]?: StoreAssigner<TContext, {
+  type: K;
+} & TEventPayloadMap[K], TEmitted, TEventPayloadMap>; };
+/**
+ * Creates a **store** that has its own internal state and can be sent events
+ * that update its internal state based on transitions.
+ *
+ * @example
+ *
+ * ```ts
+ * const store = createStore({
+ *   context: { count: 0, name: 'Ada' },
+ *   on: {
+ *     inc: (context, event: { by: number }) => ({
+ *       ...context,
+ *       count: context.count + event.by
+ *     })
+ *   }
+ * });
+ *
+ * store.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ *
+ * store.send({ type: 'inc', by: 5 });
+ * // Logs { context: { count: 5, name: 'Ada' }, status: 'active', ... }
+ * ```
+ *
+ * @param config - The store configuration object:
+ * - `config.context` - The initial state of the store
+ * - `config.schemas` - Optional standard-schema definitions used as type
+ *   sources for context, events, and emitted events
+ * - `config.on` - An object mapping event types to transition functions
+ * @returns A store instance with methods to send events and subscribe to state
+ *   changes
+ */
+export declare function createStore<TContext extends StoreContext, const TEventPayloadMap extends EventPayloadMap, TEmittedPayloadMap extends EventPayloadMap = {}, TContextSchema extends StandardSchemaV1 | undefined = undefined, TEventSchemaMap extends StandardSchemaMap | undefined = undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined = undefined>(definition: StoreConfig<TContext, TEventPayloadMap, TEmittedPayloadMap, TContextSchema, TEventSchemaMap, TEmittedSchemaMap>): Store<ResolveStoreContext<TContext, TContextSchema>, ResolveStoreEventPayloadMap<TEventPayloadMap, TEventSchemaMap>, ExtractEvents<ResolveStoreEmittedPayloadMap<TEmittedPayloadMap, TEmittedSchemaMap>>>;
+export declare function createStore<TContext extends StoreContext, TEvent extends EventObject, TEmitted extends EventObject, TContextSchema extends StandardSchemaV1 | undefined = undefined, TEventSchemaMap extends StandardSchemaMap | undefined = undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined = undefined>(definition: SpecificStoreConfig<TContext, TEvent, TEmitted, TContextSchema, TEventSchemaMap, TEmittedSchemaMap> | StoreLogic<StoreSnapshot<ResolveStoreContext<TContext, TContextSchema>>, TEvent, TEmitted>): Store<ResolveStoreContext<TContext, TContextSchema>, { [E in TEvent as E['type']]: E; }, TEmitted>;
+export declare const createStoreConfig: {
+  <TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap, TEmitted extends EventPayloadMap = {}, TContextSchema extends StandardSchemaV1 | undefined = undefined, TEventSchemaMap extends StandardSchemaMap | undefined = undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined = undefined>(definition: StoreConfig<TContext, TEventPayloadMap, TEmitted, TContextSchema, TEventSchemaMap, TEmittedSchemaMap>): StoreConfig<TContext, TEventPayloadMap, TEmitted, TContextSchema, TEventSchemaMap, TEmittedSchemaMap>;
+};
+export declare function createStoreLogic<TContext extends StoreContext, const TEventPayloadMap extends EventPayloadMap, TEmittedPayloadMap extends EventPayloadMap = {}, TInput = undefined, TContextSchema extends StandardSchemaV1 | undefined = undefined, TEventSchemaMap extends StandardSchemaMap | undefined = undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined = undefined, TSelectors extends StoreSelectorsConfig<ResolveStoreContext<TContext, TContextSchema>> = StoreSelectorsConfig<ResolveStoreContext<TContext, TContextSchema>>>(config: Omit<StoreConfig<TContext, TEventPayloadMap, TEmittedPayloadMap, TContextSchema, TEventSchemaMap, TEmittedSchemaMap>, 'context'> & {
+  context: (input: TInput) => ResolveStoreContext<TContext, TContextSchema>;
+  selectors: TSelectors;
+}): StoreLogicCreator<ResolveStoreContext<TContext, TContextSchema>, ResolveStoreEventPayloadMap<TEventPayloadMap, TEventSchemaMap>, ExtractEvents<ResolveStoreEmittedPayloadMap<TEmittedPayloadMap, TEmittedSchemaMap>>, TInput, TSelectors>;
+export declare function createStoreLogic<TContext extends StoreContext, const TEventPayloadMap extends EventPayloadMap, TEmittedPayloadMap extends EventPayloadMap = {}, TInput = undefined, TContextSchema extends StandardSchemaV1 | undefined = undefined, TEventSchemaMap extends StandardSchemaMap | undefined = undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined = undefined>(config: Omit<StoreConfig<TContext, TEventPayloadMap, TEmittedPayloadMap, TContextSchema, TEventSchemaMap, TEmittedSchemaMap>, 'context'> & {
+  context: (input: TInput) => ResolveStoreContext<TContext, TContextSchema>;
+}): StoreLogicCreator<ResolveStoreContext<TContext, TContextSchema>, ResolveStoreEventPayloadMap<TEventPayloadMap, TEventSchemaMap>, ExtractEvents<ResolveStoreEmittedPayloadMap<TEmittedPayloadMap, TEmittedSchemaMap>>, TInput, {}>;
+export declare function createStoreLogic<TContext extends StoreContext, const TEventPayloadMap extends EventPayloadMap, TEmittedPayloadMap extends EventPayloadMap = {}, TContextSchema extends StandardSchemaV1 | undefined = undefined, TEventSchemaMap extends StandardSchemaMap | undefined = undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined = undefined, TSelectors extends StoreSelectorsConfig<ResolveStoreContext<TContext, TContextSchema>> = {}>(config: StoreConfig<TContext, TEventPayloadMap, TEmittedPayloadMap, TContextSchema, TEventSchemaMap, TEmittedSchemaMap> & {
+  selectors: TSelectors;
+}): StoreLogicCreator<ResolveStoreContext<TContext, TContextSchema>, ResolveStoreEventPayloadMap<TEventPayloadMap, TEventSchemaMap>, ExtractEvents<ResolveStoreEmittedPayloadMap<TEmittedPayloadMap, TEmittedSchemaMap>>, void, TSelectors>;
+export declare function createStoreLogic<TContext extends StoreContext, const TEventPayloadMap extends EventPayloadMap, TEmittedPayloadMap extends EventPayloadMap = {}, TContextSchema extends StandardSchemaV1 | undefined = undefined, TEventSchemaMap extends StandardSchemaMap | undefined = undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined = undefined>(config: StoreConfig<TContext, TEventPayloadMap, TEmittedPayloadMap, TContextSchema, TEventSchemaMap, TEmittedSchemaMap>): StoreLogicCreator<ResolveStoreContext<TContext, TContextSchema>, ResolveStoreEventPayloadMap<TEventPayloadMap, TEventSchemaMap>, ExtractEvents<ResolveStoreEmittedPayloadMap<TEmittedPayloadMap, TEmittedSchemaMap>>, void, {}>;
+declare global {
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
+}
+type FromStoreLogic<TContext extends StoreContext, TEvent extends EventObject, TInput, TEmitted extends EventObject> = ActorLogic<StoreSnapshot<TContext>, TEvent, TInput, any, TEmitted>;
+type FromStoreEmittedEvents<TEmittedPayloadMap extends EventPayloadMap, TEmittedSchemaMap extends StandardSchemaMap | undefined> = ExtractEvents<ResolveStoreEmittedPayloadMap<TEmittedPayloadMap, TEmittedSchemaMap>>;
+type InferredFromStoreTransitions<TContext extends StoreContext, TTransitions extends Record<string, (...args: any[]) => any>, TEmittedPayloadMap extends EventPayloadMap, TContextSchema extends StandardSchemaV1 | undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined> = Record<string, (context: NoInfer<ResolveStoreContext<TContext, TContextSchema>>, event: any, enq: EnqueueObject<ResolveStoreContext<TContext, TContextSchema>, FromStoreEmittedEvents<TEmittedPayloadMap, TEmittedSchemaMap>, InferredEventPayloadMap<TTransitions>>) => ResolveStoreContext<TContext, TContextSchema> | void>;
+type InferredEventPayloadMap<TTransitions extends Record<string, (...args: any[]) => any>> = { [K in keyof TTransitions & string]: TTransitions[K] extends ((context: any, event: infer TEvent, ...args: any[]) => any) ? Omit<TEvent, 'type'> : {}; };
+type SchemaFromStoreTransitions<TContext extends StoreContext, TEventSchemaMap extends StandardSchemaMap, TEmittedPayloadMap extends EventPayloadMap, TContextSchema extends StandardSchemaV1 | undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined> = TransitionsFromEventPayloadMap<InferSchemaPayloadMap<TEventSchemaMap>, NoInfer<ResolveStoreContext<TContext, TContextSchema>>, FromStoreEmittedEvents<TEmittedPayloadMap, TEmittedSchemaMap>>;
+type FromStoreValueConfig<TContext extends StoreContext, TTransitions extends Record<string, (...args: any[]) => any>, TEmittedPayloadMap extends EventPayloadMap, TContextSchema extends StandardSchemaV1 | undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined> = {
+  context: ResolveStoreContext<TContext, TContextSchema>;
+  schemas?: StoreSchemas<TContextSchema, undefined, TEmittedSchemaMap>;
+  on: TTransitions & InferredFromStoreTransitions<TContext, TTransitions, TEmittedPayloadMap, TContextSchema, TEmittedSchemaMap>;
+};
+type FromStoreInputConfig<TContext extends StoreContext, TTransitions extends Record<string, (...args: any[]) => any>, TInput, TEmittedPayloadMap extends EventPayloadMap, TContextSchema extends StandardSchemaV1 | undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined> = {
+  context: (input: TInput) => ResolveStoreContext<TContext, TContextSchema>;
+  schemas?: StoreSchemas<TContextSchema, undefined, TEmittedSchemaMap>;
+  on: TTransitions & InferredFromStoreTransitions<TContext, TTransitions, TEmittedPayloadMap, TContextSchema, TEmittedSchemaMap>;
+};
+type SchemaFromStoreValueConfig<TContext extends StoreContext, TEventSchemaMap extends StandardSchemaMap, TEmittedPayloadMap extends EventPayloadMap, TContextSchema extends StandardSchemaV1 | undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined> = {
+  context: ResolveStoreContext<TContext, TContextSchema>;
+  schemas: StoreSchemas<TContextSchema, TEventSchemaMap, TEmittedSchemaMap> & {
+    events: TEventSchemaMap;
+  };
+  on: SchemaFromStoreTransitions<TContext, TEventSchemaMap, TEmittedPayloadMap, TContextSchema, TEmittedSchemaMap>;
+};
+type SchemaFromStoreInputConfig<TContext extends StoreContext, TEventSchemaMap extends StandardSchemaMap, TInput, TEmittedPayloadMap extends EventPayloadMap, TContextSchema extends StandardSchemaV1 | undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined> = {
+  context: (input: TInput) => ResolveStoreContext<TContext, TContextSchema>;
+  schemas: StoreSchemas<TContextSchema, TEventSchemaMap, TEmittedSchemaMap> & {
+    events: TEventSchemaMap;
+  };
+  on: SchemaFromStoreTransitions<TContext, TEventSchemaMap, TEmittedPayloadMap, TContextSchema, TEmittedSchemaMap>;
+};
+/**
+ * An actor logic creator which creates store [actor
+ * logic](https://stately.ai/docs/actors#actor-logic) for use with XState.
+ *
+ * @param config An object containing the store configuration:
+ * - `config.context` The initial context for the store, either a function
+ *   that returns context based on input, or the context itself
+ * - `config.schemas` Optional standard-schema definitions used as type
+ *   sources for context, events, and emitted events
+ * - `config.on` An object defining the transitions for different event types
+ * @returns An actor logic creator function that creates store actor logic
+ */
+export declare function fromStore<TContext extends StoreContext, const TTransitions extends Record<string, (...args: any[]) => any>, TInput, TEmittedPayloadMap extends EventPayloadMap = EventPayloadMap, TContextSchema extends StandardSchemaV1 | undefined = undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined = undefined>(config: FromStoreInputConfig<TContext, TTransitions, TInput, TEmittedPayloadMap, TContextSchema, TEmittedSchemaMap>): FromStoreLogic<ResolveStoreContext<TContext, TContextSchema>, ExtractEvents<InferredEventPayloadMap<TTransitions>>, TInput, FromStoreEmittedEvents<TEmittedPayloadMap, TEmittedSchemaMap>>;
+export declare function fromStore<TContext extends StoreContext, const TTransitions extends Record<string, (...args: any[]) => any>, TEmittedPayloadMap extends EventPayloadMap = EventPayloadMap, TContextSchema extends StandardSchemaV1 | undefined = undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined = undefined>(config: FromStoreValueConfig<TContext, TTransitions, TEmittedPayloadMap, TContextSchema, TEmittedSchemaMap>): FromStoreLogic<ResolveStoreContext<TContext, TContextSchema>, ExtractEvents<InferredEventPayloadMap<TTransitions>>, unknown, FromStoreEmittedEvents<TEmittedPayloadMap, TEmittedSchemaMap>>;
+export declare function fromStore<TContext extends StoreContext, TEventSchemaMap extends StandardSchemaMap, TInput, TEmittedPayloadMap extends EventPayloadMap = EventPayloadMap, TContextSchema extends StandardSchemaV1 | undefined = undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined = undefined>(config: SchemaFromStoreInputConfig<TContext, TEventSchemaMap, TInput, TEmittedPayloadMap, TContextSchema, TEmittedSchemaMap>): FromStoreLogic<ResolveStoreContext<TContext, TContextSchema>, ExtractEvents<InferSchemaPayloadMap<TEventSchemaMap>>, TInput, FromStoreEmittedEvents<TEmittedPayloadMap, TEmittedSchemaMap>>;
+export declare function fromStore<TContext extends StoreContext, TEventSchemaMap extends StandardSchemaMap, TEmittedPayloadMap extends EventPayloadMap = EventPayloadMap, TContextSchema extends StandardSchemaV1 | undefined = undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined = undefined>(config: SchemaFromStoreValueConfig<TContext, TEventSchemaMap, TEmittedPayloadMap, TContextSchema, TEmittedSchemaMap>): FromStoreLogic<ResolveStoreContext<TContext, TContextSchema>, ExtractEvents<InferSchemaPayloadMap<TEventSchemaMap>>, unknown, FromStoreEmittedEvents<TEmittedPayloadMap, TEmittedSchemaMap>>;
+export declare function shallowEqual(objA: any, objB: any): boolean;
+export type { ActorRefLike, AnyAtom, AnyAtomConfig, AnyStore, AnyStoreConfig, AnyStoreLogicCreator, AsyncAtomOptions, AsyncAtomState, Atom, AtomConfig, AtomOptions, BaseAtom, CanObject, ContextFromStoreConfig, EmitsFromStoreConfig, EnqueueObject, EventFromStore, EventFromStoreConfig, EventObject, EventPayloadMap, ExtractEvents, InferSchemaOutput, InferSchemaPayloadMap, InputFromAtomConfig, InputFromStoreLogicCreator, Observer, Readable, ReadonlyAtom, ReducerAtom, ResolveStoreContext, ResolveStoreEmittedPayloadMap, ResolveStoreEventPayloadMap, ResolvedStoreSelectors, Selection, Selector, SnapshotFromStore, StandardSchemaMap, StandardSchemaV1, Store, StoreAssigner, StoreConfig, StoreContext, StoreEffect, StoreEffectEnqueue, StoreExtension, StoreFromStoreConfig, StoreFromStoreLogicCreator, StoreInspectedActionEvent, StoreInspectedActorEvent, StoreInspectedEventEvent, StoreInspectedSnapshotEvent, StoreInspectionEvent, StoreLogicCreator, StoreSchemas, StoreSelectorsConfig, StoreSnapshot, StoreWithSelectors, Subscribable, Subscription, TriggerObject, ValueFromAtomConfig };

package/dist/index.mjs

@@ -0,0 +1,70 @@
+import { a as createStoreConfig, c as createAsyncAtom, d as createReducerAtom, f as isAtom, i as createStore, l as createAtom, o as createStoreLogic, s as createStoreTransition, u as createAtomConfig } from "./store-BMZdYhoE.mjs";
+// src/fromStore.ts
+function fromStore(config) {
+	const initialContext = config.context;
+	const transition = createStoreTransition(config.on);
+	const initialTransition = (input, _) => [{
+		status: "active",
+		context: typeof initialContext === "function" ? initialContext(input) : initialContext,
+		output: void 0,
+		error: void 0
+	}, []];
+	return {
+		transition: (snapshot, event, actorScope) => {
+			const [nextSnapshot, effects] = transition(snapshot, event);
+			return [nextSnapshot, effects.map((effect) => {
+				if (typeof effect === "function") {
+					const action = (system = actorScope.self.system) => {
+						const send = (event) => void system.sendEvent(actorScope.self, actorScope.self, event);
+						return effect({
+							send,
+							trigger: new Proxy({}, { get: (_, eventType) => {
+								return (payload) => send({
+									type: eventType,
+									...payload
+								});
+							} }),
+							getSnapshot: () => actorScope.self.getSnapshot()
+						});
+					};
+					return {
+						kind: "action",
+						type: "effect",
+						action,
+						params: void 0,
+						args: [],
+						exec: action
+					};
+				}
+				return {
+					kind: "emit",
+					type: effect.type,
+					source: actorScope.self,
+					event: effect,
+					params: void 0,
+					args: [],
+					exec: (system = actorScope.self.system) => system.emitEvent(actorScope.self, effect)
+				};
+			})];
+		},
+		initialTransition,
+		getInitialSnapshot: (actorScope, input) => initialTransition(input, actorScope)[0],
+		getPersistedSnapshot: (s) => s,
+		restoreSnapshot: (s) => s
+	};
+}
+// src/shallowEqual.ts
+function is(x, y) {
+	if (x === y) return x !== 0 || y !== 0 || 1 / x === 1 / y;
+	else return x !== x && y !== y;
+}
+function shallowEqual(objA, objB) {
+	if (is(objA, objB)) return true;
+	if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) return false;
+	const keysA = Object.keys(objA);
+	const keysB = Object.keys(objB);
+	if (keysA.length !== keysB.length) return false;
+	for (const key of keysA) if (!Object.prototype.hasOwnProperty.call(objB, key) || !is(objA[key], objB[key])) return false;
+	return true;
+}
+export { createAsyncAtom, createAtom, createAtomConfig, createReducerAtom, createStore, createStoreConfig, createStoreLogic, fromStore, isAtom, shallowEqual };

package/dist/persist.d.ts

@@ -0,0 +1,256 @@
+import { B as StoreContext, U as StoreExtension, _ as EventObject, v as EventPayloadMap } from "./types-0n0RpfhK.js";
+/**
+ * Storage interface compatible with `localStorage`, `sessionStorage`, and async
+ * storage adapters (React Native AsyncStorage, IndexedDB, etc.).
+ */
+export interface StateStorage {
+  getItem: (name: string) => string | null | Promise<string | null>;
+  setItem: (name: string, value: string) => void | Promise<void>;
+  removeItem: (name: string) => void | Promise<void>;
+}
+/** The envelope persisted to storage for snapshot strategy. @public */
+export interface PersistStorageValue<TContext> {
+  context: Partial<TContext>;
+  version: string | number;
+}
+/** The envelope persisted to storage for event strategy. @public */
+export interface PersistEventStorageValue<TEvent extends EventObject = EventObject> {
+  events: TEvent[];
+  /**
+   * Snapshot checkpoint from which to replay events. When events are truncated
+   * by `maxEvents`, this stores the context at the truncation point so replay
+   * produces the correct state.
+   */
+  checkpoint?: unknown;
+  version: string | number;
+}
+/** Base options shared by both persist strategies. @public */
+export interface PersistBaseOptions {
+  /** Storage key (required). */
+  name: string;
+  /** Storage adapter. Defaults to `localStorage`. */
+  storage?: StateStorage;
+  /** Schema version. Defaults to 0. */
+  version?: string | number;
+  /** Minimum milliseconds between storage writes. Defaults to 0 (immediate). */
+  throttle?: number;
+  /** Called after a successful storage write. */
+  onDone?: (data: any) => void;
+  /** Called when a storage read or write fails. */
+  onError?: (error: unknown) => void;
+  /** Skip automatic hydration on store creation. Defaults to `false`. */
+  skipHydration?: boolean;
+}
+/** Options for the snapshot persist strategy (default). @public */
+export interface PersistSnapshotOptions<TContext = StoreContext, TEvent extends EventObject = EventObject> extends PersistBaseOptions {
+  /** Persist strategy. Defaults to `'snapshot'`. */
+  strategy?: 'snapshot';
+  /**
+   * Controls whether an event should trigger a storage write. Return `false` to
+   * skip persisting for that event.
+   */
+  filter?: (event: TEvent) => boolean;
+  /** Select which parts of context to persist. Defaults to full context. */
+  pick?: (context: TContext) => Partial<TContext>;
+  /** Migration function for version upgrades. */
+  migrate?: (persistedContext: any, version: string | number) => TContext;
+  /**
+   * Custom merge strategy when rehydrating. Defaults to shallow merge
+   * (`{ ...currentContext, ...persistedContext }`).
+   */
+  merge?: (persistedContext: Partial<TContext>, currentContext: TContext) => TContext;
+  /** Custom serializer. Defaults to `JSON.stringify`. */
+  serialize?: (value: PersistStorageValue<TContext>) => string;
+  /** Custom deserializer. Defaults to `JSON.parse`. */
+  deserialize?: (str: string) => PersistStorageValue<TContext>;
+}
+/** Options for the event persist strategy. @public */
+export interface PersistEventOptions<_TContext = StoreContext, TEvent extends EventObject = EventObject> extends PersistBaseOptions {
+  /** Persist strategy. */
+  strategy: 'event';
+  /**
+   * Maximum number of events to keep. When exceeded, a snapshot checkpoint is
+   * saved and oldest events are dropped. Replay starts from the checkpoint.
+   * Defaults to Infinity.
+   */
+  maxEvents?: number;
+  /** Migration function for version upgrades. Receives the stored events array. */
+  migrate?: (persistedEvents: any[], version: string | number) => any[];
+  /** Custom serializer. Defaults to `JSON.stringify`. */
+  serialize?: (value: PersistEventStorageValue<TEvent>) => string;
+  /** Custom deserializer. Defaults to `JSON.parse`. */
+  deserialize?: (str: string) => PersistEventStorageValue<TEvent>;
+}
+/** Options for the `persist` store extension. @public */
+export type PersistOptions<TContext = StoreContext, TEvent extends EventObject = EventObject> = PersistSnapshotOptions<TContext, TEvent> | PersistEventOptions<TContext, TEvent>;
+/**
+ * Creates a store extension that persists context to storage.
+ *
+ * @example
+ *
+ * ```ts
+ * import { persist } from '@systemfsoftware/xstate-store/persist';
+ *
+ * const store = createStore({
+ *   context: { count: 0 },
+ *   on: { inc: (ctx) => ({ count: ctx.count + 1 }) }
+ * }).with(persist({ name: 'my-store' }));
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * // Throttled writes with callbacks
+ * const store = createStore({
+ *   context: { count: 0 },
+ *   on: { inc: (ctx) => ({ count: ctx.count + 1 }) }
+ * }).with(
+ *   persist({
+ *     name: 'my-store',
+ *     throttle: 1000,
+ *     onDone: (ctx) => console.log('Persisted:', ctx),
+ *     onError: (err) => console.error('Persist failed:', err)
+ *   })
+ * );
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * // Async storage with manual rehydration
+ * import {
+ *   persist,
+ *   rehydrateStore,
+ *   createJSONStorage
+ * } from '@systemfsoftware/xstate-store/persist';
+ *
+ * const store = createStore({
+ *   context: { count: 0 },
+ *   on: { inc: (ctx) => ({ count: ctx.count + 1 }) }
+ * }).with(
+ *   persist({
+ *     name: 'my-store',
+ *     storage: createJSONStorage(() => AsyncStorage),
+ *     skipHydration: true
+ *   })
+ * );
+ *
+ * await rehydrateStore(store);
+ * ```
+ */
+export declare function persist<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap, TEmitted extends EventObject>(options: PersistOptions<NoInfer<TContext>>): StoreExtension<TContext, TEventPayloadMap, {}, TEmitted>;
+/**
+ * Creates a storage adapter with error handling and SSR safety.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createJSONStorage } from '@systemfsoftware/xstate-store/persist';
+ *
+ * // Safe for SSR — returns noop storage if localStorage is unavailable
+ * const storage = createJSONStorage(() => localStorage);
+ *
+ * // Async storage (React Native)
+ * const asyncStorage = createJSONStorage(() => AsyncStorage);
+ * ```
+ */
+export declare function createJSONStorage(getStorage: () => StateStorage): StateStorage;
+/**
+ * Removes persisted data from storage for a store that uses the `persist`
+ * extension.
+ *
+ * @example
+ *
+ * ```ts
+ * import { clearStorage } from '@systemfsoftware/xstate-store/persist';
+ *
+ * clearStorage(store);
+ * ```
+ */
+export declare function clearStorage(store: {
+  getSnapshot: () => any;
+}): void | Promise<void>;
+/**
+ * Flushes pending throttled updates and waits for already queued async writes.
+ * Synchronous storage writes complete before this function returns.
+ *
+ * @example
+ *
+ * ```ts
+ * import { flushStorage } from '@systemfsoftware/xstate-store/persist';
+ *
+ * // Force write before page unload
+ * window.addEventListener('beforeunload', () => {
+ *   flushStorage(store);
+ * });
+ * ```
+ */
+export declare function flushStorage(store: {
+  getSnapshot: () => any;
+}): void | Promise<void>;
+/**
+ * Returns whether the store has been hydrated from storage.
+ *
+ * @example
+ *
+ * ```ts
+ * import { isHydrated } from '@systemfsoftware/xstate-store/persist';
+ *
+ * if (isHydrated(store)) {
+ *   // Safe to read persisted state
+ * }
+ * ```
+ */
+export declare function isHydrated(store: {
+  getSnapshot: () => any;
+}): boolean;
+/**
+ * Reads persisted state from (potentially async) storage and rehydrates the
+ * store. Use this for async storage adapters or when `skipHydration` is
+ * `true`.
+ *
+ * @example
+ *
+ * ```ts
+ * import { rehydrateStore } from '@systemfsoftware/xstate-store/persist';
+ *
+ * const store = createStore({ ... }).with(persist({
+ *   name: 'my-store',
+ *   storage: createJSONStorage(() => AsyncStorage),
+ *   skipHydration: true
+ * }));
+ *
+ * await rehydrateStore(store);
+ * ```
+ */
+export declare function rehydrateStore(store: {
+  getSnapshot: () => any;
+  send: (event: any) => void;
+}): Promise<void>;
+/** Options for `createBroadcastStorage(...)`. */
+interface BroadcastStorageOptions {
+  /** BroadcastChannel name. Defaults to `"xstate-store"`. */
+  channel?: string;
+}
+/** Storage adapter returned by `createBroadcastStorage(...)`. */
+type BroadcastStorage = StateStorage & {
+  /** Channel used to announce writes to other same-origin contexts. */
+  readonly channel: BroadcastChannel;
+};
+/**
+ * Wraps a storage adapter so writes are announced across same-origin tabs.
+ *
+ * Pair with `subscribeToBroadcastStorage(...)` on persisted stores that should
+ * rehydrate when another tab writes to the same storage key.
+ */
+export declare function createBroadcastStorage(baseStorage: StateStorage, options?: BroadcastStorageOptions): BroadcastStorage;
+/**
+ * Subscribes a persisted store to broadcast storage updates.
+ *
+ * Returns an unsubscribe function that closes the broadcast listener.
+ */
+export declare function subscribeToBroadcastStorage(store: {
+  getSnapshot: () => any;
+  send: (event: any) => void;
+}): () => void;
+export {};