march-hare 0.8.0 → 0.9.0

package/dist/resource/types.d.ts

@@ -1,27 +1,100 @@
-import { Store } from '../boundary/components/store/index';
+import { Env } from '../boundary/components/env/index';
+import { Cache } from '../cache/index';
+import { BroadcastPayload, MulticastPayload, Filter } from '../types/index';
 /**
- * Args object passed to every {@link Fetcher}. The fetcher destructures
- * whatever it needs; unused fields can be omitted.
+ * Dispatch surface exposed on a Resource fetcher's `context`. Restricted
+ * to broadcast and multicast actions — unicast targets the calling
+ * component, which a Resource fetcher does not have.
+ */
+export type Dispatch = {
+    <C extends Filter = never>(action: BroadcastPayload<never, C> | MulticastPayload<never, C>): Promise<void>;
+    <P, C extends Filter = never>(action: BroadcastPayload<P, C> | MulticastPayload<P, C>, payload: P): Promise<void>;
+};
+/**
+ * `context` object passed to every {@link Fetcher}.
  *
- * - `store` &mdash; snapshot of the per-`<Boundary>` Store at the
+ * - `env` &mdash; snapshot of the per-`<Boundary>` Env 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 `{}`.
+ * - `dispatch` &mdash; fire broadcast or multicast actions from inside
+ *   the fetcher. Unicast is rejected at compile time.
  *
  * @internal
  */
 export type Args<P extends object = Record<never, never>> = {
-    readonly store: Store;
+    readonly env: Env;
     readonly controller: AbortController;
     readonly params: P;
+    readonly dispatch: Dispatch;
 };
 /**
- * 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.
+ * Fetcher signature accepted by `Resource`. Receives a single `context`
+ * argument carrying the Env snapshot, the abort controller, params,
+ * and a broadcast/multicast-only `dispatch`.
+ */
+export type Fetcher<T, P extends object = Record<never, never>> = (context: Args<P>) => Promise<T>;
+/**
+ * Per-call coalescing token. Two callers with the same Resource, same
+ * structural params, and equal `Coalesce` value share a single in-flight
+ * promise; different tokens (or different params) fire independent
+ * fetches. Primitives compose naturally via stringification; objects
+ * are serialised with `JSON.stringify`.
+ */
+export type Coalesce = string | number | bigint | boolean | symbol | object;
+/**
+ * Config form accepted by `Resource`. The fetcher shorthand
+ * `Resource(fetcher)` is equivalent to `Resource({ fetch: fetcher })`.
+ *
+ * - `fetch` &mdash; the fetcher.
+ * - `cache` &mdash; persist successful payloads via a {@link Cache}
+ *   wired to an `Adapter` (localStorage, MMKV, etc). Omit for an
+ *   in-memory cache scoped to this Resource.
+ */
+export type Config<T, P extends object = Record<never, never>> = {
+    readonly fetch: Fetcher<T, P>;
+    readonly cache?: Cache;
+};
+/**
+ * Snapshot of the most recent resource invocation. `resource.cat(params)`
+ * writes one of these into a module-scope slot; the next
+ * `context.actions.resource(...)` / `.set(...)` call consumes it via
+ * `consumePending` and then clears the slot.
+ *
+ * @internal
+ */
+export type PendingCall = {
+    readonly run: (env: Env, controller: AbortController, params: object, dispatch: Dispatch) => Promise<unknown>;
+    readonly read: (params: object) => {
+        data: unknown;
+        at: Temporal.Instant | null;
+    };
+    readonly seed: (params: object, data: unknown, at: Temporal.Instant) => void;
+    readonly params: object;
+};
+/**
+ * Resource handle returned by `Resource(...)` or `Resource.Cachable(...)`.
+ * Call it with `params` to read the per-params cache slot synchronously
+ * and prime the slot consumed by `context.actions.resource(...)` for a
+ * follow-up fetch or `context.actions.resource.set(...)` for an
+ * out-of-band write.
+ *
+ * ```ts
+ * // Sync cache read in a model literal.
+ * { cat: resource.cat({ id: 5 }) }
+ *
+ * // Fetch with `.exceeds(...)` for cache-aware refresh.
+ * await context.actions
+ *   .resource(resource.cat({ id: 5 }))
+ *   .exceeds({ minutes: 5 });
+ *
+ * // Write through to the per-params cache slot.
+ * context.actions.resource.set(resource.cat({ id: 5 }), data);
+ * ```
  */
-export type Fetcher<T, P extends object = Record<never, never>> = (args: Args<P>) => Promise<T>;
+export type ResourceHandle<T, P extends object = Record<never, never>> = [
+    keyof P
+] extends [never] ? (params?: P) => T | null : (params: P) => T | null;

package/dist/scope/index.d.ts

@@ -0,0 +1,63 @@
+import { AppContextHandle, AppResource } from '../app/types';
+import { Actions, Model, Props } from '../types/index';
+import * as React from "react";
+/**
+ * Handle returned by `app.Scope<MulticastActions>()`. Mirrors the {@link App}
+ * surface (`Boundary`, `useContext`, `useEnv`, `Resource`) but typed
+ * against a specific multicast action surface `MulticastActions` and the
+ * enclosing App's Env shape `S`.
+ *
+ * Notably absent: a nested `Scope` method. Nesting scopes is supported
+ * at the React-tree level &mdash; just render two `<scope.Boundary>`s
+ * &mdash; but each scope must come from a distinct
+ * `app.Scope<MulticastActions>()` call so that its multicast surface is
+ * declared up-front.
+ *
+ * @template S The enclosing App's Env shape.
+ * @template MulticastActions The multicast Actions class (or union of
+ *  classes) this scope's `useContext().actions.dispatch` is allowed
+ *  to fire.
+ */
+export type Scope<S extends object, MulticastActions> = {
+    /**
+     * Boundary component. Wrap a subtree to open a fresh multicast scope
+     * &mdash; every `Distribution.Multicast` action dispatched inside this
+     * subtree routes through this boundary's emitter, and every handler
+     * subscribed via `scope.useContext().useActions(...)` on that subtree
+     * receives the event.
+     *
+     * Each render of `<scope.Boundary>` opens a distinct scope instance;
+     * unmounting tears the emitter down.
+     */
+    readonly Boundary: React.FC<{
+        children: React.ReactNode;
+    }>;
+    /**
+     * Hook returning a stable `Context` handle. Identical to
+     * `app.useContext` except `actions.dispatch` accepts the multicast
+     * surface `MulticastActions` in addition to the local `AC` &mdash; mirroring
+     * the way `Actions.Broadcast = BroadcastActions` already widens the
+     * dispatch surface for broadcasts.
+     */
+    readonly useContext: <LocalModel extends Model | void = void, AC extends Actions | void = void, D extends Props = Props>() => AppContextHandle<LocalModel, MulticastActions extends Actions ? AC extends Actions ? AC & MulticastActions : MulticastActions : AC, D, S>;
+    /**
+     * Read-only Proxy over the enclosing App's Env. Identical to
+     * `app.useEnv` &mdash; the Scope does not introduce its own Env;
+     * scopes are about multicast routing, not ambient state.
+     */
+    readonly useEnv: () => Readonly<S>;
+    /**
+     * Resource factory bound to the enclosing App's Env. Identical to
+     * `app.Resource`; provided on the scope handle for convenience so a
+     * scoped feature can keep all its primitives in one place.
+     */
+    readonly Resource: AppResource<S>;
+};
+/**
+ * Internal constructor for a {@link Scope} handle. Called from inside
+ * `App<S>()` so the enclosing Env shape `S` is captured at the type
+ * level.
+ *
+ * @internal
+ */
+export declare function createScope<S extends object, MulticastActions>(): Scope<S, MulticastActions>;

package/dist/scope/types.d.ts

@@ -0,0 +1,55 @@
+import { AppContextHandle, AppResource } from '../app/types';
+import { Actions, Model, Props } from '../types/index';
+import type * as React from "react";
+/**
+ * Handle returned by `app.Scope<MulticastActions>()`. Mirrors the
+ * `App` surface (`Boundary`, `useContext`, `useEnv`, `Resource`) but
+ * typed against a specific multicast action surface `MulticastActions`
+ * and the enclosing App's Env shape `S`.
+ *
+ * Notably absent: a nested `Scope` method. Nesting scopes is supported
+ * at the React-tree level &mdash; just render two `<scope.Boundary>`s
+ * &mdash; but each scope must come from a distinct
+ * `app.Scope<MulticastActions>()` call so that its multicast surface is
+ * declared up-front.
+ *
+ * @template S The enclosing App's Env shape.
+ * @template MulticastActions The multicast Actions class (or union of
+ *  classes) this scope's `useContext().actions.dispatch` is allowed
+ *  to fire.
+ */
+export type Scope<S extends object, MulticastActions> = {
+    /**
+     * Boundary component. Wrap a subtree to open a fresh multicast scope
+     * &mdash; every `Distribution.Multicast` action dispatched inside this
+     * subtree routes through this boundary's emitter, and every handler
+     * subscribed via `scope.useContext().useActions(...)` on that subtree
+     * receives the event.
+     *
+     * Each render of `<scope.Boundary>` opens a distinct scope instance;
+     * unmounting tears the emitter down.
+     */
+    readonly Boundary: React.FC<{
+        children: React.ReactNode;
+    }>;
+    /**
+     * Hook returning a stable `Context` handle. Identical to
+     * `app.useContext` except `actions.dispatch` accepts the multicast
+     * surface `MulticastActions` in addition to the local `AC` &mdash;
+     * mirroring the way `Actions.Broadcast = BroadcastActions` already
+     * widens the dispatch surface for broadcasts.
+     */
+    readonly useContext: <LocalModel extends Model | void = void, AC extends Actions | void = void, D extends Props = Props>() => AppContextHandle<LocalModel, MulticastActions extends Actions ? AC extends Actions ? AC & MulticastActions : MulticastActions : AC, D, S>;
+    /**
+     * Read-only Proxy over the enclosing App's Env. Identical to
+     * `app.useEnv` &mdash; the Scope does not introduce its own Env;
+     * scopes are about multicast routing, not ambient state.
+     */
+    readonly useEnv: () => Readonly<S>;
+    /**
+     * Resource factory bound to the enclosing App's Env. Identical to
+     * `app.Resource`; provided on the scope handle for convenience so a
+     * scoped feature can keep all its primitives in one place.
+     */
+    readonly Resource: AppResource<S>;
+};

package/dist/types/index.d.ts

@@ -1,8 +1,40 @@
 import { Operation, Process, Inspect, Box } from 'immertation';
 import { ActionId, Task, Tasks } from '../boundary/components/tasks/types';
 import { Fault } from '../error/types';
-import { Store } from '../boundary/components/store/index';
+import { Env } from '../boundary/components/env/index';
+import { Coalesce } from '../resource/types';
 import * as React from "react";
+/**
+ * Chainable handle returned from `context.actions.resource(invocation)`.
+ *
+ * - `.exceeds(duration)` short-circuits the fetch when the per-params
+ *   cache age is within the supplied freshness window.
+ * - `.coalesce(token)` opts the call into in-flight sharing: any other
+ *   caller with the same Resource, same structural params, and equal
+ *   `token` joins the same promise.
+ *
+ * Awaiting the handle (`await context.actions.resource(...)`) triggers
+ * the fetch with whichever options have been set on the chain.
+ */
+export type ResourceCall<T> = PromiseLike<T> & {
+    /**
+     * Skip the fetch when the cached payload is within `duration`.
+     * Accepts a `Temporal.Duration`, a `DurationLike` object
+     * (`{ minutes: 5 }`), or an ISO 8601 string (`"PT5M"`).
+     */
+    readonly exceeds: (duration: Temporal.DurationLike) => ResourceCall<T>;
+    /**
+     * Join an in-flight fetch for the same `(resource, params, token)`
+     * tuple. The shared fetch runs against a detached `AbortController`
+     * so a single caller's abort never cancels work other callers are
+     * waiting on; each caller still sees its own `context.task.controller`
+     * abort as a rejection of its personal await.
+     *
+     * `token` is optional &mdash; omit it to share with every other
+     * untokened caller for the same `(resource, params)` slot.
+     */
+    readonly coalesce: (token?: Coalesce) => ResourceCall<T>;
+};
 export type { ActionId, Box, Task, Tasks };
 /**
  * Type for objects with a Brand.Action symbol property.
@@ -34,7 +66,7 @@ export type BrandedObject = {
 };
 /**
  * Recursive readonly. Locks every nested property so that read-only
- * projections on `context` (model, data, store) reject direct assignment
+ * projections on `context` (model, data, env) reject direct assignment
  * &mdash; mutation must go through `context.actions.produce(...)`.
  *
  * Function types pass through untouched so method calls (e.g.
@@ -85,13 +117,13 @@ export declare class Brand {
  */
 export declare const FaultSymbol: unique symbol;
 /**
- * Internal symbol for the global `Lifecycle.Store` broadcast. The store
+ * Internal symbol for the global `Lifecycle.Env` broadcast. The env
  * mutation path in `useActions` fires this symbol whenever a
- * `produce({ store })` call changes the slot reference.
+ * `produce({ env })` call changes the slot reference.
  *
  * @internal
  */
-export declare const StoreSymbol: unique symbol;
+export declare const EnvSymbol: unique symbol;
 /**
  * Factory functions for lifecycle actions.
  *
@@ -111,10 +143,10 @@ export declare const StoreSymbol: unique symbol;
  * }
  * ```
  *
- * `Lifecycle.Fault` and `Lifecycle.Store` are singleton broadcasts (not
+ * `Lifecycle.Fault` and `Lifecycle.Env` are singleton broadcasts (not
  * factories). All components subscribe to the same shared symbol &mdash;
- * `Fault` delivers global fault notifications, `Store` delivers per-`Boundary`
- * store-change notifications.
+ * `Fault` delivers global fault notifications, `Env` delivers per-`Boundary`
+ * env-change notifications.
  */
 export declare class Lifecycle {
     /** Creates a Mount lifecycle action. Triggered once on component mount (`useLayoutEffect`). */
@@ -146,30 +178,30 @@ export declare class Lifecycle {
      */
     static Fault: BroadcastPayload<Fault, never, "Fault">;
     /**
-     * Global store-change broadcast. Receives the latest {@link Store}
-     * snapshot whenever a `context.actions.produce(({ store }) => ...)` call
+     * Global env-change broadcast. Receives the latest {@link Env}
+     * snapshot whenever a `context.actions.produce(({ env }) => ...)` call
      * mutates the slot. Subscribe via
-     * `actions.useAction(Lifecycle.Store, handler)` &mdash; or render against
-     * it directly with `actions.stream(Lifecycle.Store, (store) => ...)`.
+     * `actions.useAction(Lifecycle.Env, handler)` &mdash; or render against
+     * it directly with `actions.stream(Lifecycle.Env, (env) => ...)`.
      *
      * Like `Lifecycle.Fault`, this is a singleton broadcast (not a factory):
      * every subscriber points at the same shared symbol. The latest value is
      * cached on the broadcast emitter so that late-mounting handlers and
-     * streams receive the current store on mount.
+     * streams receive the current env on mount.
      *
      * @example
      * ```tsx
-     * actions.useAction(Lifecycle.Store, (context, store) => {
-     *   console.log("store changed", store);
+     * actions.useAction(Lifecycle.Env, (context, env) => {
+     *   console.log("env changed", env);
      * });
      *
      * // In JSX:
-     * {actions.stream(Lifecycle.Store, (store) => (
-     *   <span>{store.locale}</span>
+     * {actions.stream(Lifecycle.Env, (env) => (
+     *   <span>{env.locale}</span>
      * ))}
      * ```
      */
-    static Store: BroadcastPayload<Store, never, "Store">;
+    static Env: BroadcastPayload<Env, never, "Env">;
 }
 /**
  * Distribution modes for actions.
@@ -179,21 +211,29 @@ export declare class Lifecycle {
  * - **Broadcast** &ndash; Action is distributed to all mounted components that have
  *   defined a handler for it. Values are cached for late-mounting components.
  * - **Multicast** &ndash; Action defines its own scope. Components reach it by
- *   wrapping a subtree in `withScope(<theMulticastAction>, Component)`.
+ *   rendering inside a `<scope.Boundary>` produced by `app.Scope<MulticastActions>()`.
  *
  * @example
  * ```ts
- * export class Scope {
- *   // The action itself acts as the scope identifier.
+ * export class MulticastActions {
  *   static Mood = Action<Mood>("Mood", Distribution.Multicast);
  * }
  *
+ * export const scope = app.Scope<typeof MulticastActions>();
+ *
  * // Wrap the subtree where the scope applies.
- * export default withScope(Scope.Mood, Component);
+ * export default function Mood() {
+ *   return (
+ *     <scope.Boundary>
+ *       <Happy />
+ *       <Sad />
+ *     </scope.Boundary>
+ *   );
+ * }
  *
  * // Dispatch / subscribe — no extra options.
- * actions.dispatch(Scope.Mood, mood);
- * actions.useAction(Scope.Mood, (context, mood) => { ... });
+ * actions.dispatch(MulticastActions.Mood, mood);
+ * actions.useAction(MulticastActions.Mood, (context, mood) => { ... });
  * ```
  */
 export declare enum Distribution {
@@ -201,7 +241,7 @@ export declare enum Distribution {
     Unicast = "unicast",
     /** Action is broadcast to all mounted components and can be consumed. */
     Broadcast = "broadcast",
-    /** Action is multicast to every component inside its `withScope` boundary. */
+    /** Action is multicast to every component inside its `<scope.Boundary>`. */
     Multicast = "multicast"
 }
 /**
@@ -238,14 +278,14 @@ export declare enum Phase {
  */
 export type Pk<T> = undefined | symbol | T;
 /**
- * Reactive field type &mdash; a value that may be a concrete `T`, or
- * `null` / `undefined` while loading, awaiting a fetch, or before
+ * Maybe-present field type &mdash; a value that may be a concrete `T`,
+ * or `null` / `undefined` while loading, awaiting a fetch, or before
  * upstream data has arrived. Use this for model fields whose presence
  * is determined by async or external state.
  *
  * @template T - The concrete value type
  */
-export type Reactive<T> = T | null | undefined;
+export type Maybe<T> = T | null | undefined;
 /**
  * Base constraint type for model state objects.
  * Models must be plain objects with string keys.
@@ -315,7 +355,7 @@ export type ChanneledAction<P = unknown, C = unknown, Name extends string = stri
  * to check whether a cached value exists before performing default fetches.
  *
  * This type extends `HandlerPayload<P, C>` with an additional brand to enforce at compile-time
- * that only broadcast actions can be passed to `context.actions.resolution()`.
+ * that only broadcast actions can be passed to `context.actions.final()`.
  *
  * @template P - The payload type for the action
  * @template C - The channel type for channeled dispatches (defaults to never)
@@ -325,7 +365,7 @@ export type ChanneledAction<P = unknown, C = unknown, Name extends string = stri
  * const SignedOut = Action<User>("SignedOut", Distribution.Broadcast);
  *
  * // Resolve the latest value inside a handler
- * const user = await context.actions.resolution(SignedOut);
+ * const user = await context.actions.final(SignedOut);
  * ```
  */
 export type BroadcastPayload<P = unknown, C extends Filter = never, Name extends string = string> = HandlerPayload<P, C, Name> & {
@@ -475,23 +515,21 @@ export type HandlerContext<M extends Model | void, AC extends Actions | void, D
     readonly task: Task;
     readonly data: DeepReadonly<D>;
     readonly tasks: ReadonlySet<Task>;
-    readonly store: DeepReadonly<Store>;
+    readonly env: DeepReadonly<Env>;
     readonly actions: {
         produce<F extends (draft: {
             model: M;
-            store: Store;
+            env: Env;
             readonly inspect: Readonly<Inspect<M>>;
         }) => void>(ƒ: F & AssertSync<F>): 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;
         readonly inspect: Readonly<Inspect<M>>;
-        resource: (<T>(invocation: T | null) => PromiseLike<T> & {
-            readonly exceeds: (duration: Temporal.DurationLike) => Promise<T>;
-        }) & {
+        resource: (<T>(invocation: T | null) => ResourceCall<T>) & {
             set<T>(invocation: T | null, data: T): void;
         };
-        resolution<T>(action: BroadcastPayload<T> | MulticastPayload<T>): Promise<T | null>;
+        final<T>(action: BroadcastPayload<T> | MulticastPayload<T>): Promise<T | null>;
         peek<T>(action: BroadcastPayload<T> | MulticastPayload<T>): T | null;
     };
 };
@@ -557,7 +595,7 @@ type OwnKeys<AC> = Exclude<keyof AC & string, "prototype">;
  *
  * Used to constrain `dispatch` and `useAction` so that only actions owned by
  * the component's `AC` (plus the global `Lifecycle.Fault` /
- * `Lifecycle.Store`) can be referenced.
+ * `Lifecycle.Env`) 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]>;
@@ -576,10 +614,10 @@ export type ChanneledOf<A> = A extends HandlerPayload<infer P, infer C> ? [C] ex
 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` and `Lifecycle.Store`
+ * `Dispatchable<AC>` plus the shared `Lifecycle.Fault` and `Lifecycle.Env`
  * broadcasts which live outside `AC` but are subscribable by any component.
  */
-export type Subscribable<AC> = Dispatchable<AC> | typeof Lifecycle.Fault | typeof Lifecycle.Store;
+export type Subscribable<AC> = Dispatchable<AC> | typeof Lifecycle.Fault | typeof Lifecycle.Env;
 /**
  * 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

package/dist/utils/index.d.ts

@@ -3,15 +3,15 @@ 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
- * aborted. Use to inject a cancellable delay into an action handler.
+ * milliseconds, or rejects with an {@link Aborted} when the signal is aborted. Use to inject a cancellable
+ * delay into an action handler.
  *
  * @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.
+ *          an {@link Aborted} if `signal` aborts first.
  */
 export declare function sleep(ms: number, signal: AbortSignal | undefined): Promise<void>;
 /**
@@ -21,12 +21,13 @@ export declare function sleep(ms: number, signal: AbortSignal | undefined): Prom
  *
  * @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.
+ *               Aborts propagate as an {@link Aborted} 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.
+ *          with a `DOMException("aborted", "Aborted")` if `signal`
+ *          aborts first.
  */
 export declare function poll(ms: number, signal: AbortSignal | undefined, fn: () => boolean | Promise<boolean>): Promise<void>;
 /**

package/dist/with/index.d.ts

@@ -0,0 +1,40 @@
+import { Actions, HandlerContext, Model, Props } from '../types/index';
+/**
+ * Handler factories that wire an action directly to a model field.
+ *
+ * - {@link With.Update} assigns the dispatched payload to `model[key]`.
+ * - {@link With.Invert} flips a boolean field on `model[key]`.
+ *
+ * Both are typed so the call site fails to compile when `key` is missing or
+ * has an incompatible type.
+ *
+ * @example
+ * ```ts
+ * import { With } from "march-hare";
+ *
+ * type Model = { name: string; sidebar: boolean };
+ *
+ * class Actions {
+ *   static SetName = Action<string>("SetName");
+ *   static ToggleSidebar = Action("ToggleSidebar");
+ * }
+ *
+ * actions.useAction(Actions.SetName, With.Update("name"));
+ * actions.useAction(Actions.ToggleSidebar, With.Invert("sidebar"));
+ * ```
+ */
+export declare const With: {
+    /**
+     * Returns a handler that assigns the action payload to `model[key]`.
+     *
+     * Type-checks at the call site: the payload type must be assignable to
+     * the model property's type, and the key must exist on the model.
+     */
+    Update<K extends string>(key: K): <M extends Model, A extends Actions | void, D extends Props, P extends K extends keyof M ? M[K] : never>(context: HandlerContext<M, A, D>, payload: P) => void;
+    /**
+     * Returns a handler that inverts a boolean field on the model.
+     *
+     * Type-checks at the call site: `model[key]` must be a boolean.
+     */
+    Invert<K extends string>(key: K): <M extends Model & Record<K, boolean>, A extends Actions | void, D extends Props>(context: HandlerContext<M, A, D>) => void;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-hare",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "module",
   "license": "MIT",
   "packageManager": "yarn@1.22.22",

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

@@ -1,41 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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;
-};