chizu 0.2.72 → 0.3.0

package/dist/error/index.d.ts

@@ -1,24 +1,2 @@
-import { Props } from './types';
-export { useError } from './utils';
 export { Reason, AbortError, TimeoutError, DisallowedError } from './types';
-export type { Fault, Catcher } from './types';
-/**
- * Error boundary component for catching and handling errors from actions.
- *
- * @template E Custom error types to include in the handler's error union.
- * @param props.handler - The error handler function to call when an error occurs.
- * @param props.children - The children to render within the error boundary.
- * @returns The children wrapped in an error context provider.
- *
- * @example
- * ```tsx
- * <Error<ApiError | ValidationError>
- *   handler={({ error }) => {
- *     if (error instanceof ApiError) handleApiError(error);
- *   }}
- * >
- *   <App />
- * </Error>
- * ```
- */
-export declare function Error<E extends Error = never>({ handler, children, }: Props<E>): import("react/jsx-runtime").JSX.Element;
+export type { Fault } from './types';

package/dist/error/types.d.ts

@@ -1,4 +1,3 @@
-import { ReactNode } from 'react';
 import { Task } from '../boundary/components/tasks/types.ts';
 /**
  * Reasons why an action error occurred.
@@ -57,6 +56,13 @@ export declare class DisallowedError extends Error {
 }
 /**
  * Details about an error that occurred during action execution.
+ *
+ * Faults are delivered through the global `Lifecycle.Fault` broadcast.
+ * Subscribe with `actions.useAction(Lifecycle.Fault, handler)` near the
+ * root of your application for app-level concerns (logging, sign-out on
+ * auth failure, abort cascades). For component-local recovery, use a
+ * `Lifecycle.Error()` factory instead.
+ *
  * @template E Custom error types to include in the union with Error.
  */
 export type Fault<E extends Error = never> = {
@@ -74,35 +80,13 @@ export type Fault<E extends Error = never> = {
      * (e.g., on 403/500 responses to prevent cascading failures).
      *
      * @example
-     * ```tsx
-     * <Error handler={({ reason, tasks }) => {
-     *   if (reason === Reason.Errored) {
-     *     // Abort all in-flight tasks to prevent cascading errors
-     *     for (const task of tasks) {
-     *       task.controller.abort();
-     *     }
-     *     // Trigger re-authentication flow
+     * ```ts
+     * actions.useAction(Lifecycle.Fault, (context, fault) => {
+     *   if (fault.reason === Reason.Errored) {
+     *     for (const task of fault.tasks) task.controller.abort();
      *   }
-     * }}>
-     *   {children}
-     * </Error>
+     * });
      * ```
      */
     tasks: ReadonlySet<Task>;
 };
-/**
- * Catcher function called when an action error occurs.
- * @template E Custom error types to include in the union with Error.
- * @param details Information about the error.
- */
-export type Catcher<E extends Error = never> = (details: Fault<E>) => void;
-/**
- * Props for the Error boundary component.
- * @template E Custom error types to include in the union with Error.
- */
-export type Props<E extends Error = never> = {
-    /** Catcher function called when an action error occurs. */
-    handler: Catcher<E>;
-    /** Child components to wrap with error handling. */
-    children?: ReactNode;
-};

package/dist/error/utils.d.ts

@@ -1,4 +1,4 @@
-import { Catcher, Reason } from './types.ts';
+import { Reason } from './types.ts';
 /**
  * Determines the error reason based on what was thrown.
  *
@@ -13,13 +13,3 @@ export declare function getReason(error: unknown): Reason;
  * @returns An Error instance (original if already Error, wrapped otherwise).
  */
 export declare function getError(error: unknown): Error;
-/**
- * React context for handling errors that occur within actions.
- */
-export declare const ErrorContext: import('react').Context<Catcher | undefined>;
-/**
- * Hook to access the error handler from the nearest Error provider.
- *
- * @returns The error handler function, or undefined if not within an Error provider.
- */
-export declare function useError(): Catcher | undefined;

package/dist/hooks/utils.d.ts

@@ -16,6 +16,14 @@ export declare function withGetters<P extends Props>(a: P, b: RefObject<P>): P;
  * the generator function's name.
  */
 export declare function isGenerator(result: unknown): result is Generator | AsyncGenerator;
+/**
+ * Sentinel passed as the dispatch channel during mount replay. Channeled
+ * handlers check for this to skip replay &mdash; they require specific
+ * channel context and cannot meaningfully process a replay without it.
+ *
+ * @internal
+ */
+export declare const replay: unique symbol;
 /**
  * Invokes all listeners for an event and returns a promise that resolves
  * when every handler has settled. For {@link BroadcastEmitter} instances the

package/dist/index.d.ts

@@ -1,15 +1,16 @@
 export { Action } from './action/index.ts';
-export { Entry } from './cache/index.ts';
 export { Distribution, Lifecycle } from './types/index.ts';
-export { Error, Reason, DisallowedError } from './error/index.tsx';
+export { Reason, AbortError, TimeoutError, DisallowedError, } from './error/index.ts';
 export { Operation, Op, State } from 'immertation';
 export { annotate } from './annotate/index.ts';
 export { Boundary } from './boundary/index.tsx';
 export { Regulators } from './boundary/components/regulators/index.tsx';
 export { Scope, withScope } from './boundary/components/scope/index.tsx';
 export { useActions, With } from './hooks/index.ts';
+export { Resource } from './resource/index.ts';
+export type { ResourceHandle, ResourceDispatch, ResourceSuccess, ResourceFailure, } from './resource/index.ts';
 export * as utils from './utils/index.ts';
 export type { Box } from 'immertation';
-export type { Fault, Catcher } from './error/index.tsx';
-export type { Pk, Task, Tasks, Handlers, Meta } from './types/index.ts';
+export type { Fault } from './error/index.ts';
+export type { Pk, Task, Tasks, Handlers, Meta, ScopeCarrier, } from './types/index.ts';
 export type { Regulator } from './boundary/components/regulators/index.tsx';

package/dist/resource/index.d.ts

@@ -0,0 +1,78 @@
+import { BroadcastPayload, ChanneledAction, Filter, Props } from '../types/index.ts';
+/**
+ * Fan-out dispatcher passed to a {@link Resource}'s `onSuccess` and
+ * `onError` callbacks. Restricted to broadcast actions (and channeled
+ * broadcasts) because resource-level events have no single owning
+ * component to scope unicast or multicast to.
+ */
+export type ResourceDispatch = {
+    <P>(action: BroadcastPayload<P>, payload?: P): Promise<void>;
+    <P, C extends Filter>(action: ChanneledAction<P, C>, payload?: P): Promise<void>;
+};
+/**
+ * Context passed to a {@link Resource}'s `onSuccess` callback after a
+ * successful fetch.
+ */
+export type ResourceSuccess<T> = {
+    /** The resolved value from the fetcher. */
+    readonly response: T;
+    /** The reactive `data` proxy of the component that triggered the fetch. */
+    readonly data: Props;
+    /** Pre-bound dispatcher for the surrounding Boundary's broadcaster. */
+    readonly dispatch: ResourceDispatch;
+};
+/**
+ * Context passed to a {@link Resource}'s `onError` callback after a
+ * failed fetch.
+ */
+export type ResourceFailure<E> = {
+    /** The thrown error, narrowed to the second generic on `Resource`. */
+    readonly error: E;
+    /** The reactive `data` proxy of the component that triggered the fetch. */
+    readonly data: Props;
+    /** Pre-bound dispatcher for the surrounding Boundary's broadcaster. */
+    readonly dispatch: ResourceDispatch;
+};
+/**
+ * Module-scope handle returned by {@link Resource}. Pass to
+ * `actions.useResource(handle)` inside a component to obtain a fetcher
+ * thunk bound to the surrounding Boundary's broadcaster and the
+ * component's reactive `data`.
+ */
+export type ResourceHandle<T, E = Error, Args extends readonly unknown[] = []> = {
+    readonly key: string;
+    /** @internal */
+    readonly fetch: (dispatch: ResourceDispatch, data: Props, ...args: Args) => Promise<T>;
+    /** @internal — phantom marker so TS distinguishes by error type */
+    readonly _error?: E;
+    /** @internal — phantom marker so TS distinguishes by args */
+    readonly _args?: Args;
+};
+/**
+ * Defines a remote resource &mdash; declare at module scope and consume via
+ * `actions.useResource(handle)`. Mirrors the {@link Action} factory pattern:
+ * the declaration is a value, not a hook.
+ *
+ * The fetcher may take arguments. The thunk returned by `actions.useResource`
+ * forwards them, and in-flight dedup keys per arg-tuple &ndash; so
+ * `fetchPage(null)` and `fetchPage("abc")` run independently, while two
+ * concurrent `fetchPage("abc")` calls share one network request.
+ *
+ * Once a fetch resolves, the next call with the same args fetches anew &ndash;
+ * there is no stale cache. Coordination across components happens via the
+ * broadcast actions dispatched in `onSuccess` / `onError`.
+ *
+ * @example
+ * ```ts
+ * import { Resource } from "chizu";
+ *
+ * export const feed = Resource<Page<Item>, ApiError, [cursor: string | null]>(
+ *   "feed",
+ *   (cursor) =>
+ *     http.get("feed", { searchParams: { cursor: cursor ?? "" } }).json(),
+ *   ({ response, dispatch }) =>
+ *     dispatch(Actions.Broadcast.PageLoaded, response),
+ * );
+ * ```
+ */
+export declare function Resource<T, E = Error, Args extends readonly unknown[] = []>(key: string, fetcher: (...args: Args) => Promise<T>, onSuccess?: (context: ResourceSuccess<T>) => void, onError?: (context: ResourceFailure<E>) => void): ResourceHandle<T, E, Args>;

package/dist/types/index.d.ts

@@ -1,7 +1,5 @@
 import { Operation, Process, Inspect, Box } from 'immertation';
 import { ActionId, Task, Tasks } from '../boundary/components/tasks/types.ts';
-import { Option } from '@mobily/ts-belt/Option';
-import { Result as TsBeltResult } from '@mobily/ts-belt/Result';
 import { Regulator } from '../boundary/components/regulators/types.ts';
 import { Fault } from '../error/types.ts';
 import * as React from "react";
@@ -58,43 +56,15 @@ export declare class Brand {
     static readonly Channel: unique symbol;
     /** Node capture events used by Lifecycle.Node */
     static readonly Node: unique symbol;
-    /** Identifies cache entry identifiers created with Entry() */
-    static readonly Cache: unique symbol;
 }
 /**
- * Phantom brand symbol for value type tracking on cache entry identifiers.
- * Uses a function type `(t: T) => T` to enforce invariance, preventing
- * a cache entry declared for one type from being used with a different type.
- * @internal
- */
-declare const CacheValueBrand: unique symbol;
-/**
- * A branded cache entry identifier.
- *
- * When the second type parameter `C` is provided, the entry becomes callable
- * to produce channeled identifiers for independent cache slots per channel.
+ * Internal symbol for the global `Lifecycle.Fault` broadcast. Exposed so the
+ * dispatch pipeline can fire faults and short-circuit the regulator policy
+ * without depending on the `Lifecycle` class at runtime.
  *
- * @template T - The cached value type.
- * @template C - The channel type for channeled entries (defaults to never).
- */
-export type CacheId<T = unknown, C extends Filter = never> = {
-    readonly [Brand.Cache]: symbol;
-    readonly [CacheValueBrand]?: (t: T) => T;
-} & ([C] extends [never] ? unknown : {
-    (channel: C): ChanneledCacheId<T, C>;
-});
-/**
- * Result of calling a channeled cache entry with a channel argument.
- * Contains the entry identity and the channel data for scoped cache access.
- *
- * @template T - The cached value type.
- * @template C - The channel type.
+ * @internal
  */
-export type ChanneledCacheId<T = unknown, C = unknown> = {
-    readonly [Brand.Cache]: symbol;
-    readonly [CacheValueBrand]?: (t: T) => T;
-    readonly channel: C;
-};
+export declare const FaultSymbol: unique symbol;
 /**
  * Factory functions for lifecycle actions.
  *
@@ -116,6 +86,9 @@ export type ChanneledCacheId<T = unknown, C = unknown> = {
  * // Now regulating Lifecycle.Mount only blocks THIS component's mount:
  * context.regulator.disallow(Actions.Mount);
  * ```
+ *
+ * `Lifecycle.Fault` is a singleton broadcast (not a factory). All components
+ * subscribe to the same shared symbol to receive global fault notifications.
  */
 export declare class Lifecycle {
     /** Creates a Mount lifecycle action. Triggered once on component mount (`useLayoutEffect`). */
@@ -151,6 +124,28 @@ export declare class Lifecycle {
     static Node(): HandlerPayload<unknown, {
         Name: string;
     }>;
+    /**
+     * Global fault broadcast. Receives a `Fault` whenever any action in the
+     * `<Boundary>` errors, times out, is supplanted, or is blocked by the
+     * regulator. Subscribe via `actions.useAction(Lifecycle.Fault, handler)`.
+     *
+     * Unlike the per-component `Lifecycle.Error()` factory, `Fault` is a single
+     * shared broadcast — every subscriber points at the same symbol. The
+     * regulator policy does not apply to `Fault`; faults always reach
+     * subscribers so error visibility cannot be silenced.
+     *
+     * @example
+     * ```tsx
+     * const actions = useActions<void, typeof Actions>();
+     *
+     * actions.useAction(Lifecycle.Fault, (context, fault) => {
+     *   if (fault.reason === Reason.Errored) {
+     *     console.error(`Action "${fault.action}" failed`, fault.error);
+     *   }
+     * });
+     * ```
+     */
+    static Fault: BroadcastPayload<Fault>;
 }
 /**
  * Distribution modes for actions.
@@ -274,8 +269,12 @@ export type ChanneledAction<P = unknown, C = unknown> = {
  * Broadcast actions are sent to all mounted components. Values are cached so that
  * late-mounting components receive the most recent payload.
  *
+ * Late-mounting components receive the most recent cached payload via their
+ * `useAction` handler during mount. Use `peek()` in a `Lifecycle.Mount` handler
+ * to check whether a cached value exists before performing default fetches.
+ *
  * This type extends `HandlerPayload<P, C>` with an additional brand to enforce at compile-time
- * that only broadcast actions can be passed to `context.actions.read()`.
+ * that only broadcast actions can be passed to `context.actions.resolution()`.
  *
  * @template P - The payload type for the action
  * @template C - The channel type for channeled dispatches (defaults to never)
@@ -284,8 +283,8 @@ export type ChanneledAction<P = unknown, C = unknown> = {
  * ```ts
  * const SignedOut = Action<User>("SignedOut", Distribution.Broadcast);
  *
- * // Read the latest value inside a handler
- * const user = await context.actions.read(SignedOut);
+ * // Resolve the latest value inside a handler
+ * const user = await context.actions.resolution(SignedOut);
  * ```
  */
 export type BroadcastPayload<P = unknown, C extends Filter = never> = HandlerPayload<P, C> & {
@@ -295,20 +294,21 @@ export type BroadcastPayload<P = unknown, C extends Filter = never> = HandlerPay
  * Branded type for multicast action objects created with `Action()` and `Distribution.Multicast`.
  * Multicast actions are dispatched to all components within a named scope boundary.
  *
- * When dispatching a multicast action, you MUST provide the scope name as the third argument:
+ * When dispatching a multicast action, you MUST provide the scope carrier as the third argument:
  * ```ts
- * actions.dispatch(Actions.Multicast.Update, payload, { scope: "MyScope" });
+ * actions.dispatch(Actions.Multicast.Update, payload, { scope: Actions.Multicast });
  * ```
  *
- * Components receive multicast events only if they are descendants of a `<Scope name="...">`.
+ * Components receive multicast events only if they are descendants of a `<Scope of={...}>`.
  *
  * @template P - The payload type for the action
  * @template C - The channel type for channeled dispatches (defaults to never)
  *
  * @example
  * ```tsx
- * // Define multicast actions in a shared class
+ * // Define multicast actions and their scope together
  * class MulticastActions {
+ *   static Scope = "Counter" as const;
  *   static Update = Action<number>("Update", Distribution.Multicast);
  * }
  *
@@ -318,26 +318,47 @@ export type BroadcastPayload<P = unknown, C extends Filter = never> = HandlerPay
  * }
  *
  * // In JSX - create a named scope boundary
- * <Scope name="Counter">
+ * <Scope of={MulticastActions}>
  *   <CounterA />
  *   <CounterB />
  * </Scope>
  *
- * // Inside CounterA - dispatch to all components in "Counter" scope
- * actions.dispatch(Actions.Multicast.Update, 42, { scope: "Counter" });
+ * // Inside CounterA - dispatch to all components in the scope
+ * actions.dispatch(Actions.Multicast.Update, 42, { scope: Actions.Multicast });
  * // CounterA and CounterB both receive the event
  * ```
  */
 export type MulticastPayload<P = unknown, C extends Filter = never> = HandlerPayload<P, C> & {
     readonly [Brand.Multicast]: true;
 };
+/**
+ * A scope carrier — any object exposing a `Scope` string literal.
+ *
+ * By convention this is the feature's `MulticastActions` class, which owns
+ * the scope name alongside its multicast action declarations:
+ *
+ * ```ts
+ * export class MulticastActions {
+ *   static Scope = "my-feature" as const;
+ *   static Update = Action<T>("Update", Distribution.Multicast);
+ * }
+ * ```
+ *
+ * Requiring a carrier (rather than a bare string) prevents typos and enforces
+ * a single source of truth for each scope name.
+ *
+ * @template S - The scope name literal type.
+ */
+export type ScopeCarrier<S extends string = string> = {
+    readonly Scope: S;
+};
 /**
  * Options for multicast dispatch.
  * Required when dispatching a multicast action.
  */
 export type MulticastOptions = {
-    /** The name of the scope to multicast to. Must match a `<Scope name="...">` ancestor. */
-    scope: string;
+    /** Carrier object exposing the scope name via `.Scope`. Typically the feature's `MulticastActions` class. */
+    scope: ScopeCarrier;
 };
 /**
  * Extracts the payload type `P` from a `HandlerPayload<P>` or `ChanneledAction<P, C>`.
@@ -665,45 +686,6 @@ export type HandlerContext<M extends Model | void, _AC extends Actions | void, D
         }) => void>(ƒ: F & AssertSync<F>): void;
         dispatch(action: ActionOrChanneled, payload?: unknown, options?: MulticastOptions): Promise<void>;
         annotate<T>(operation: Operation, value: T): T;
-        /**
-         * Fetches a value from the cache or executes the callback if not cached / expired.
-         *
-         * The callback must return an `Option<T>` or `Result<T, E>`. Only `Some` / `Ok`
-         * values are stored; `None` / `Error` results are skipped and `{ data: null }`
-         * is returned. Exactly one layer of `Option` / `Result` is unwrapped.
-         *
-         * @param entry - The cache entry identifier (from `Entry()`).
-         * @param ttl - Time-to-live in milliseconds.
-         * @param fn - Async callback that produces the value to cache.
-         * @returns An object with `data` set to the cached or freshly-fetched value, or `null`.
-         *
-         * @example
-         * ```ts
-         * const { data } = await context.actions.cacheable(
-         *   CacheStore.Pairs,
-         *   30_000,
-         *   async () => Some(await api.fetchPairs()),
-         * );
-         * ```
-         */
-        cacheable<T>(entry: CacheId<T> | ChanneledCacheId<T>, ttl: number, fn: () => Promise<Option<T>>): Promise<{
-            data: T | null;
-        }>;
-        cacheable<T>(entry: CacheId<T> | ChanneledCacheId<T>, ttl: number, fn: () => Promise<TsBeltResult<T, unknown>>): Promise<{
-            data: T | null;
-        }>;
-        /**
-         * Removes a cached value from the store.
-         *
-         * @param entry - The cache entry identifier to invalidate.
-         *
-         * @example
-         * ```ts
-         * context.actions.invalidate(CacheStore.Pairs);
-         * context.actions.invalidate(CacheStore.User({ UserId: 5 }));
-         * ```
-         */
-        invalidate(entry: CacheId<unknown> | ChanneledCacheId<unknown>): void;
         /**
          * Feature toggle methods for mutating boolean flags on the model.
          *
@@ -720,20 +702,21 @@ export type HandlerContext<M extends Model | void, _AC extends Actions | void, D
             invert<K extends keyof FeatureFlags<M>>(name: K): void;
         };
         /**
-         * Reads the latest broadcast or multicast value, waiting for annotations to settle.
+         * Returns the resolved broadcast or multicast value, waiting for any
+         * pending annotations to settle before resolving.
          *
          * If a value has already been dispatched it resolves immediately.
          * Otherwise it waits until the next dispatch of the action.
          * Resolves with `null` if the task is aborted before a value arrives.
          *
-         * @param action - The broadcast or multicast action to read.
-         * @param options - For multicast actions, must include `{ scope: "ScopeName" }`.
+         * @param action - The broadcast or multicast action to resolve.
+         * @param options - For multicast actions, must include `{ scope: MulticastActions }`.
          * @returns The dispatched value, or `null` if aborted.
          *
          * @example
          * ```ts
          * actions.useAction(Actions.FetchPosts, async (context) => {
-         *   const user = await context.actions.read(Actions.Broadcast.User);
+         *   const user = await context.actions.resolution(Actions.Broadcast.User);
          *   if (!user) return;
          *   const posts = await fetchPosts(user.id, {
          *     signal: context.task.controller.signal,
@@ -742,15 +725,15 @@ export type HandlerContext<M extends Model | void, _AC extends Actions | void, D
          * });
          * ```
          */
-        read<T>(action: BroadcastPayload<T>): Promise<T | null>;
-        read<T>(action: MulticastPayload<T>, options: MulticastOptions): Promise<T | null>;
+        resolution<T>(action: BroadcastPayload<T>): Promise<T | null>;
+        resolution<T>(action: MulticastPayload<T>, options: MulticastOptions): Promise<T | null>;
         /**
          * Returns the latest broadcast or multicast value immediately without
          * waiting for annotations to settle. Use this when you need the current
          * cached value and do not need to wait for pending operations to complete.
          *
          * @param action - The broadcast or multicast action to peek at.
-         * @param options - For multicast actions, must include `{ scope: "ScopeName" }`.
+         * @param options - For multicast actions, must include `{ scope: MulticastActions }`.
          * @returns The cached value, or `null` if no value has been dispatched.
          *
          * @example
@@ -854,14 +837,14 @@ export type UseActions<M extends Model | void, AC extends Actions | void, D exte
         /**
          * Dispatches an action with an optional payload.
          *
-         * For multicast actions, you MUST provide the scope as the third argument:
+         * For multicast actions, you MUST provide the scope carrier as the third argument:
          * ```ts
-         * actions.dispatch(Actions.Multicast.Update, payload, { scope: "MyScope" });
+         * actions.dispatch(Actions.Multicast.Update, payload, { scope: Actions.Multicast });
          * ```
          *
          * @param action - The action to dispatch
          * @param payload - The payload to send with the action
-         * @param options - For multicast actions, must include `{ scope: "ScopeName" }`
+         * @param options - For multicast actions, must include `{ scope: MulticastActions }`
          */
         dispatch<P>(action: HandlerPayload<P>, payload?: P, options?: MulticastOptions): Promise<void>;
         dispatch<P>(action: BroadcastPayload<P>, payload?: P, options?: MulticastOptions): Promise<void>;
@@ -975,4 +958,22 @@ export type UseActions<M extends Model | void, AC extends Actions | void, D exte
      * ```
      */
     useAction<A extends ActionId | HandlerPayload | ChanneledAction>(action: A, handler: (context: HandlerContext<M, AC, D>, ...args: [Payload<A>] extends [never] ? [] : [payload: Payload<A>]) => void | Promise<void> | AsyncGenerator | Generator): void;
+    /**
+     * Connects a {@link Resource} declared at module scope to this component.
+     * Returns a thunk that fetches fresh data on every call &ndash; concurrent
+     * calls share the in-flight promise. The Resource's `onSuccess` and
+     * `onError` callbacks receive `(response, data, dispatch)` where `data`
+     * is this component's reactive `data` proxy.
+     *
+     * @example
+     * ```ts
+     * const fetchUser = actions.useResource(resources.user);
+     *
+     * actions.useAction(Actions.Mount, async (context) => {
+     *   const data = await fetchUser();
+     *   context.actions.produce(({ model }) => { model.user = data; });
+     * });
+     * ```
+     */
+    useResource<T, E, Args extends readonly unknown[]>(resource: import('../resource/index.ts').ResourceHandle<T, E, Args>): (...args: Args) => Promise<T>;
 };

package/dist/utils/index.d.ts

@@ -1,21 +1,4 @@
 import { Pk } from '../types/index.ts';
-/**
- * Configuration constants for Chizu action symbols.
- */
-export declare const config: {
-    /** Prefix for all Chizu action symbols. */
-    actionPrefix: string;
-    /** Prefix for broadcast action symbols. */
-    broadcastActionPrefix: string;
-    /** Prefix for multicast action symbols. */
-    multicastActionPrefix: string;
-    /** Prefix for channeled action symbols. */
-    channelPrefix: string;
-    /** Prefix for cache operation symbols. */
-    cachePrefix: string;
-    /** Prefix for lifecycle action symbols. */
-    lifecyclePrefix: string;
-};
 /**
  * Returns a promise that resolves after the specified number of milliseconds.
  * The sleep will reject with an AbortError when the signal is aborted,

package/dist/utils.d.ts

@@ -1,3 +1,29 @@
+/**
+ * Internal symbol description factories. Each function returns a namespaced
+ * string suitable for `Symbol()` descriptions or `startsWith` checks.
+ *
+ * @internal
+ */
+export declare const describe: {
+    /** Unicast action description. `describe.action("Fetch")` → `"chizu.action/Fetch"` */
+    action: (name?: string) => string;
+    /** Broadcast action description. `describe.broadcast("User")` → `"chizu.action/broadcast/User"` */
+    broadcast: (name?: string) => string;
+    /** Multicast action description. `describe.multicast("Update")` → `"chizu.action/multicast/Update"` */
+    multicast: (name?: string) => string;
+    /** Channeled action description. `describe.channel("user")` → `"chizu.channel/user"` */
+    channel: (name?: string) => string;
+    /** Cache entry description. `describe.cache("users")` → `"chizu.cache/users"` */
+    cache: (name?: string) => string;
+    /** Lifecycle action description. `describe.lifecycle("Mount")` → `"chizu.action.lifecycle/Mount"` */
+    lifecycle: (name?: string) => string;
+    /** Mount replay sentinel description. Used to create the {@link replay} symbol. */
+    replay: (name?: string) => string;
+};
+/**
+ * Flat record used for shallow property comparison in {@link changes}.
+ * @internal
+ */
 type Changes = Record<string, unknown>;
 /**
  * Get high-level changed paths between two objects.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chizu",
-  "version": "0.2.72",
+  "version": "0.3.0",
   "type": "module",
   "license": "MIT",
   "packageManager": "yarn@1.22.22",
@@ -47,6 +47,7 @@
     "@testing-library/dom": "^10.4.1",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.2",
+    "@types/dom-navigation": "^1.0.7",
     "@types/lodash": "^4.17.23",
     "@types/ramda": "^0.31.1",
     "@types/react": "^19.2.14",
@@ -70,6 +71,7 @@
     "jest": "^30.2.0",
     "jest-environment-jsdom": "^30.2.0",
     "jsdom": "^28.1.0",
+    "ky": "^2.0.2",
     "lodash": "^4.17.23",
     "lucide-react": "^0.564.0",
     "madge": "^8.0.0",
@@ -80,6 +82,7 @@
     "react-flip-numbers": "^3.0.9",
     "react-router-dom": "^7.13.0",
     "react-test-renderer": "^19.2.4",
+    "react-wayfinder": "^0.1.3",
     "rollup-plugin-visualizer": "^6.0.5",
     "terser": "^5.46.0",
     "traverse": "^0.6.11",

package/dist/boundary/components/cache/index.d.ts

@@ -1,13 +0,0 @@
-import { Props } from './types.ts';
-import * as React from "react";
-export { useCacheStore } from './utils.ts';
-export type { CacheContext } from './types.ts';
-/**
- * Creates a new cache context for storing values from `context.actions.cacheable`.
- * Automatically included in `<Boundary>`. Only needed directly if you want to
- * isolate a cache context.
- *
- * @param props.children - The children to render within the cache context.
- * @returns The children wrapped in a cache context provider.
- */
-export declare function CacheProvider({ children }: Props): React.ReactNode;