march-hare 0.8.0 → 0.10.0

package/dist/types/index.d.ts

@@ -1,8 +1,41 @@
 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 { WithHandle } from '../with/index';
 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 +67,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 +118,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 +144,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 +179,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 +212,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 +242,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 +279,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 +356,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 +366,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> & {
@@ -442,16 +483,19 @@ export type Filter = Record<string, string | number | bigint | boolean | symbol>
  */
 export type ActionOrChanneled<A extends HandlerPayload = HandlerPayload> = A | ChanneledAction;
 /**
- * Checks if a function type returns a Promise.
- * @internal
- */
-type IsAsync<F> = F extends (...args: unknown[]) => Promise<unknown> ? true : false;
-/**
- * Type guard that produces a compile-time error if an async function is passed.
- * Used to enforce synchronous callbacks in `produce()`.
+ * Type guard that produces a compile-time error if an async function is
+ * passed. Used to enforce synchronous callbacks in `produce()`.
+ *
+ * The `[F]` tuple wrapping prevents distribution over function unions, and
+ * checking the actual signature (`(...args: never[]) => Promise<unknown>`)
+ * sidesteps TypeScript's lenient `Promise<void>`→`void` assignability that
+ * would otherwise let an async recipe satisfy a `(draft) => void`
+ * constraint. Async F collapses the argument type to `never`, which no
+ * function value can satisfy.
+ *
  * @internal
  */
-type AssertSync<F> = IsAsync<F> extends true ? "Error: async functions are not allowed in produce" : F;
+type AssertSync<F> = [F] extends [(...args: never[]) => Promise<unknown>] ? never : F;
 /**
  * Base type for data props passed to useActions.
  * Represents any object that can be captured as reactive data.
@@ -469,29 +513,27 @@ 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> = {
+export type HandlerContext<M extends Model | void, AC extends Actions | void, D extends Props = Props, S extends Env = Env> = {
     readonly model: DeepReadonly<M>;
     readonly phase: Phase;
     readonly task: Task;
     readonly data: DeepReadonly<D>;
     readonly tasks: ReadonlySet<Task>;
-    readonly store: DeepReadonly<Store>;
+    readonly env: Readonly<S>;
     readonly actions: {
         produce<F extends (draft: {
             model: M;
-            store: Store;
+            env: S;
             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;
     };
 };
@@ -512,7 +554,7 @@ export type HandlerContext<M extends Model | void, AC extends Actions | void, D
  * @example
  * ```tsx
  * const [model, actions, data] = useActions<Model, typeof Actions, Data>(
- *   initialModel,
+ *   model,
  *   () => ({ user, theme }),
  * );
  *
@@ -540,7 +582,7 @@ export type HandlerContext<M extends Model | void, AC extends Actions | void, D
  *
  * @see {@link Handlers} for the recommended HKT pattern
  */
-export type Handler<M extends Model | void, AC extends Actions | void, K extends keyof AC & string, D extends Props = Props> = (context: HandlerContext<M, AC, D>, ...args: [Payload<AC[K] & HandlerPayload<unknown>>] extends [never] ? [] : [payload: Payload<AC[K] & HandlerPayload<unknown>>]) => void | Promise<void> | AsyncGenerator | Generator;
+export type Handler<M extends Model | void, AC extends Actions | void, K extends keyof AC & string, D extends Props = Props, S extends Env = Env> = (context: HandlerContext<M, AC, D, S>, ...args: [Payload<AC[K] & HandlerPayload<unknown>>] extends [never] ? [] : [payload: Payload<AC[K] & HandlerPayload<unknown>>]) => void | Promise<void> | AsyncGenerator | Generator;
 /**
  * String keys of `AC` excluding inherited `prototype` from class constructors.
  * When action containers are classes (`typeof MyActions`), TypeScript includes
@@ -557,7 +599,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 +618,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
@@ -629,10 +671,10 @@ export type WithPayloadActions<U> = Exclude<U, {
  * export const handlePaymentSent: H["Broadcast"]["PaymentSent"] = (context) => { ... };
  * ```
  */
-export type Handlers<M extends Model | void, AC extends Actions | void, D extends Props = Props, RootAC extends Actions | void = AC> = {
-    [K in OwnKeys<AC>]: OwnKeys<AC[K]> extends never ? (context: HandlerContext<M, RootAC, D>, ...args: [Payload<AC[K] & HandlerPayload<unknown>>] extends [never] ? [] : [payload: Payload<AC[K] & HandlerPayload<unknown>>]) => void | Promise<void> | AsyncGenerator | Generator : Handlers<M, AC[K] & Actions, D, RootAC>;
+export type Handlers<M extends Model | void, AC extends Actions | void, D extends Props = Props, RootAC extends Actions | void = AC, S extends Env = Env> = {
+    [K in OwnKeys<AC>]: OwnKeys<AC[K]> extends never ? (context: HandlerContext<M, RootAC, D, S>, ...args: [Payload<AC[K] & HandlerPayload<unknown>>] extends [never] ? [] : [payload: Payload<AC[K] & HandlerPayload<unknown>>]) => void | Promise<void> | AsyncGenerator | Generator : Handlers<M, AC[K] & Actions, D, RootAC, S>;
 };
-export type UseActions<M extends Model | void, AC extends Actions | void, D extends Props = Props> = [
+export type UseActions<M extends Model | void, AC extends Actions | void, D extends Props = Props, S extends Env = Env> = [
     Readonly<M>,
     {
         /**
@@ -665,6 +707,7 @@ export type UseActions<M extends Model | void, AC extends Actions | void, D exte
          * );
          * ```
          */
+        stream(action: typeof Lifecycle.Env, renderer: (value: Readonly<S>, inspect: Inspect<S>) => React.ReactNode): React.ReactNode;
         stream<T extends object>(action: BroadcastPayload<T>, renderer: (value: T, inspect: Inspect<T>) => React.ReactNode): React.ReactNode;
     },
     DeepReadonly<D>
@@ -705,8 +748,9 @@ export type UseActions<M extends Model | void, AC extends Actions | void, D exte
      * });
      * ```
      */
-    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;
+    useAction(action: NoPayloadActions<Subscribable<AC>>, handler: (context: HandlerContext<M, AC, D, S>) => void | Promise<void> | AsyncGenerator | Generator): void;
+    useAction(action: typeof Lifecycle.Env, handler: (context: HandlerContext<M, AC, D, S>, env: Readonly<S>) => void | Promise<void> | AsyncGenerator | Generator): void;
+    useAction<A extends WithPayloadActions<Subscribable<AC>>>(action: A, handler: (context: HandlerContext<M, AC, D, S>, payload: Payload<A>) => void | Promise<void> | AsyncGenerator | Generator): void;
 };
 /**
  * Stable, typed dispatch function for the actions class `AC`. Same call
@@ -729,10 +773,16 @@ export type Dispatch<AC extends Actions | void> = {
  * `React.Context` &mdash; it's the March Hare action surface returned by
  * the `useContext` hook of this library.
  */
-export type Context<M extends Model | void, AC extends Actions | void, D extends Props = Props> = {
+export type Context<M extends Model | void, AC extends Actions | void, D extends Props = Props, S extends Env = Env> = {
     readonly actions: {
         dispatch: Dispatch<AC>;
     };
-    useActions(getData?: () => D): UseActions<M, AC, D>;
-    useActions(initialModel: M extends void ? never : M, getData?: () => D): UseActions<M, AC, D>;
+    /**
+     * Typed bag of handler factories bound to `M`. Methods accept lodash-style
+     * dotted paths with array indices (e.g. `"a.b.c"`, `"items.0.id"`) and
+     * autocomplete from the model. See {@link WithHandle}.
+     */
+    readonly with: WithHandle<M>;
+    useActions(getData?: () => D): UseActions<M, AC, D, S>;
+    useActions(model: M extends void ? never : M, getData?: () => D): UseActions<M, AC, D, S>;
 };

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,111 @@
+import { Actions, HandlerContext, Model, Props } from '../types/index';
+import { Env } from '../boundary/components/env/index';
+type Primitive = string | number | bigint | boolean | symbol | null | undefined;
+type Depth = [never, 0, 1, 2, 3, 4, 5];
+/**
+ * Lodash-style dotted paths reachable from `T`. Yields `"a"`, `"a.b"`,
+ * `"items.0"`, `"items.0.name"`, etc. Recursion is capped at depth 5 to
+ * keep the type-checker tractable on deeply nested models.
+ *
+ * @template T The object type to enumerate paths from.
+ * @template D Recursion budget (internal).
+ */
+export type Paths<T, D extends number = 5> = [D] extends [never] ? never : T extends Primitive ? never : T extends ReadonlyArray<infer U> ? `${number}` | (U extends Primitive ? never : `${number}.${Paths<U, Depth[D]>}`) : T extends object ? {
+    [K in Extract<keyof T, string>]: T[K] extends Primitive ? K : K | `${K}.${Paths<T[K], Depth[D]>}`;
+}[Extract<keyof T, string>] : never;
+/**
+ * Subset of {@link Paths} whose leaf type is `boolean`. Used by
+ * `context.with.invert` (and the legacy {@link With.Invert}) to restrict the
+ * key to togglable fields only.
+ *
+ * @template T The object type to enumerate boolean leaves from.
+ * @template D Recursion budget (internal).
+ */
+export type BooleanPaths<T, D extends number = 5> = [D] extends [never] ? never : T extends Primitive ? never : T extends ReadonlyArray<infer U> ? (U extends boolean ? `${number}` : never) | (U extends Primitive ? never : `${number}.${BooleanPaths<U, Depth[D]>}`) : T extends object ? {
+    [K in Extract<keyof T, string>]: T[K] extends boolean ? K : T[K] extends Primitive ? never : `${K}.${BooleanPaths<T[K], Depth[D]>}`;
+}[Extract<keyof T, string>] : never;
+/**
+ * Resolves the leaf type at a dotted path on `T`. `Get<{a:{b:number}},"a.b">`
+ * is `number`; `Get<{items: string[]},"items.0">` is `string`.
+ *
+ * @template T The object type to walk.
+ * @template P The dotted path string.
+ */
+export type Get<T, P extends string> = P extends `${infer Head}.${infer Tail}` ? T extends ReadonlyArray<infer U> ? Head extends `${number}` ? Get<U, Tail> : never : Head extends keyof T ? Get<T[Head], Tail> : never : T extends ReadonlyArray<infer U> ? P extends `${number}` ? U : never : P extends keyof T ? T[P] : never;
+/**
+ * Returned by `context.with` &mdash; a typed bag of handler factories
+ * bound to the model `M` declared in `useContext<M, …>()`. Methods accept
+ * lodash-style dotted paths (`"a.b.c"`) with array indices (`"items.0.id"`).
+ *
+ * - `update(key)` &mdash; assigns the dispatched payload to `model[key]`.
+ * - `invert(key)` &mdash; flips a boolean leaf at `model[key]`.
+ * - `always(key, value)` &mdash; assigns a fixed `value` to `model[key]`,
+ *   ignoring any dispatched payload.
+ *
+ * @template M The model type to bind keys against.
+ */
+export type WithHandle<M> = M extends Model ? {
+    update<K extends Paths<M>>(key: K): <A extends Actions | void, D extends Props, S extends Env = Env>(context: HandlerContext<M, A, D, S>, payload: Get<M, K>) => void;
+    invert<K extends BooleanPaths<M>>(key: K): <A extends Actions | void, D extends Props, S extends Env = Env>(context: HandlerContext<M, A, D, S>) => void;
+    always<K extends Paths<M>>(key: K, value: Get<M, K>): <A extends Actions | void, D extends Props, S extends Env = Env>(context: HandlerContext<M, A, D, S>) => void;
+} : Record<string, never>;
+/**
+ * Builds the {@link WithHandle} object returned via `context.with`. The
+ * runtime is identical for any model &mdash; only the call-site types differ.
+ *
+ * @internal
+ */
+export declare function bindWith<M extends Model | void>(): WithHandle<M>;
+/**
+ * Handler factories that wire an action directly to a model field. Prefer
+ * `context.with` from `useContext<Model>()` for first-class autocompletion
+ * over dotted paths; this top-level form is kept for callers that don't have
+ * a typed `context` in scope.
+ *
+ * - {@link With.Update} assigns the dispatched payload to a model path.
+ * - {@link With.Invert} flips a boolean leaf at a model path.
+ * - {@link With.Always} assigns a fixed value to a model path, ignoring any
+ *   dispatched payload.
+ *
+ * Keys may be lodash-style dotted paths (`"a.b.c"`) and support array
+ * indices (`"items.0.name"`). The model type is inferred at handler-bind
+ * time; an invalid path or mismatched payload fails to compile when the
+ * handler is registered with `useAction`.
+ *
+ * @example
+ * ```ts
+ * import { With } from "march-hare";
+ *
+ * type Model = {
+ *   name: string;
+ *   sidebar: boolean;
+ *   nested: { open: boolean };
+ *   items: { id: number }[];
+ * };
+ *
+ * actions.useAction(Actions.SetName, With.Update("name"));
+ * actions.useAction(Actions.SetFirstId, With.Update("items.0.id"));
+ * actions.useAction(Actions.ToggleSidebar, With.Invert("sidebar"));
+ * actions.useAction(Actions.ToggleNested, With.Invert("nested.open"));
+ * actions.useAction(Actions.Open, With.Always("nested.open", true));
+ * ```
+ */
+export declare const With: {
+    /**
+     * Returns a handler that assigns the action payload to the model leaf at
+     * the given lodash-style path. The payload type must match `Get<M, K>`,
+     * and the path 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 Paths<M> ? Get<M, K> : never, S extends Env = Env>(context: HandlerContext<M, A, D, S>, payload: P) => void;
+    /**
+     * Returns a handler that inverts a boolean leaf at the given lodash-style
+     * path. The leaf must be a `boolean` on the model.
+     */
+    Invert<K extends string>(key: K): <M extends Model, A extends Actions | void, D extends Props, S extends Env = Env>(context: K extends BooleanPaths<M> ? HandlerContext<M, A, D, S> : never) => void;
+    /**
+     * Returns a handler that assigns a fixed `value` to the model leaf at the
+     * given lodash-style path. The dispatched payload (if any) is ignored.
+     */
+    Always<K extends string, V>(key: K, value: V): <M extends Model, A extends Actions | void, D extends Props, S extends Env = Env>(context: K extends Paths<M> ? V extends Get<M, K> ? HandlerContext<M, A, D, S> : never : never) => void;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-hare",
-  "version": "0.8.0",
+  "version": "0.10.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;
-};

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

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