march-hare 0.6.1 → 0.7.0

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

@@ -1,150 +1,27 @@
-import { Stored, Unset } from '../utils/index.ts';
-export type { Unset } from '../utils/index.ts';
+import { Store } from '../boundary/components/store/index.tsx';
 /**
- * Options accepted by `.if(...)` on a bound resource handle.
+ * Args object passed to every {@link Fetcher}. The fetcher destructures
+ * whatever it needs; unused fields can be omitted.
  *
- * - `over` – a `Temporal.Duration`, a `DurationLike` object
- *   (e.g. `{ minutes: 5 }`), or an ISO 8601 duration string (`"PT5M"`).
- *   If the most recent successful run resolved longer ago than this
- *   window, the underlying fetcher is called. Otherwise the cached
- *   data is returned without hitting the network.
+ * - `store` &mdash; snapshot of the per-`<Boundary>` Store at the
+ *   moment the fetcher is invoked.
+ * - `controller` &mdash; the `AbortController` auto-threaded from the
+ *   calling handler's `context.task.controller`. Pass
+ *   `controller.signal` to `fetch`/`ky`/`EventSource`, or call
+ *   `controller.abort()` to fail fast.
+ * - `params` &mdash; the call-site params object. Defaults to `{}`.
  *
- * @example
- * ```ts
- * await user.if({ over: { minutes: 5 } });
- * await user.if({ over: "PT5M" });
- * await user.if({ over: Temporal.Duration.from({ minutes: 5 }) });
- * ```
+ * @internal
  */
-export type IfOptions = {
-    readonly over: Temporal.DurationLike;
+export type Args<P extends object = Record<never, never>> = {
+    readonly store: Store;
+    readonly controller: AbortController;
+    readonly params: P;
 };
 /**
- * Fetcher signature accepted by `Resource`. Receives the optional
- * `AbortSignal` first (threaded from the action handler's
- * `context.task.controller.signal`) and the call-site `params` second.
- * Side-effects (dispatching broadcasts, analytics, etc.) belong in the
- * calling `useAction` handler, not inside the fetcher.
+ * Fetcher signature accepted by `Resource`. Receives the args object
+ * `{ store, controller, params }`. Side-effects (dispatching broadcasts,
+ * analytics, etc.) belong in the calling `useAction` handler, not
+ * inside the fetcher.
  */
-export type ResourceFetcher<T, P extends object = Record<never, never>> = (signal: AbortSignal | undefined, params: P) => Promise<T>;
-/**
- * Module-scope handle returned by `Resource`. Pass to `useResource` to
- * obtain the bound, component-scoped callable.
- *
- * Every call to the underlying fetcher fires its own request. The most
- * recent successful response is cached in a module-level `WeakMap`
- * keyed by the fetcher itself, so `.if(...)` and `.else(...)` on the
- * bound handle have something to read from.
- */
-export type ResourceHandle<T, P extends object = Record<never, never>> = {
-    /** @internal */
-    readonly run: (signal: AbortSignal | undefined, params: P) => Promise<T>;
-    /**
-     * Most recent successfully-resolved payload, or the shared `unset`
-     * sentinel if no successful run has happened yet.
-     * @internal
-     */
-    readonly data: T | Unset;
-    /** @internal */
-    readonly at: Temporal.Instant | null;
-    /**
-     * Populates the cache slot with `data` and `at` without invoking the
-     * fetcher. Used by the bound handle's `.else(stored)` overload to
-     * hydrate the cache from a {@link Stored} fallback (typically the
-     * return value of `Store.get(key)` after a page reload).
-     * @internal
-     */
-    readonly seed: (data: T, at: Temporal.Instant) => void;
-};
-/**
- * Component-bound handle returned by `useResource`. The handle is itself
- * the fetch callable &mdash; `await user(signal?, params?)` triggers a
- * request &mdash; with attached read accessors and methods:
- *
- * - `.if({ over }, signal?, params?)` &mdash; fetch only if the cached
- *   payload is older than the supplied freshness window; otherwise
- *   return the cached payload synchronously.
- * - `.else(fallback)` &mdash; synchronous read of the cached payload,
- *   falling back to the supplied default when nothing has resolved
- *   successfully yet. Accepts either a value (terminal, returns
- *   `T | U`) or a {@link Stored} (chainable, seeds the cache from the
- *   Stored's data/at when the cache is empty and returns the same bound
- *   handle for further chaining).
- * - `.snapshot()` &mdash; returns a {@link Stored} wrapping the current
- *   cache state, symmetric with `Store.get(key)`. Pass straight to
- *   `Store.set(key, ...)` to persist the latest successful payload.
- * - `.data` and `.at` &mdash; the underlying cache fields. Reading
- *   `.snapshot()` is usually clearer.
- *
- * Call signature: `(signal?)` for resources with no params, or
- * `(signal: AbortSignal | null, params: P)` for parameterised
- * resources &mdash; pass `null` as the first argument when you have
- * params but no signal to thread.
- */
-export type BoundResourceHandle<T, P extends object> = [keyof P] extends [never] ? {
-    (signal?: AbortSignal): Promise<T>;
-    /**
-     * Calls the underlying fetcher if the most recent successful run
-     * resolved longer ago than `options.over`. Otherwise returns the
-     * cached data without hitting the network.
-     */
-    readonly if: (options: IfOptions, signal?: AbortSignal) => Promise<T>;
-    /**
-     * Overloaded fallback accessor.
-     *
-     * - `(fallback: U)` terminal &mdash; returns the cached payload, or
-     *   `fallback` when nothing has resolved yet. Cached `null` values
-     *   are returned verbatim.
-     * - `(stored: Stored<T>)` chainable &mdash; if the cache is empty
-     *   and the Stored carries data and a timestamp, seeds the cache
-     *   from it before returning the same bound handle so further
-     *   `.else(...)` calls compose. Used to hydrate the cache on first
-     *   render after a page reload, allowing `.if({ over })` to
-     *   short-circuit on the persisted timestamp.
-     */
-    readonly else: {
-        (stored: Stored<T>): BoundResourceHandle<T, P>;
-        <U>(fallback: U): T | U;
-    };
-    /**
-     * Snapshot of the current cache state in the shared {@link Stored}
-     * shape. Empty (`data === unset`, `at === null`) until a fetcher
-     * resolves; otherwise carries the most recent payload and the
-     * instant it resolved. Pass directly to `Store.set(key, ...)`.
-     */
-    readonly snapshot: () => Stored<T>;
-    /** Direct read of the cache payload. Prefer `.snapshot()`. */
-    readonly data: T | Unset;
-    /** Instant the cache was last populated, or `null` if empty. */
-    readonly at: Temporal.Instant | null;
-} : {
-    (signal: AbortSignal | null, params: P): Promise<T>;
-    /**
-     * Calls the underlying fetcher if the most recent successful run
-     * resolved longer ago than `options.over`. Otherwise returns the
-     * cached data without hitting the network.
-     */
-    readonly if: (options: IfOptions, signal: AbortSignal | null, params: P) => Promise<T>;
-    /**
-     * Overloaded fallback accessor.
-     *
-     * - `(fallback: U)` terminal &mdash; returns the cached payload, or
-     *   `fallback` when nothing has resolved yet.
-     * - `(stored: Stored<T>)` chainable &mdash; if the cache is empty
-     *   and the Stored carries data and a timestamp, seeds the cache
-     *   from it before returning the same bound handle.
-     */
-    readonly else: {
-        (stored: Stored<T>): BoundResourceHandle<T, P>;
-        <U>(fallback: U): T | U;
-    };
-    /**
-     * Snapshot of the current cache state in the shared {@link Stored}
-     * shape. Pass directly to `Store.set(key, ...)`.
-     */
-    readonly snapshot: () => Stored<T>;
-    /** Direct read of the cache payload. Prefer `.snapshot()`. */
-    readonly data: T | Unset;
-    /** Instant the cache was last populated, or `null` if empty. */
-    readonly at: Temporal.Instant | null;
-};
+export type Fetcher<T, P extends object = Record<never, never>> = (args: Args<P>) => Promise<T>;

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

@@ -1,20 +1,34 @@
+import { Cache } from '../cache/index.ts';
 import { unset } from '../utils/index.ts';
+export { Cache } from '../cache/index.ts';
 /**
- * Module-level cache shared by every `Resource` declaration. Keyed by
- * the fetcher function itself so each module-scope declaration gets a
- * distinct slot — entries are garbage-collected when the fetcher
- * reference is dropped.
+ * 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 cache: WeakMap<object, {
-    data: unknown;
-    at: Temporal.Instant;
-}>;
+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"}.
- * Kept under `config` for back-compatibility with existing imports in this
- * module's siblings; new code should import `unset` directly from `utils`.
  *
  * @internal
  */

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,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/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';
+export type { Stored, Unset } from './types.ts';
 /**
  * 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/src/library/utils/types.d.ts

@@ -1,25 +1,10 @@
 import { unset } from './utils.ts';
 /** Nominal type of the {@link unset} sentinel. */
 export type Unset = typeof unset;
-/**
- * On-disk JSON shape of a {@link Stored} envelope. The Store wrapper
- * encodes a populated Stored as `{ data, at: at.toString() }` so the
- * `Temporal.Instant` survives the string round-trip, and decodes via
- * `Temporal.Instant.from(...)` on read. Adapters never see this shape
- * directly — they shuttle the already-stringified JSON.
- *
- * @template T The payload type carried by the matching {@link Stored}.
- */
-export type Encoded<T> = {
-    readonly data: T;
-    readonly at: string;
-};
 /**
  * Common shape for a possibly-present value with a timestamp. Produced by
- * `BoundResourceHandle.snapshot()` (from the in-memory cache) and by
- * `Store.get(key)` (from persistent storage). Both feed into the bound
- * handle's overloaded `.else(...)`, which seeds the cache when given a
- * Stored that carries data and a timestamp.
+ * `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.
  */
@@ -28,74 +13,6 @@ export type Stored<T> = {
     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.
-     * Symmetric with `BoundResourceHandle.else(...)`'s terminal form.
-     */
+    /** Returns {@link data} when present, otherwise the supplied fallback. */
     readonly else: <U>(fallback: U) => T | U;
 };
-/**
- * Adapter contract for synchronous key/value storage. Implement once per
- * backend (localStorage, MMKV on React Native, chrome.storage with a sync
- * facade, etc.) and pass to `store`. The adapter shuttles raw strings;
- * JSON encoding and `Temporal.Instant` round-tripping happen inside the
- * Store wrapper, so adapters stay trivial.
- */
-export type Adapter = {
-    /**
-     * Return the raw string stored under `key`, or `null` when no entry
-     * exists. The Store wrapper handles JSON parsing and `Temporal.Instant`
-     * round-tripping, so this stays a plain string getter. Treat any
-     * read-time error (decryption, IPC, etc.) as "not found" and return
-     * `null` — the Store falls through to its next fallback rather than
-     * crashing the render.
-     */
-    readonly get: (key: string) => string | null;
-    /**
-     * Persist the raw string `value` under `key`. The Store guarantees
-     * `value` is a JSON-encoded `{ data, at }` envelope produced by a
-     * resolved snapshot — never a placeholder. Throwing is fine on quota,
-     * private mode, sandboxed iframes, etc.; the Store catches and
-     * swallows so a write failure can't poison an already-resolved fetch.
-     */
-    readonly set: (key: string, value: string) => void;
-    /**
-     * Drop the entry at `key`. Idempotent — calling `remove` for a key
-     * that isn't present must not throw.
-     */
-    readonly remove: (key: string) => void;
-    /**
-     * Wipe every entry this adapter can see. On a shared backend such as
-     * `localStorage` this means the whole origin — third-party SDK state,
-     * dismissed banners, route hints, etc. all go with it. Adapter authors
-     * should either delegate to the backend's native clear (accepting that
-     * scope) or namespace by key prefix and remove only their own.
-     */
-    readonly clear: () => void;
-};
-/**
- * Bound storage instance returned by `store`. Reads return a
- * {@link Stored} handle so the result composes with the Resource bound
- * handle's `.else(...)`; writes accept a Stored and short-circuit on the
- * empty case to avoid persisting placeholder snapshots.
- */
-export type Store = Pick<Adapter, "remove" | "clear"> & {
-    /**
-     * Read the entry at `key` as a {@link Stored} envelope. Returns an
-     * empty Stored (`data: unset`, `at: null`) when nothing is recorded
-     * or when the persisted payload fails to parse — corrupted entries
-     * never reach the caller. The result composes directly with a
-     * Resource bound handle's `.else(...)` for seeding the cache after
-     * a reload.
-     */
-    readonly get: <T>(key: string) => Stored<T>;
-    /**
-     * Persist `value` under `key`. Returns `true` when the entry landed
-     * in the adapter, `false` otherwise. A `false` covers two distinct
-     * cases: the Stored had no payload yet (`data === unset` or
-     * `at === null`), or the adapter threw (quota, private mode, etc.).
-     * Callers that care about quota failures should branch on the
-     * return; callers writing on every dispatch can safely ignore it.
-     */
-    readonly set: <T>(key: string, value: Stored<T>) => boolean;
-};