march-hare 0.6.1 → 0.7.1

package/dist/resource/utils.d.ts

@@ -0,0 +1,37 @@
+import { Cache } from '../cache/index';
+import { unset } from '../utils/index';
+export { Cache } from '../cache/index';
+/**
+ * Default in-memory `Cache` used when {@link Resource} is constructed
+ * without an explicit one. Each fetcher gets its own slot via the
+ * outer `WeakMap` so unrelated Resources don't share a string-key
+ * namespace.
+ *
+ * @internal
+ */
+export declare const defaults: WeakMap<object, Cache>;
+/**
+ * Returns the {@link Cache} bound to `fetcher`, allocating a fresh
+ * in-memory Cache on first access.
+ *
+ * @internal
+ */
+export declare function defaultCache(fetcher: object): Cache;
+/**
+ * Stable string key derived from the call-site `params`. Two calls with
+ * the same logical params (same key order, same primitive values) hit
+ * the same slot. JSON.stringify is sufficient for the Chizu params
+ * convention (primitive-leaf objects); callers who need order-stable
+ * keying should normalise the object before passing it in.
+ *
+ * @internal
+ */
+export declare function key(params: object): string;
+/**
+ * Re-export of the shared `unset` sentinel from {@link "../utils/index.ts"}.
+ *
+ * @internal
+ */
+export declare const config: {
+    readonly unset: typeof unset;
+};

package/dist/{src/library/types → 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 { ActionId, Task, Tasks } from '../boundary/components/tasks/types';
+import { Fault } from '../error/types';
+import { Store } from '../boundary/components/store/index';
 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,5 +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;
+    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 → utils}/index.d.ts

@@ -1,7 +1,6 @@
-import { Pk } from '../types/index.ts';
-import { Adapter, Store } from './types.ts';
-export { unset } from './utils.ts';
-export type { Adapter, Encoded, Store, Stored, Unset } from './types.ts';
+import { Pk } from '../types/index';
+export { unset } from './utils';
+export type { Stored, Unset } from './types';
 /**
  * Returns a promise that resolves after the specified number of
  * milliseconds, or rejects with an {@link AbortError} when the signal is
@@ -45,48 +44,9 @@ export declare function pk(): symbol;
  * @returns `true` if `id` is a non-symbol value, `false` otherwise.
  */
 export declare function pk<T>(id: Pk<T>): boolean;
-/**
- * Wraps a synchronous {@link Adapter} into a {@link Store} that traffics
- * in {@link Stored} values. Storage entries serialise as
- * {@link Encoded}`<T>` so the `Temporal.Instant` timestamp survives the
- * string round-trip and `BoundResourceHandle.if({ over })` can
- * short-circuit on the persisted timestamp after a reload.
- *
- * @param adapter Backend implementation providing raw string `get`/`set`/
- *                `remove`/`clear`. The Store layers JSON encoding and
- *                timestamp serialisation on top.
- * @returns A {@link Store} bound to `adapter`. Reads return {@link Stored}
- *          envelopes; writes accept Stored envelopes and return `true`
- *          when the entry landed in the adapter.
- *
- * @example
- * ```ts
- * const store = utils.store({
- *   get: (key) => localStorage.getItem(key),
- *   set: (key, value) => localStorage.setItem(key, value),
- *   remove: (key) => localStorage.removeItem(key),
- *   clear: () => localStorage.clear(),
- * });
- *
- * // Read into a Resource fallback chain.
- * { cat: get.cat.else(store.get(Snapshots.Cat)).else(null) }
- *
- * // Write the latest cached value back to storage.
- * store.set(Snapshots.Cat, get.cat.snapshot());
- *
- * // Drop a snapshot on sign-out, cache invalidation, etc.
- * store.remove(Snapshots.Cat);
- *
- * // Or wipe the whole backing store (scope is the adapter's call).
- * store.clear();
- * ```
- */
-export declare function store(adapter: Adapter): Store;
 /** 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;
-/** Shorthand alias for {@link store}. */
-export declare const σ: typeof store;

package/dist/utils/types.d.ts

@@ -0,0 +1,18 @@
+import { unset } from './utils';
+/** 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}/utils.d.ts

@@ -1,4 +1,4 @@
-import { Stored } from './types.ts';
+import { Stored } from './types';
 /**
  * Sentinel symbol marking "no value present yet". Shared by the Resource
  * cache and by storage handles so callers can distinguish "nothing has been

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-hare",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "type": "module",
   "license": "MIT",
   "packageManager": "yarn@1.22.22",
@@ -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>;

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

@@ -1,20 +0,0 @@
-import { Props } from './types.ts';
-import * as React from "react";
-/**
- * Creates a unified context boundary for all March Hare features.
- * Wraps children with Broadcaster, Mode, and Tasks providers.
- *
- * Use this at the root of your application or to create isolated context boundaries
- * for libraries that need their own March Hare context.
- *
- * @param props.children - The children to render within the boundary.
- * @returns The children wrapped in all required context providers.
- *
- * @example
- * ```tsx
- * <Boundary>
- *   <App />
- * </Boundary>
- * ```
- */
-export declare function Boundary({ children }: Props): React.ReactNode;

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

@@ -1,4 +0,0 @@
-import type * as React from "react";
-export type Props = {
-    children: React.ReactNode;
-};

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

@@ -1,17 +0,0 @@
-export { Action } from './action/index.ts';
-export { Distribution, Lifecycle } from './types/index.ts';
-export { Reason, AbortError, TimeoutError } from './error/index.ts';
-export { Operation, Op, State } from 'immertation';
-export { annotate } from './annotate/index.ts';
-export { Boundary } from './boundary/index.tsx';
-export { withScope } from './boundary/components/scope/index.tsx';
-export { useMode } from './boundary/components/mode/index.tsx';
-export type { ModeHandle } from './boundary/components/mode/index.tsx';
-export { useActions, With } from './hooks/index.ts';
-export { Resource, useResource } from './resource/index.ts';
-export type { ResourceHandle, ResourceFetcher, BoundResourceHandle, IfOptions, } from './resource/index.ts';
-export * as utils from './utils/index.ts';
-export type { Stored, Unset, Adapter, Store } from './utils/index.ts';
-export type { Box } from 'immertation';
-export type { Fault } from './error/index.ts';
-export type { Pk, Task, Tasks, Handlers } from './types/index.ts';

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

@@ -1,65 +0,0 @@
-import { ResourceFetcher, ResourceHandle, BoundResourceHandle } from './types.ts';
-export type { IfOptions, ResourceFetcher, ResourceHandle, BoundResourceHandle, } from './types.ts';
-/**
- * Defines a remote resource — declared at module scope and
- * consumed via {@link useResource}.
- *
- * The fetcher receives the optional `AbortSignal` first and the
- * `params` object second (defaults to `{}`). Resources do **not**
- * carry any callbacks – side-effects (broadcasting, logging,
- * model updates) belong in the `useAction` handler that called
- * `await handle(...)`.
- *
- * Every call fires its own request. The most recent successful
- * payload is cached in a module-level `WeakMap` keyed by the fetcher,
- * so `.if(...)` and `.else(...)` on the bound handle behave
- * consistently across all components that share the same Resource.
- *
- * @example
- * ```ts
- * import { Resource } from "march-hare";
- *
- * // `T` is inferred from the fetcher's return type.
- * export const user = Resource((signal) =>
- *   ky.get("user", { signal }).json<User>(),
- * );
- *
- * // Annotate `params` when destructuring so `P` is inferred.
- * export const updateUser = Resource(
- *   (signal, { id, body }: { id: number; body: { name: string } }) =>
- *     ky.patch(`users/${id}`, { json: body, signal }).json<User>(),
- * );
- * ```
- */
-export declare function Resource<T, P extends object = Record<never, never>>(fetcher: ResourceFetcher<T, P>): ResourceHandle<T, P>;
-/**
- * Binds a module-scope {@link ResourceHandle} to the component, returning
- * the fetch callable with `.if`, `.else`, `.snapshot`, `.data`, and `.at`
- * attached. The hook is standalone &ndash; call it *before* `useActions`
- * when you want to seed the initial model from the cache via
- * `.else(fallback)`.
- *
- * Pass `context.task.controller.signal` as the first argument to thread
- * cancellation from the surrounding action handler through to the
- * fetcher. For parameterised resources, pass `null` as the first arg
- * when you have params but no signal.
- *
- * @example
- * ```ts
- * const cat = useResource(resources.cat);
- * const actions = useActions<Model, typeof Actions, Data>(
- *   { cat: cat.else(store.get(Snapshots.Cat)).else(null) },
- *   () => ({ index, router }),
- * );
- *
- * actions.useAction(Actions.Mount, async (context) => {
- *   const fresh = await cat.if(
- *     { over: { minutes: 5 } },
- *     context.task.controller.signal,
- *   );
- *   store.set(Snapshots.Cat, cat.snapshot());
- *   context.actions.produce(({ model }) => void (model.cat = fresh));
- * });
- * ```
- */
-export declare function useResource<T, P extends object>(resource: ResourceHandle<T, P>): BoundResourceHandle<T, P>;