march-hare 0.6.1 → 0.7.1

package/README.md

@@ -76,27 +76,26 @@ export default function Profile(): React.ReactElement {
 }
 ```
 
-When you need to do more than just assign the payload – such as making an API request – expand `useAction` to a full function. It can be synchronous, asynchronous, or even a generator. Remote data goes through `Resource` rather than a bare `fetch` – declare the resource at module scope and consume it via `useResource`:
+When you need to do more than just assign the payload – such as making an API request – expand `useAction` to a full function. It can be synchronous, asynchronous, or even a generator. Remote data goes through `Resource` rather than a bare `fetch` – declare the resource at module scope, fetch from handlers via `context.actions.resource(...)`:
 
 ```ts
 // resources.ts
 import { Resource } from "march-hare";
 
-export const user = Resource(() => ky.get(api.user()).json<User>());
+export const user = Resource(({ controller }) =>
+  ky.get(api.user(), { signal: controller.signal }).json<User>(),
+);
 ```
 
 ```tsx
-const get = {
-  user: useResource(resource.user),
-};
-
 actions.useAction(Actions.Name, async (context) => {
   context.actions.produce(
     ({ model }) =>
       void (model.name = context.actions.annotate(model.name, Op.Update)),
   );
 
-  const data = await get.user();
+  // Auto-threads context.task.controller and the Store snapshot.
+  const data = await context.actions.resource(user());
 
   context.actions.produce(({ model }) => void (model.name = data.name));
 });
@@ -109,17 +108,17 @@ If you need to access external reactive values (like props or `useState` from pa
 ```tsx
 const actions = useActions<Model, typeof Actions, { query: string }>(
   model,
-  () => ({ query: props.query }),
+  () => ({
+    query: props.query,
+  }),
 );
 
-const get = {
-  search: useResource(resource.search),
-};
-
 actions.useAction(Actions.Search, async (context) => {
-  await get.search({ query: context.data.query });
+  const results = await context.actions.resource(
+    search({ query: context.data.query }),
+  );
   // context.data.query is always the latest value, even after await
-  console.log(context.data.query);
+  console.log(context.data.query, results);
 });
 ```
 
@@ -177,17 +176,13 @@ class Actions {
 ```
 
 ```tsx
-const get = {
-  user: useResource(resource.user),
-};
-
 actions.useAction(Actions.Profile, async (context) => {
   context.actions.produce(
     ({ model }) =>
       void (model.name = context.actions.annotate(model.name, Op.Update)),
   );
 
-  const data = await get.user();
+  const data = await context.actions.resource(user());
 
   context.actions.produce(({ model }) => void (model.name = data.name));
 
@@ -198,12 +193,8 @@ actions.useAction(Actions.Profile, async (context) => {
 Once we have the broadcast action, if we want to listen for it and perform another operation in our local component we can do that via `useAction`:
 
 ```tsx
-const get = {
-  friends: useResource(resource.friends),
-};
-
 actions.useAction(Actions.Broadcast.Name, async (context, name) => {
-  const data = await get.friends({ name });
+  const data = await context.actions.resource(friends({ name }));
 
   context.actions.produce(({ model }) => void (model.friends = data));
 });
@@ -212,14 +203,10 @@ actions.useAction(Actions.Broadcast.Name, async (context, name) => {
 Both `read` and `peek` access the latest cached broadcast value without subscribing via `useAction`. The difference is that `read` waits for any pending annotations on the corresponding model field to settle before resolving, whereas `peek` returns the value immediately:
 
 ```tsx
-const get = {
-  friends: useResource(resource.friends),
-};
-
 actions.useAction(Actions.FetchFriends, async (context) => {
   const name = await context.actions.resolution(Actions.Broadcast.Name);
   if (!name) return;
-  const data = await get.friends({ name });
+  const data = await context.actions.resource(friends({ name }));
   context.actions.produce(({ model }) => void (model.friends = data));
 });
 ```
@@ -268,52 +255,42 @@ Components that mount after a broadcast has already been dispatched automaticall
 
 <a id="remote-data"></a>
 
-For remote data, declare a `Resource` at module scope and consume it via `useResource`. Every call fires its own request; the most recent successful response is cached in a module-level `WeakMap` keyed by the fetcher so `.if(...)` and `.else(...)` on the bound handle have something to read from. Convention is to keep all resources in `resources.ts` and import them as a namespace:
+For remote data, declare a `Resource` at module scope and use it directly. `user(params)` is the unified call form &mdash; it returns the sync cache read (`User | null`) and primes a slot that `context.actions.resource(user(params))` consumes for the fetch path (with auto-threaded abort controller and Store snapshot). Every successful fetch caches the response in a module-level slot keyed by the fetcher and the stringified params, so different param-sets are independent. Keep all resources in `resources.ts` and pull them in with named imports:
 
 ```ts
 // resources.ts
 import { Resource } from "march-hare";
 
-export const user = Resource(() => ky.get("/api/user").json<User>());
+export const user = Resource(({ controller }) =>
+  ky.get("/api/user", { signal: controller.signal }).json<User>(),
+);
 
-export const pay = Resource((signal, body: Body) =>
-  ky.post("/api/pay", { json: body, signal }).json<Receipt>(),
+export const pay = Resource<Receipt, Body>(({ controller, params }) =>
+  ky
+    .post("/api/pay", { json: params, signal: controller.signal })
+    .json<Receipt>(),
 );
 ```
 
 ```tsx
 // actions.ts
-import { useActions, useResource } from "march-hare";
-import * as resource from "./resources";
+import { useActions } from "march-hare";
+import { user, pay } from "./resources";
 
 export function useActions() {
-  // Bind the resources first so we can seed the initial model from the
-  // cache via `.else(fallback)` — if a previous mount populated the
-  // slot, the model starts with that value; otherwise the fallback.
-  // Bindings are grouped by HTTP verb so call sites advertise read vs.
-  // write at a glance.
-  const get = {
-    user: useResource(resource.user),
-  };
-  const post = {
-    pay: useResource(resource.pay),
-  };
-
   const actions = useActions<Model, typeof Actions>({
-    user: get.user.else(null),
-    receipt: post.pay.else(null),
+    // Sync cache read at the model literal — returns null when nothing is cached.
+    user: user(),
+    receipt: null,
   });
 
   actions.useAction(Actions.Mount, async (context) => {
-    const data = await get.user.if(
-      { over: { minutes: 5 } },
-      context.task.controller.signal,
-    );
+    const data = await context.actions.resource(user()).exceeds({ minutes: 5 });
     context.actions.produce(({ model }) => void (model.user = data));
   });
 
   actions.useAction(Actions.Submit, async (context, body) => {
-    const receipt = await post.pay(context.task.controller.signal, body);
+    const receipt = await context.actions.resource(pay(body));
     context.actions.produce(({ model }) => void (model.receipt = receipt));
   });
 
@@ -321,15 +298,17 @@ export function useActions() {
 }
 ```
 
-`useResource(handle)` returns the fetch callable directly. The callable has two attached methods: `.if({ over })` skips the network when the cached payload is still fresh, and `.else(fallback)` reads the cached payload synchronously with a default. `Temporal` is read from the host runtime &ndash; bring a polyfill (e.g. [`@js-temporal/polyfill`](https://github.com/js-temporal/temporal-polyfill)) if your target environment does not yet expose it natively. `.if({ over })` accepts a `Temporal.Duration`, a `DurationLike` object, or an ISO 8601 duration string.
+`context.actions.resource(invocation)` returns a thenable. Awaiting it fires the fetch unconditionally; chaining `.exceeds({ minutes: 5 })` short-circuits when the per-params cache age does not yet exceed the supplied freshness window. `.exceeds(duration)` accepts a `Temporal.Duration`, a `DurationLike` object, or an ISO 8601 duration string. `Temporal` is read from the host runtime &ndash; bring a polyfill (e.g. [`@js-temporal/polyfill`](https://github.com/js-temporal/temporal-polyfill)) if your target environment does not yet expose it natively.
 
-`Resource` takes a single fetcher argument. The fetcher receives the call-site `params` object as its only argument and returns a `Promise<T>`. There are no callbacks &ndash; no `onSuccess`, no `onError`, no injected `dispatch`. Side-effects after a run (broadcasting, analytics, model writes) live in the `useAction` handler that awaited the call, next to the rest of the flow:
+`Resource` takes a single fetcher argument. The fetcher receives `{ store, controller, params }` &mdash; destructure whichever you need. There are no callbacks &ndash; no `onSuccess`, no `onError`, no injected `dispatch`. Side-effects after a run (broadcasting, analytics, model writes) live in the `useAction` handler that awaited the call, next to the rest of the flow:
 
 ```ts
-export const user = Resource(() => ky.get("/api/user").json<User>());
+export const user = Resource(({ controller }) =>
+  ky.get("/api/user", { signal: controller.signal }).json<User>(),
+);
 
 actions.useAction(Actions.Mount, async (context) => {
-  const data = await get.user();
+  const data = await context.actions.resource(user());
   await context.actions.dispatch(Actions.Broadcast.UserUpdated, data);
   context.actions.produce(({ model }) => void (model.user = data));
 });
@@ -340,16 +319,18 @@ actions.useAction(Actions.Mount, async (context) => {
 ```ts
 type Params = { cursor: string | null };
 
-export const feed = Resource((signal, { cursor }: Params) =>
+export const feed = Resource<Page<Item>, Params>(({ controller, params }) =>
   http
-    .get("feed", { searchParams: { cursor: cursor ?? "" }, signal })
+    .get("feed", {
+      searchParams: { cursor: params.cursor ?? "" },
+      signal: controller.signal,
+    })
     .json<Page<Item>>(),
 );
 
-const get = {
-  feed: useResource(resource.feed),
-};
-const page = await get.feed({ cursor: context.model.cursor });
+const page = await context.actions.resource(
+  feed({ cursor: context.model.cursor }),
+);
 ```
 
 A complete IntersectionObserver-driven infinite-scroll demo lives at [`src/example/transactions/`](./src/example/transactions/) &ndash; mock paginated API, scroll-triggered `LoadMore`, `pending()` guard, broadcast on success.
@@ -359,7 +340,7 @@ For typed failure routing, wrap the call in `try/catch` and use `instanceof` &nd
 ```ts
 actions.useAction(Actions.Mount, async (context) => {
   try {
-    const data = await get.user();
+    const data = await context.actions.resource(user());
     context.actions.produce(({ model }) => void (model.user = data));
   } catch (error) {
     if (error instanceof RateLimitedError) {
@@ -377,38 +358,42 @@ See the [Resource recipe](./recipes/use-resource.md) for the three-tier error ha
 
 ### Persisting resources across reloads
 
-`useResource`'s cache lives in a `WeakMap` that's reset on every page load. To keep the most recent successful payload around between sessions, pair it with `utils.store(...)` &ndash; a synchronous key/value wrapper around any backing store (`localStorage` on web, `MMKV` on React Native, etc.) that traffics in the same `Stored<T>` shape as the Resource cache.
+By default a `Resource`'s cache is in-memory only &ndash; it resets on every page load. To keep the most recent successful payload around between sessions, wire a `Cache` instance to the `Resource` definition. The Cache writes through to its adapter on every successful run and seeds the per-params slot from storage on first read, so call sites stay free of explicit `store.set` / `store.get` ceremony.
 
 ```ts
-import { utils } from "march-hare";
+// resources.ts
+import { Cache, Resource } from "march-hare";
 
-export const store = utils.store({
+const cache = Cache({
   get: (key) => localStorage.getItem(key),
   set: (key, value) => localStorage.setItem(key, value),
   remove: (key) => localStorage.removeItem(key),
+  clear: () => localStorage.clear(),
 });
-```
 
-`get.cat.else(...)` is overloaded: pass a `Stored<T>` (from `store.get(key)`) and the bound handle seeds its own cache from it when empty &ndash; then chain `.else(null)` for the leaf fallback. `get.cat.snapshot()` produces the symmetric `Stored<T>` for writing back. After this single chain, `.if({ over })` short-circuits on the persisted timestamp on the _first_ mount after a reload, with no second method to call.
+export const cat = Resource(
+  async ({ controller }) => fetchCat(controller.signal),
+  cache,
+);
+```
 
 ```ts
-const get = { cat: useResource(resource.cat) };
+// actions.ts
 const actions = useActions<Model, typeof Actions>({
-  // First render reads cache → storage → null.
-  cat: get.cat.else(store.get(Snapshots.Cat)).else(null),
+  // First render reads the Cache automatically.
+  cat: cat(),
 });
 
 actions.useAction(Actions.Mount, async (context) => {
-  // Short-circuits when storage held a payload < 5 minutes old.
-  const fresh = await get.cat.if(
-    { over: { minutes: 5 } },
-    context.task.controller.signal,
-  );
-  store.set(Snapshots.Cat, get.cat.snapshot());
+  // Short-circuits when the persisted payload is < 5 minutes old.
+  // The Cache writes through automatically on success.
+  const fresh = await context.actions.resource(cat()).exceeds({ minutes: 5 });
   context.actions.produce(({ model }) => void (model.cat = fresh));
 });
 ```
 
+`Cache()` with no adapter is an in-memory scope &ndash; useful in tests or when you want a holdable cache without persistence. Per-params keying via `JSON.stringify(params)` is automatic, so `user({ id: 5 })` and `user({ id: 6 })` are distinct slots.
+
 See the [storage recipe](./recipes/storage.md) for backend adapters (React Native MMKV, browser extension `chrome.storage`), sign-out purge, and the `unset` sentinel that keeps "nothing stored" distinct from "a legitimately stored null".
 
 For targeted event delivery, use channeled actions. Define a channel type as the second generic argument and call the action with a channel object &ndash; handlers fire when the dispatch channel matches:
@@ -481,33 +466,41 @@ Unlike broadcast which reaches all mounted components, multicast is confined to
 
 See the [multicast recipe](./recipes/multicast-actions.md) for more details.
 
-For coordinating between async handlers without re-rendering the JSX tree, use the per-`<Boundary>` mode handle returned by `useMode()`. Thread it through the `useActions` data callback so it shows up as `context.data.mode` inside handlers, fully typed. Mode is **not** reactive &mdash; drive view state through the model, not mode.
+For coordinating between async handlers and threading ambient values (session tokens, locale, feature flags, current operational mode) without re-rendering the JSX tree, use the per-`<Boundary>` `Store`. Declare your app's Store shape once via module augmentation, supply the initial value to `<Boundary store={...}>`, read via dot notation (`store.session`, `context.store.locale`), and write via `context.actions.produce(({ store }) => { ... })` &mdash; the same Immer-style recipe used for the model. Every `Resource` fetcher also receives a snapshot of the Store on its args object. Store is **not** reactive &mdash; drive view state through the model.
 
 ```ts
-import { useActions, useMode } from "march-hare";
-
-enum Mode {
-  Idle,
-  SigningOut,
+import { useActions } from "march-hare";
+
+// Declare your Store's shape once. Every read/write is typed against this.
+declare module "march-hare" {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+  interface Store {
+    session: Session | null;
+    operating: "idle" | "signing-out";
+  }
 }
 
-export function useActions() {
-  const mode = useMode<Mode>();
-  // Spell the data shape as the third generic so `context.data.mode` keeps
-  // its concrete type inside handlers.
-  const actions = useActions<Model, typeof Actions, { mode: typeof mode }>(
-    model,
-    () => ({ mode }),
-  );
+// Wire the initial Store into Boundary at app root.
+<Boundary store={{ session: null, operating: "idle" }}>
+  <App />
+</Boundary>;
+
+export function useAuthActions() {
+  const actions = useActions<void, typeof Actions>();
 
   actions.useAction(Actions.SignOut, async (context) => {
-    context.data.mode.update(Mode.SigningOut);
+    context.actions.produce(({ store }) => {
+      store.operating = "signing-out";
+    });
     await api.signOut();
-    context.data.mode.update(Mode.Idle);
+    context.actions.produce(({ store }) => {
+      store.session = null;
+      store.operating = "idle";
+    });
   });
 
   actions.useAction(Actions.Refresh, async (context) => {
-    if (context.data.mode.read() === Mode.SigningOut) return;
+    if (context.store.operating === "signing-out") return;
     // ...
   });
 

package/dist/{src/library/action → action}/index.d.ts

@@ -1,29 +1,33 @@
-import { HandlerPayload, BroadcastPayload, MulticastPayload, Distribution, Filter } from '../types/index.ts';
-export { getActionSymbol, getLifecycleType, isBroadcastAction, isMulticastAction, getName, isChanneledAction, } from './utils.ts';
+import { HandlerPayload, BroadcastPayload, MulticastPayload, Distribution, Filter } from '../types/index';
+export { getActionSymbol, getLifecycleType, isBroadcastAction, isMulticastAction, getName, isChanneledAction, } from './utils';
 /**
  * Interface for the Action factory function.
  */
 type ActionFactory = {
     /**
      * Creates a new unicast action with the given name.
+     *
+     * `K` is the literal type of the action name and is captured as a phantom
+     * brand so `Action("A")` and `Action("B")` produce structurally-distinct
+     * types. **Note:** when the caller supplies any explicit generic
+     * (`Action<P>("Name")`), TypeScript fills `K` from its default and the
+     * literal is lost. The Name brand still helps for `Action("Name")` calls
+     * (e.g. lifecycle / no-payload actions) which is the most common source of
+     * foreign-class collisions.
+     *
      * @template P The payload type for the action.
-     * @template C The channel type for channeled dispatches (defaults to never).
-     * @param name The action name, used for debugging purposes.
-     * @returns A typed action object.
+     * @template C The channel type for channeled dispatches.
+     * @template K The literal type of the action name (inferred when no other
+     *   generics are supplied; defaults to `string` otherwise).
      */
-    <P = never, C extends Filter = never>(name: string): HandlerPayload<P, C>;
+    <P = never, C extends Filter = never, K extends string = string>(name: K): HandlerPayload<P, C, K>;
     /**
      * Creates a new action with the specified distribution mode.
-     * @template P The payload type for the action.
-     * @template C The channel type for channeled dispatches (defaults to never).
-     * @param name The action name, used for debugging purposes.
-     * @param distribution The distribution mode (Unicast, Broadcast, or Multicast).
-     * @returns A typed action object (BroadcastPayload if Broadcast, MulticastPayload if Multicast).
      */
-    <P = never, C extends Filter = never>(name: string, distribution: Distribution.Broadcast): BroadcastPayload<P, C>;
-    <P = never, C extends Filter = never>(name: string, distribution: Distribution.Multicast): MulticastPayload<P, C>;
-    <P = never, C extends Filter = never>(name: string, distribution: Distribution.Unicast): HandlerPayload<P, C>;
-    <P = never, C extends Filter = never>(name: string, distribution: Distribution): HandlerPayload<P, C> | BroadcastPayload<P, C> | MulticastPayload<P, C>;
+    <P = never, C extends Filter = never, K extends string = string>(name: K, distribution: Distribution.Broadcast): BroadcastPayload<P, C, K>;
+    <P = never, C extends Filter = never, K extends string = string>(name: K, distribution: Distribution.Multicast): MulticastPayload<P, C, K>;
+    <P = never, C extends Filter = never, K extends string = string>(name: K, distribution: Distribution.Unicast): HandlerPayload<P, C, K>;
+    <P = never, C extends Filter = never, K extends string = string>(name: K, distribution: Distribution): HandlerPayload<P, C, K> | BroadcastPayload<P, C, K> | MulticastPayload<P, C, K>;
 };
 /**
  * Creates a new action with a given payload type, optional channel type, and optional distribution mode.

package/dist/{src/library/action → action}/utils.d.ts

@@ -1,5 +1,5 @@
-import { ChanneledAction, AnyAction } from '../types/index.ts';
-import { ActionId } from '../boundary/components/tasks/types.ts';
+import { ChanneledAction, AnyAction } from '../types/index';
+import { ActionId } from '../boundary/components/tasks/types';
 /**
  * Extracts the underlying symbol from an action or channeled action.
  * This symbol is used as the event emitter key for dispatching.

package/dist/{src/library/boundary → boundary}/components/broadcast/index.d.ts

@@ -1,6 +1,6 @@
-import { Props } from './types.ts';
+import { Props } from './types';
 import * as React from "react";
-export { useBroadcast, BroadcastEmitter } from './utils.ts';
+export { useBroadcast, BroadcastEmitter } from './utils';
 /**
  * Creates a new broadcast context for distributed actions. Only needed if you
  * want to isolate a broadcast context, useful for libraries that want to provide

package/dist/{src/library/boundary → boundary}/components/broadcast/types.d.ts

@@ -1,4 +1,4 @@
-import { BroadcastEmitter } from './utils.ts';
+import { BroadcastEmitter } from './utils';
 import * as React from "react";
 /**
  * The broadcast context is a BroadcastEmitter used for distributed actions across components.

package/dist/{src/library/boundary → boundary}/components/consumer/components/partition/index.d.ts

@@ -1,4 +1,4 @@
-import { Props } from './types.ts';
+import { Props } from './types';
 import * as React from "react";
 /**
  * Renders output for the `stream()` method by subscribing to distributed action events.

package/dist/{src/library/boundary → boundary}/components/consumer/components/partition/types.d.ts

@@ -1,4 +1,4 @@
-import { ConsumerRenderer } from '../../types.ts';
+import { ConsumerRenderer } from '../../types';
 /**
  * Props for the Partition component.
  * @internal

package/dist/{src/library/boundary → boundary}/components/consumer/index.d.ts

@@ -1,9 +1,9 @@
-import { Props } from './types.ts';
+import { Props } from './types';
 import * as React from "react";
-export { useConsumer } from './utils.ts';
-export { Partition } from './components/partition/index.tsx';
-export type { Props as PartitionProps } from './components/partition/types.ts';
-export type { ConsumerRenderer, Entry, ConsumerContext } from './types.ts';
+export { useConsumer } from './utils';
+export { Partition } from './components/partition/index';
+export type { Props as PartitionProps } from './components/partition/types';
+export type { ConsumerRenderer, Entry, ConsumerContext } from './types';
 /**
  * Creates a new consumer context for storing distributed action values. Only needed if you
  * want to isolate a consumer context, useful for libraries that want to provide

package/dist/{src/library/boundary → boundary}/components/consumer/types.d.ts

@@ -1,5 +1,5 @@
 import { Inspect, State } from 'immertation';
-import { ActionId } from '../tasks/types.ts';
+import { ActionId } from '../tasks/types';
 import * as React from "react";
 /**
  * Callback function for the stream() method.

package/dist/{src/library/boundary → boundary}/components/consumer/utils.d.ts

@@ -1,4 +1,4 @@
-import { ConsumerContext } from './types.ts';
+import { ConsumerContext } from './types';
 import * as React from "react";
 /**
  * React context for the consumer store.

package/dist/{src/library/boundary → boundary}/components/scope/index.d.ts

@@ -1,7 +1,7 @@
-import { MulticastPayload } from '../../../types/index.ts';
+import { MulticastPayload } from '../../../types/index';
 import { ComponentType, ReactNode } from 'react';
-export { useScope, getScope } from './utils.ts';
-export type { ScopeEntry, ScopeContext } from './types.ts';
+export { useScope, getScope } from './utils';
+export type { ScopeEntry, ScopeContext } from './types';
 /**
  * Higher-order component that opens a multicast scope keyed by the supplied
  * multicast action. Components rendered inside the wrapped tree (and any

package/dist/{src/library/boundary → boundary}/components/scope/types.d.ts

@@ -1,5 +1,5 @@
-import { BroadcastEmitter } from '../broadcast/utils.ts';
-import { ActionId } from '../tasks/types.ts';
+import { BroadcastEmitter } from '../broadcast/utils';
+import { ActionId } from '../tasks/types';
 /**
  * Represents a single scope in the ancestor chain. The scope key is the
  * action id of the multicast action that opens the scope; each multicast

package/dist/{src/library/boundary → boundary}/components/scope/utils.d.ts

@@ -1,5 +1,5 @@
-import { ScopeContext, ScopeEntry } from './types.ts';
-import { ActionId } from '../tasks/types.ts';
+import { ScopeContext, ScopeEntry } from './types';
+import { ActionId } from '../tasks/types';
 import * as React from "react";
 /**
  * React context for the scope chain.

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

@@ -0,0 +1,41 @@
+import { Props } from './types';
+import * as React from "react";
+export { useStore } from './utils';
+/**
+ * App-wide store of cross-cutting, mutable state. The interface is
+ * declared empty here and **augmented** by consumer code via module
+ * augmentation:
+ *
+ * @example
+ * ```ts
+ * declare module "march-hare" {
+ *   interface Store {
+ *     session: Session | null;
+ *     locale: string;
+ *     featureFlags: Record<string, boolean>;
+ *   }
+ * }
+ * ```
+ *
+ * Every key declared here flows into:
+ *
+ * - `useStore()` &mdash; the per-`<Boundary>` handle for reads and writes.
+ * - `context.store` inside `useActions` handlers.
+ * - The `store` field on every `Resource` fetcher's args object.
+ *
+ * The Store is **not** reactive. Mutating it does not re-render. Drive
+ * view state through the model; use the Store for cross-handler
+ * coordination, session tokens, locale, feature flags, etc.
+ */
+export interface Store {
+}
+/**
+ * Provides a per-Boundary {@link Store} value to every component inside
+ * the boundary. Usually wired in via the `<Boundary store={initial}>`
+ * prop rather than used directly.
+ *
+ * The Store is **not** reactive. Mutating it does not trigger a
+ * re-render. Drive view state through the model; use the Store for
+ * cross-handler coordination.
+ */
+export declare function Store({ initial, children }: Props): React.ReactNode;

package/dist/boundary/components/store/types.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { Store } from './index';
+export type { Store } from './index';
+/**
+ * Props for the Store provider component. Accepts the initial Store
+ * value that satisfies the augmented {@link Store} interface.
+ */
+export type Props = {
+    initial: Store;
+    children: ReactNode;
+};

package/dist/boundary/components/store/utils.d.ts

@@ -0,0 +1,64 @@
+import { RefObject } from 'react';
+import { Store } from './index';
+import * as React from "react";
+/**
+ * React context exposing the per-Boundary Store ref. The ref itself is
+ * stable across renders — readers grab `.current` at call time.
+ *
+ * @internal
+ */
+export declare const Context: React.Context<React.RefObject<Store>>;
+/**
+ * Hook that returns a read-only handle to the per-Boundary {@link Store}.
+ * Reads use plain dot notation (`store.session`) and always reflect the
+ * latest value, even after `await` boundaries &mdash; the handle is a
+ * `Proxy` that delegates property access to the live ref.
+ *
+ * Writes are not exposed here. Mutate the Store inside an action handler
+ * via `context.actions.produce(({ model, store }) => { store.x = ... })`
+ * &mdash; the same Immer-style recipe used for the model. Mutations do
+ * **not** trigger a re-render; drive view state through the model.
+ *
+ * The Store's shape is declared via module augmentation on the library's
+ * {@link Store} interface, so dot reads are fully typed at every call
+ * site.
+ *
+ * @example
+ * ```ts
+ * declare module "march-hare" {
+ *   interface Store {
+ *     session: Session | null;
+ *     locale: string;
+ *   }
+ * }
+ *
+ * function useAuthActions() {
+ *   const store = useStore();
+ *   const actions = useActions<void, typeof Actions>();
+ *
+ *   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 (store.session === null) return;
+ *     // ...
+ *   });
+ *
+ *   return actions;
+ * }
+ * ```
+ */
+export declare function useStore(): Store;
+/**
+ * Internal accessor for the per-Boundary Store ref &mdash; used by the
+ * Resource layer to pass a fresh snapshot to each fetcher invocation
+ * and by the action layer to write through `context.actions.produce`.
+ * Not exported from the library.
+ *
+ * @internal
+ */
+export declare function useStoreRef(): RefObject<Store>;

package/dist/{src/library/boundary → boundary}/components/tasks/index.d.ts

@@ -1,6 +1,6 @@
-import { Props } from './types.ts';
+import { Props } from './types';
 import * as React from "react";
-export type { Task } from './types.ts';
+export type { Task } from './types';
 /**
  * Creates a new tasks context for action control. Only needed if you
  * want to isolate a tasks context, useful for libraries that want to provide