march-hare 0.6.0 → 0.7.0

package/dist/src/library/types/index.d.ts

@@ -1,6 +1,7 @@
 import { Operation, Process, Inspect, Box } from 'immertation';
 import { ActionId, Task, Tasks } from '../boundary/components/tasks/types.ts';
 import { Fault } from '../error/types.ts';
+import { Store } from '../boundary/components/store/index.tsx';
 import * as React from "react";
 export type { ActionId, Box, Task, Tasks };
 /**
@@ -31,6 +32,20 @@ export type BrandedMulticast = {
 export type BrandedObject = {
     readonly [x: symbol]: unknown;
 };
+/**
+ * Recursive readonly. Locks every nested property so that read-only
+ * projections on `context` (model, data, store) reject direct assignment
+ * — mutation must go through `context.actions.produce(...)`.
+ *
+ * Function types pass through untouched so method calls (e.g.
+ * `AbortController#abort`) remain callable. Built-in mutable containers
+ * are mapped to their readonly counterparts.
+ *
+ * @internal
+ */
+export type DeepReadonly<T> = T extends (...args: never) => unknown ? T : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepReadonly<U>> : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends ReadonlySet<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;
 /**
  * Union type representing any valid action that can be passed to action utilities.
  * This includes raw ActionIds (symbol/string), and any branded object.
@@ -53,6 +68,13 @@ export declare class Brand {
     static readonly Action: unique symbol;
     /** Identifies channeled actions (result of calling Action(channel)) */
     static readonly Channel: unique symbol;
+    /**
+     * Phantom brand carrying the action's literal name. Used purely at the
+     * type level to make `Action("X")` and `Action("Y")` produce
+     * structurally-distinct types so `dispatch`/`useAction` can reject
+     * symbols imported from a class outside `AC`.
+     */
+    static readonly Name: unique symbol;
 }
 /**
  * Internal symbol for the global `Lifecycle.Fault` broadcast. Exposed so the
@@ -86,13 +108,13 @@ export declare const FaultSymbol: unique symbol;
  */
 export declare class Lifecycle {
     /** Creates a Mount lifecycle action. Triggered once on component mount (`useLayoutEffect`). */
-    static Mount(): HandlerPayload<never>;
+    static Mount(): HandlerPayload<never, never, "Mount">;
     /** Creates an Unmount lifecycle action. Triggered when the component unmounts. */
-    static Unmount(): HandlerPayload<never>;
+    static Unmount(): HandlerPayload<never, never, "Unmount">;
     /** Creates an Error lifecycle action. Triggered when an action throws. Receives `Fault` as payload. */
-    static Error(): HandlerPayload<Fault>;
+    static Error(): HandlerPayload<Fault, never, "Error">;
     /** Creates an Update lifecycle action. Triggered when `context.data` changes (not on initial mount). */
-    static Update(): HandlerPayload<Record<string, unknown>>;
+    static Update(): HandlerPayload<Record<string, unknown>, never, "Update">;
     /**
      * Global fault broadcast. Receives a `Fault` whenever any action in the
      * `<Boundary>` errors, times out, or is supplanted. Subscribe via
@@ -112,7 +134,7 @@ export declare class Lifecycle {
      * });
      * ```
      */
-    static Fault: BroadcastPayload<Fault>;
+    static Fault: BroadcastPayload<Fault, never, "Fault">;
 }
 /**
  * Distribution modes for actions.
@@ -209,12 +231,13 @@ export type Model<M = Record<string, unknown>> = M;
  * dispatch(UserUpdated({ UserId: 5 }), user);     // channeled dispatch
  * ```
  */
-export type HandlerPayload<P = unknown, C extends Filter = never> = {
+export type HandlerPayload<P = unknown, C extends Filter = never, Name extends string = string> = {
     readonly [Brand.Action]: symbol;
     readonly [Brand.Payload]: P;
+    readonly [Brand.Name]: Name;
     readonly [Brand.Broadcast]?: boolean;
 } & ([C] extends [never] ? unknown : {
-    (channel: C): ChanneledAction<P, C>;
+    (channel: C): ChanneledAction<P, C, Name>;
 });
 /**
  * Result of calling an action with a channel argument.
@@ -231,10 +254,11 @@ export type HandlerPayload<P = unknown, C extends Filter = never> = {
  * dispatch(UserUpdated({ UserId: 5 }), user);
  * ```
  */
-export type ChanneledAction<P = unknown, C = unknown> = {
+export type ChanneledAction<P = unknown, C = unknown, Name extends string = string> = {
     readonly [Brand.Action]: symbol;
     readonly [Brand.Payload]: P;
     readonly [Brand.Channel]: C;
+    readonly [Brand.Name]: Name;
     readonly channel: C;
 };
 /**
@@ -260,7 +284,7 @@ export type ChanneledAction<P = unknown, C = unknown> = {
  * const user = await context.actions.resolution(SignedOut);
  * ```
  */
-export type BroadcastPayload<P = unknown, C extends Filter = never> = HandlerPayload<P, C> & {
+export type BroadcastPayload<P = unknown, C extends Filter = never, Name extends string = string> = HandlerPayload<P, C, Name> & {
     readonly [Brand.Broadcast]: true;
 };
 /**
@@ -306,7 +330,7 @@ export type BroadcastPayload<P = unknown, C extends Filter = never> = HandlerPay
  * actions.dispatch(Actions.Multicast.Update, 42);
  * ```
  */
-export type MulticastPayload<P = unknown, C extends Filter = never> = HandlerPayload<P, C> & {
+export type MulticastPayload<P = unknown, C extends Filter = never, Name extends string = string> = HandlerPayload<P, C, Name> & {
     readonly [Brand.Multicast]: true;
 };
 /**
@@ -401,8 +425,8 @@ export type Actions = object;
 export type Result = {
     processes: Set<Process>;
 };
-export type HandlerContext<M extends Model | void, _AC extends Actions | void, D extends Props = Props> = {
-    readonly model: Readonly<M>;
+export type HandlerContext<M extends Model | void, AC extends Actions | void, D extends Props = Props> = {
+    readonly model: DeepReadonly<M>;
     /**
      * The current lifecycle phase of the component.
      * Useful for determining if the handler was called during mount (e.g., from a cached
@@ -458,7 +482,7 @@ export type HandlerContext<M extends Model | void, _AC extends Actions | void, D
      * });
      * ```
      */
-    readonly data: D;
+    readonly data: DeepReadonly<D>;
     /**
      * Set of all running tasks across all components in the context.
      * Tasks are ordered by creation time (oldest first).
@@ -490,13 +514,87 @@ export type HandlerContext<M extends Model | void, _AC extends Actions | void, D
      * ```
      */
     readonly tasks: ReadonlySet<Task>;
+    /**
+     * Read-only view of the per-`<Boundary>` Store &mdash; ambient,
+     * cross-cutting state (session, locale, feature flags, etc.) typed
+     * via module augmentation on the library's `Store` interface.
+     * Identical to the value returned by `useStore()` at the hook level.
+     *
+     * Reads use plain dot notation and always reflect the latest value,
+     * even after `await` boundaries. Writes go through
+     * `context.actions.produce(({ store }) => { store.x = ... })`
+     * &mdash; the same Immer-style recipe used for the model.
+     *
+     * @example
+     * ```ts
+     * actions.useAction(Actions.SignIn, async (context, credentials) => {
+     *   const result = await context.actions.resource(signIn(credentials));
+     *   context.actions.produce(({ store }) => {
+     *     store.session = result;
+     *   });
+     * });
+     *
+     * actions.useAction(Actions.Refresh, async (context) => {
+     *   if (context.store.session === null) return;
+     *   // ...
+     * });
+     * ```
+     */
+    readonly store: DeepReadonly<Store>;
     readonly actions: {
         produce<F extends (draft: {
             model: M;
+            store: Store;
             readonly inspect: Readonly<Inspect<M>>;
         }) => void>(ƒ: F & AssertSync<F>): void;
-        dispatch(action: ActionOrChanneled, payload?: unknown): Promise<void>;
+        dispatch(action: NoPayloadActions<Dispatchable<AC>>): Promise<void>;
+        dispatch<A extends WithPayloadActions<Dispatchable<AC>>>(action: A, payload: Payload<A>): Promise<void>;
         annotate<T>(value: T, operation?: Operation): T;
+        /**
+         * Fetches a {@link Resource} with the abort controller and Store
+         * snapshot auto-threaded from the current handler context. The
+         * argument is a resource invocation (`cat({ id: 5 })`) &mdash; the
+         * call primes a slot with the resource and params, and
+         * `.resource(...)` reads it. The return value is a thenable &mdash;
+         * `await` it to fire the fetch unconditionally, or use
+         * `.exceeds(duration)` to short-circuit when the per-params cache
+         * slot is still within the supplied freshness window (i.e. fetch
+         * only when the cache age *exceeds* the duration).
+         *
+         * @example
+         * ```ts
+         * actions.useAction(Actions.Mount, async (context) => {
+         *   // Always fetch.
+         *   const fresh = await context.actions.resource(user({ id: 5 }));
+         *
+         *   // Reuse cache when < 5 minutes old.
+         *   const maybe = await context.actions
+         *     .resource(user({ id: 5 }))
+         *     .exceeds({ minutes: 5 });
+         *
+         *   context.actions.produce(({ model }) => void (model.user = fresh));
+         * });
+         * ```
+         */
+        resource: (<T>(invocation: T | null) => PromiseLike<T> & {
+            readonly exceeds: (duration: Temporal.DurationLike) => Promise<T>;
+        }) & {
+            /**
+             * Writes `data` into the per-params cache slot of the resource
+             * invocation passed as the first argument, with a fresh timestamp.
+             * Use this when payloads arrive out-of-band (SSE, WebSocket,
+             * postMessage) and need to be reflected in the Resource cache
+             * without a fetcher round-trip.
+             *
+             * @example
+             * ```ts
+             * actions.useAction(Actions.Broadcast.UserSSE, (context, payload) => {
+             *   context.actions.resource.set(user({ id: payload.id }), payload);
+             * });
+             * ```
+             */
+            set<T>(invocation: T | null, data: T): void;
+        };
         /**
          * Returns the resolved broadcast or multicast value, waiting for any
          * pending annotations to settle before resolving.
@@ -586,6 +684,50 @@ export type Handler<M extends Model | void, AC extends Actions | void, K extends
  * as a handler key and avoids recursion into Function internals.
  */
 type OwnKeys<AC> = Exclude<keyof AC & string, "prototype">;
+/**
+ * Recursively flattens an actions class into the union of its leaf action
+ * types. A "leaf" is any property whose own string keys are empty &mdash; the
+ * branded `HandlerPayload` / `BroadcastPayload` / `MulticastPayload` values
+ * produced by `Action(...)` and `Lifecycle.*()`. Nested namespace classes
+ * (e.g. `static Broadcast = BroadcastActions`) are descended into.
+ *
+ * Used to constrain `dispatch` and `useAction` so that only actions owned by
+ * the component's `AC` (plus the global `Lifecycle.Fault`) can be referenced.
+ */
+export type LeafActions<AC> = AC extends void ? never : {
+    [K in OwnKeys<AC>]: OwnKeys<AC[K]> extends never ? AC[K] : LeafActions<AC[K]>;
+}[OwnKeys<AC>];
+/**
+ * Maps each action in a union to its channeled-call variant, when one exists.
+ * Distributes over unions so a mixed bag of leaf actions produces the union
+ * of their `ChanneledAction<P, C>` results.
+ */
+export type ChanneledOf<A> = A extends HandlerPayload<infer P, infer C> ? [C] extends [never] ? never : ChanneledAction<P, C> : never;
+/**
+ * Everything `dispatch` accepts for a given `AC`: leaf actions on the class
+ * and their channeled-call variants. The shared `Lifecycle.Fault` broadcast
+ * is excluded — it's library-internal and not user-dispatchable.
+ */
+export type Dispatchable<AC> = LeafActions<AC> | ChanneledOf<LeafActions<AC>>;
+/**
+ * Everything `useAction` will subscribe to for a given `AC`: same as
+ * `Dispatchable<AC>` plus the shared `Lifecycle.Fault` broadcast which lives
+ * outside `AC` but is subscribable by any component.
+ */
+export type Subscribable<AC> = Dispatchable<AC> | typeof Lifecycle.Fault;
+/**
+ * Subset of a union of actions whose payload type is `never`. Used to split
+ * `dispatch`/`useAction` into a no-payload and a with-payload overload so
+ * TypeScript reports a clear "no overload matches" error instead of widening
+ * the inferred action type when constraints don't match.
+ */
+export type NoPayloadActions<U> = Extract<U, {
+    readonly [Brand.Payload]: never;
+}>;
+/** Subset of a union of actions whose payload type is non-`never`. */
+export type WithPayloadActions<U> = Exclude<U, {
+    readonly [Brand.Payload]: never;
+}>;
 /**
  * Recursive mapped type for action handlers that mirrors the action class hierarchy.
  *
@@ -633,10 +775,8 @@ export type UseActions<M extends Model | void, AC extends Actions | void, D exte
          * their scope from the action declaration, so no extra options are
          * required at the call site.
          */
-        dispatch<P>(action: HandlerPayload<P>, payload?: P): Promise<void>;
-        dispatch<P>(action: BroadcastPayload<P>, payload?: P): Promise<void>;
-        dispatch<P>(action: MulticastPayload<P>, payload?: P): Promise<void>;
-        dispatch<P, C extends Filter>(action: ChanneledAction<P, C>, payload?: P): Promise<void>;
+        dispatch(action: NoPayloadActions<Dispatchable<AC>>): Promise<void>;
+        dispatch<A extends WithPayloadActions<Dispatchable<AC>>>(action: A, payload: Payload<A>): Promise<void>;
         inspect: Inspect<M>;
         /**
          * Streams broadcast values declaratively in JSX using a render-prop pattern.
@@ -689,30 +829,6 @@ 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 frozen `{ run, data, at }` object &ndash; `run` triggers a
-     * fresh network call (concurrent calls share the in-flight promise),
-     * while `data` and `at` are read-only snapshots of the most recent
-     * successful payload and the instant it resolved.
-     *
-     * `data` and `at` are non-reactive &mdash; reading them does not
-     * subscribe the component to updates. Drive UI from the model.
-     *
-     * @example
-     * ```ts
-     * const user = actions.useResource(resources.user);
-     *
-     * actions.useAction(Actions.Mount, async (context) => {
-     *   const data = await user.run();
-     *   context.actions.produce(({ model }) => { model.user = data; });
-     * });
-     * ```
-     */
-    useResource<T, P extends object>(resource: import('../resource/index.ts').ResourceHandle<T, P>): Readonly<{
-        run: import('../resource/index.ts').BoundRun<T, P>;
-        data: T | null;
-        at: Temporal.Instant | null;
-    }>;
+    useAction(action: NoPayloadActions<Subscribable<AC>>, handler: (context: HandlerContext<M, AC, D>) => void | Promise<void> | AsyncGenerator | Generator): void;
+    useAction<A extends WithPayloadActions<Subscribable<AC>>>(action: A, handler: (context: HandlerContext<M, AC, D>, payload: Payload<A>) => void | Promise<void> | AsyncGenerator | Generator): void;
 };

package/dist/src/library/utils/index.d.ts

@@ -1,42 +1,52 @@
 import { Pk } from '../types/index.ts';
+export { unset } from './utils.ts';
+export type { Stored, Unset } from './types.ts';
 /**
- * Returns a promise that resolves after the specified number of milliseconds.
- * The sleep will reject with an AbortError when the signal is aborted,
- * allowing cleanup of pending operations.
+ * Returns a promise that resolves after the specified number of
+ * milliseconds, or rejects with an {@link AbortError} when the signal is
+ * aborted. Use to inject a cancellable delay into an action handler.
  *
- * @param ms The number of milliseconds to sleep.
- * @param signal AbortSignal to cancel the sleep early.
- * @returns A promise that resolves after the delay or rejects if aborted.
+ * @param ms How long to wait before resolving.
+ * @param signal Optional {@link AbortSignal} that cancels the sleep early.
+ *               Pass `context.task.controller.signal` to tie the wait to
+ *               the lifetime of the current action.
+ * @returns A promise that resolves after `ms` milliseconds or rejects with
+ *          an {@link AbortError} if `signal` aborts first.
  */
 export declare function sleep(ms: number, signal: AbortSignal | undefined): Promise<void>;
-/** Shorthand alias for {@link sleep}. */
-export declare const ζ: typeof sleep;
 /**
- * Repeatedly calls a function at a fixed interval until it returns `true` or
- * the signal is aborted. The function is invoked immediately on the first
- * iteration, then after each interval.
+ * Repeatedly calls a function at a fixed interval until it returns `true`
+ * or the signal is aborted. The function is invoked immediately on the
+ * first iteration, then after each interval.
  *
- * @param ms The interval in milliseconds between invocations.
- * @param signal Optional AbortSignal to cancel polling early.
- * @param fn Callback invoked each iteration. Return `true` to stop polling.
- * @returns A promise that resolves when `fn` returns `true`, or rejects with
- *          an AbortError if the signal is aborted.
+ * @param ms Interval in milliseconds between invocations of `fn`.
+ * @param signal Optional {@link AbortSignal} that cancels polling early.
+ *               Aborts propagate as an {@link AbortError} rejection.
+ * @param fn Predicate invoked each iteration. Return `true` to stop
+ *           polling, `false` to schedule another invocation after `ms`.
+ *           May be sync or async.
+ * @returns A promise that resolves when `fn` returns `true`, or rejects
+ *          with an {@link AbortError} if `signal` aborts first.
  */
 export declare function poll(ms: number, signal: AbortSignal | undefined, fn: () => boolean | Promise<boolean>): Promise<void>;
-/** Shorthand alias for {@link poll}. */
-export declare const π: typeof poll;
 /**
  * Generates a unique primary key.
+ *
  * @returns A new unique symbol representing the primary key.
  */
 export declare function pk(): symbol;
 /**
- * Checks if the provided ID is a valid primary key.
- * A valid primary key is considered any value that is not a symbol.
- * @template T The type of the object.
+ * Checks if the provided ID is a valid primary key. A valid primary key
+ * is any value that is not a symbol.
+ *
+ * @template T The model type the key identifies.
  * @param id The primary key to validate.
- * @returns `true` if the ID is valid, `false` otherwise.
+ * @returns `true` if `id` is a non-symbol value, `false` otherwise.
  */
 export declare function pk<T>(id: Pk<T>): boolean;
+/** Shorthand alias for {@link sleep}. */
+export declare const ζ: typeof sleep;
+/** Shorthand alias for {@link poll}. */
+export declare const π: typeof poll;
 /** Shorthand alias for {@link pk}. */
 export declare const κ: typeof pk;

package/dist/src/library/utils/types.d.ts

@@ -0,0 +1,18 @@
+import { unset } from './utils.ts';
+/** Nominal type of the {@link unset} sentinel. */
+export type Unset = typeof unset;
+/**
+ * Common shape for a possibly-present value with a timestamp. Produced by
+ * `Cache.get(key)` (from persistent storage or in-memory) and consumed
+ * internally by Resource's per-params cache slots.
+ *
+ * @template T The payload type when present.
+ */
+export type Stored<T> = {
+    /** The payload, or {@link unset} when nothing is recorded. */
+    readonly data: T | Unset;
+    /** When the payload was recorded, or `null` when nothing is recorded. */
+    readonly at: Temporal.Instant | null;
+    /** Returns {@link data} when present, otherwise the supplied fallback. */
+    readonly else: <U>(fallback: U) => T | U;
+};

package/dist/src/library/utils/utils.d.ts

@@ -1,5 +1,36 @@
+import { Stored } from './types.ts';
 /**
- * Returns a function to force a component re-render.
- * Useful when state is managed externally (e.g., refs) but the UI needs updating.
+ * Sentinel symbol marking "no value present yet". Shared by the Resource
+ * cache and by storage handles so callers can distinguish "nothing has been
+ * recorded" from "a legitimately stored null".
+ */
+export declare const unset: unique symbol;
+/**
+ * Returns a function to force a component re-render. Useful when state is
+ * managed externally (e.g., refs) but the UI needs updating.
+ *
+ * @returns A zero-arg callback that schedules a re-render of the host
+ *          component when invoked.
  */
 export declare function useRerender(): () => void;
+/**
+ * Constructs a {@link Stored} in the empty state. Internal helper shared
+ * by the storage layer and the Resource snapshot accessor.
+ *
+ * @template T The payload type the resulting Stored would carry if populated.
+ * @returns A Stored with `data` set to {@link unset} and `at` set to `null`.
+ *          Its `.else(fallback)` returns the fallback unchanged.
+ * @internal
+ */
+export declare function empty<T>(): Stored<T>;
+/**
+ * Constructs a {@link Stored} wrapping a present payload and timestamp.
+ *
+ * @template T The payload type carried by the Stored.
+ * @param data The payload value to wrap.
+ * @param at The instant the payload was recorded — flows through to the
+ *           Resource cache as the entry's `at` timestamp.
+ * @returns A Stored whose `.else(fallback)` returns `data` unchanged.
+ * @internal
+ */
+export declare function present<T>(data: T, at: Temporal.Instant): Stored<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-hare",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "license": "MIT",
   "packageManager": "yarn@1.22.22",
@@ -30,7 +30,7 @@
   ],
   "scripts": {
     "build": "vite build",
-    "build:example": "vite build --mode example --outDir dist-example --base /march-hare/",
+    "build:example": "vite build --mode example --outDir dist-example --base /MarchHare/ && mv dist-example/src/example/index.html dist-example/index.html && rm -rf dist-example/src",
     "dev": "vite",
     "preview": "vite preview",
     "release": "make checks",
@@ -88,7 +88,7 @@
     "react-flip-numbers": "^3.0.9",
     "react-router-dom": "^7.13.0",
     "react-test-renderer": "^19.2.4",
-    "react-wayfinder": "^0.1.3",
+    "react-wayfinder": "^0.1.4",
     "rollup-plugin-visualizer": "^6.0.5",
     "terser": "^5.46.0",
     "traverse": "^0.6.11",

package/dist/src/library/boundary/components/mode/index.d.ts

@@ -1,15 +0,0 @@
-import { Props } from './types.ts';
-import * as React from "react";
-export { useMode } from './utils.ts';
-export type { ModeHandle } from './utils.ts';
-/**
- * Provides a single mutable mode handle to every component inside the
- * boundary. Components opt in by calling {@link useMode} and threading the
- * returned handle through {@link useActions}'s `data` callback.
- *
- * Mode is **not** reactive — mutating it does not trigger a re-render.
- * Use it for cross-handler coordination (e.g. flagging an in-progress
- * sign-out) when you do not want the value showing up as render-time UI
- * state.
- */
-export declare function Mode({ children }: Props): React.ReactNode;

package/dist/src/library/boundary/components/mode/types.d.ts

@@ -1,7 +0,0 @@
-import { ReactNode } from 'react';
-/**
- * Props for the Mode provider component.
- */
-export type Props = {
-    children: ReactNode;
-};

package/dist/src/library/boundary/components/mode/utils.d.ts

@@ -1,55 +0,0 @@
-import * as React from "react";
-/**
- * React context exposing the per-Boundary mode handle. The handle itself
- * is stable across renders — readers grab `.current` at call time.
- *
- * @internal
- */
-export declare const Context: React.Context<React.RefObject<unknown>>;
-/**
- * Handle returned by {@link useMode}. Reads always reflect the latest
- * write, even after `await` boundaries.
- */
-export type ModeHandle<T> = {
-    read(): T | null;
-    update(value: T | null): void;
-};
-/**
- * Hook that returns a `{ read, update }` handle to the per-Boundary mode
- * value.
- *
- * Mode is a single mutable value shared across every component inside the
- * surrounding `<Boundary>`. It is **not** reactive &mdash; mutating it does
- * not trigger a re-render. Use it for coordinating between async action
- * handlers (e.g. short-circuiting refreshes during sign-out).
- *
- * Pass the handle through the {@link useActions} `data` callback so it
- * shows up under `context.data` inside handlers, fully typed.
- *
- * @example
- * ```ts
- * enum Mode {
- *   Idle,
- *   SigningOut,
- * }
- *
- * function useSignOutActions() {
- *   const mode = useMode<Mode>();
- *   const actions = useActions<Model, typeof Actions>(model, () => ({ mode }));
- *
- *   actions.useAction(Actions.SignOut, async (context) => {
- *     context.data.mode.update(Mode.SigningOut);
- *     await api.signOut();
- *     context.data.mode.update(Mode.Idle);
- *   });
- *
- *   actions.useAction(Actions.Refresh, async (context) => {
- *     if (context.data.mode.read() === Mode.SigningOut) return;
- *     // ...
- *   });
- *
- *   return actions;
- * }
- * ```
- */
-export declare function useMode<T>(): ModeHandle<T>;