march-hare 0.13.0 → 0.13.2

package/README.md

@@ -27,8 +27,9 @@
 1. [Multicast actions](#multicast-actions)
 1. [Global data](#global-data)
 1. [Reusable components](#reusable-components)
+1. [Scaffolding CLI](#scaffolding-cli)
 
-For advanced topics, see the [recipes directory](./recipes/). For a worked end-to-end example with the FSD layout, see [`src/example/`](./src/example/README.md).
+For advanced topics, see the [recipes directory](./recipes/). For a worked end-to-end example with the FSD layout, see [`src/example/`](./src/example/README.md). To scaffold a new project that mirrors that example, see [`src/cli/`](./src/cli/README.md).
 
 ## Benefits
 
@@ -606,6 +607,26 @@ export default function CatCard(): React.ReactElement {
 
 `Cache()` with no adapter is an in-memory scope – 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.
 
+For multi-tenant apps that share a single backing store, add a `key(context)` callback alongside the adapter methods to derive a per-context prefix from the live `<app.Boundary>` Env. The callback receives the same `{ env }` an `app.Resource` fetcher sees; its return value is prepended to every cache slot, so two users on the same device do not see each other's data:
+
+```ts
+// app.ts
+type AppEnv = { session: { accessToken: string } | null };
+
+export const app = App<AppEnv>({
+  env: { session: null },
+  cache: Cache<AppEnv>({
+    get: (key) => localStorage.getItem(key),
+    set: (key, value) => localStorage.setItem(key, value),
+    remove: (key) => localStorage.removeItem(key),
+    clear: () => localStorage.clear(),
+    key: ({ env }) => env.session?.accessToken ?? "",
+  }),
+});
+```
+
+Successful writes for Alice land under `alice:0:{...}`; Bob's land under `bob:0:{...}`. Return `""`, `null`, or `undefined` to skip prefixing &ndash; useful for the signed-out gap, where the scope is genuinely empty.
+
 The adapter contract is **strictly synchronous** &ndash; `get` / `set` / `remove` / `clear` all return immediately, with no `Promise`. The model-literal read (`{ user: resource.user.get() }`) is evaluated during render and has no place to wait. React Native projects should use [`react-native-mmkv`](https://github.com/mrousavy/react-native-mmkv), which is sync out of the box and drops straight into the contract; `AsyncStorage` is incompatible. Truly async backends (IndexedDB, `chrome.storage.local`) need a sync facade hydrated at app entry &ndash; see the [storage recipe](./recipes/storage.md).
 
 See the [storage recipe](./recipes/storage.md) for backend adapters (React Native `react-native-mmkv`, browser `localStorage`, browser extension `chrome.storage`), sign-out purge, and the `unset` sentinel that keeps "nothing stored" distinct from "a legitimately stored null".
@@ -896,3 +917,26 @@ function Where(): React.ReactElement {
 When a reusable component or resource is genuinely Env-agnostic &mdash; the fetcher never touches `context.env`, the hook never calls `shared.useEnv` &mdash; pass `Envless` as `E` instead of spelling out `Record<never, never>`: `shared.Resource<Envless, T>`, `shared.useContext<Envless, M, A>()`. It's a named alias for the empty-record shape exported from `march-hare`, kept around purely for legibility at the call site.
 
 For one-line handler binding &mdash; flipping a boolean, assigning a payload to a leaf, pinning a field to a fixed value &mdash; reach for `context.with.{update,invert,always}`. See the [`With` helpers recipe](./recipes/with-helpers.md) for the full surface.
+
+## Scaffolding CLI
+
+A [Hygen](https://github.com/jondot/hygen)-style scaffolder ships under [`src/cli/`](./src/cli/) as the `mh` binary. It mirrors the layout of [`src/example/`](./src/example/) and the FSD layering rules enforced by `eslint-plugin-boundaries` &mdash; imports flow strictly downward (`app → features → shared`).
+
+```bash
+cd src/cli
+npm install
+npm link          # creates the global `mh` binary
+```
+
+Run it with no arguments for an interactive menu, or drive any leaf command directly:
+
+```bash
+mh                            # banner + interactive menu
+mh init my-project            # bootstrap a new project
+mh feature new add-cat        # add a stateful feature
+mh app new dashboard          # add a page
+mh shared component card      # add a shared component
+mh feature action counter Reset   # inject an Action + handler stub
+```
+
+Every command lives in a tree &mdash; typing `mh feature` opens a sub-menu, typing `mh feature new` prompts for a name, typing `mh feature new add-cat` runs non-interactively. See [`src/cli/README.md`](./src/cli/README.md) for the full command surface, the template format, and instructions for adding your own generators.

package/dist/action/index.d.ts

@@ -1,5 +1,5 @@
-import { HandlerPayload, BroadcastPayload, MulticastPayload, Distribution, Filter } from '../types/index';
-export { getActionSymbol, getLifecycleType, isBroadcastAction, isMulticastAction, getName, isChanneledAction, } from './utils';
+import { HandlerPayload, BroadcastPayload, MulticastPayload, Distribution, Filter } from '../types/index.js';
+export { getActionSymbol, getLifecycleType, isBroadcastAction, isMulticastAction, getName, isChanneledAction, } from './utils.js';
 /**
  * Interface for the Action factory function.
  */

package/dist/action/utils.d.ts

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

package/dist/actions/index.d.ts

@@ -1,5 +1,5 @@
-import { Data } from './types';
-import { Model, Props, Actions, UseActions } from '../types/index';
+import { Data } from './types.js';
+import { Model, Props, Actions, UseActions } from '../types/index.js';
 /**
  * A hook for managing state with actions.
  *

package/dist/actions/types.d.ts

@@ -1,8 +1,8 @@
 import { default as EventEmitter } from 'eventemitter3';
 import { RefObject } from 'react';
-import { Model, HandlerContext, Actions, Props, Tasks, ActionId, Phase, Filter } from '../types/index';
-import { BroadcastEmitter } from '../boundary/components/broadcast/utils';
-import { ScopeContext } from '../boundary/components/scope/types';
+import { Model, HandlerContext, Actions, Props, Tasks, ActionId, Phase, Filter } from '../types/index.js';
+import { BroadcastEmitter } from '../boundary/components/broadcast/utils.js';
+import { ScopeContext } from '../boundary/components/scope/types.js';
 /**
  * Function signature for action handlers registered via `useAction`.
  * Receives the reactive context and payload, returning void or a promise/generator.

package/dist/actions/utils.d.ts

@@ -1,8 +1,8 @@
 import { RefObject } from 'react';
-import { Props, Model, Actions, Filter, ActionId, HandlerPayload, ChanneledAction, HandlerContext } from '../types/index';
+import { Props, Model, Actions, Filter, ActionId, HandlerPayload, ChanneledAction, HandlerContext } from '../types/index.js';
 import { default as EventEmitter } from 'eventemitter3';
-import { Dispatchers, LifecycleConfig, Scope } from './types';
-import { isChanneledAction, getActionSymbol } from '../action/index';
+import { Dispatchers, LifecycleConfig, Scope } from './types.js';
+import { isChanneledAction, getActionSymbol } from '../action/index.js';
 import * as React from "react";
 /**
  * Creates a new object with getters for each property of the input object.

package/dist/app/index.d.ts

@@ -1,10 +1,10 @@
-import { Env } from '../boundary/components/env/index';
-import { Cache } from '../cache/index';
-import { Actions, Model, Props } from '../types/index';
-import { AppHandle, AppContextHandle } from './types';
-import { Tap } from '../boundary/components/tap/types';
-export type { AppArgs, AppContextHandle, AppFetcher, AppResource, } from './types';
-export type { AppHandle } from './types';
+import { Env } from '../boundary/components/env/types.js';
+import { Cache } from '../cache/index.js';
+import { Actions, Model, Props } from '../types/index.js';
+import { AppHandle, AppContextHandle } from './types.js';
+import { Tap } from '../boundary/components/tap/types.js';
+export type { AppArgs, AppContextHandle, AppFetcher, AppResource, } from './types.js';
+export type { AppHandle } from './types.js';
 /**
  * Creates an `App` — the entrypoint for a typed Env shape `E`,
  * inferred from `config.env`. `App<E>` exposes `Boundary`, hooks, and

package/dist/app/types.d.ts

@@ -1,8 +1,8 @@
-import { Args, ResourceHandle } from '../resource/types';
-import { Actions, Context, Model, Props, UseActions } from '../types/index';
-import { Data } from '../actions/types';
-import { Env } from '../boundary/components/env/index';
-import { WithHandle } from '../with/types';
+import { Args, ResourceHandle } from '../resource/types.js';
+import { Actions, Context, Model, Props, UseActions } from '../types/index.js';
+import { Data } from '../actions/types.js';
+import { Env } from '../boundary/components/env/types.js';
+import { WithHandle } from '../with/types.js';
 /**
  * Args object passed to an `app.Resource` fetcher. Same shape as the
  * base `Resource` fetcher's args but with `env` typed as `E`.

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

@@ -1,6 +1,6 @@
-import { Props } from './types';
+import { Props } from './types.js';
 import * as React from "react";
-export { useBroadcast, BroadcastEmitter } from './utils';
+export { useBroadcast, BroadcastEmitter } from './utils.js';
 /**
  * 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/boundary/components/broadcast/types.d.ts

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

package/dist/boundary/components/consumer/components/partition/index.d.ts

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

package/dist/boundary/components/consumer/components/partition/types.d.ts

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

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

@@ -1,9 +1,9 @@
-import { Props } from './types';
+import { Props } from './types.js';
 import * as React from "react";
-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';
+export { useConsumer } from './utils.js';
+export { Partition } from './components/partition/index.js';
+export type { Props as PartitionProps } from './components/partition/types.js';
+export type { ConsumerRenderer, Entry, ConsumerContext } from './types.js';
 /**
  * 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/boundary/components/consumer/types.d.ts

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

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

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

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

@@ -1,32 +1,8 @@
-import { Props } from './types';
+import { Props } from './types.js';
 import * as React from "react";
-export { useEnv } from './utils';
+export { useEnv } from './utils.js';
 /**
- * Loose runtime shape for the per-`<Boundary>` Env. Each {@link App}
- * narrows this to its own typed env via `App<E>({ env })`; the
- * loose type exists so the framework's internal plumbing
- * (`<Boundary>`, `useEnv`, handler `context.env`, Resource
- * fetcher `context.env`) does not need to be parametric over E.
- *
- * Consumers should declare their Env shape inline via `App({ env })`
- * &mdash; the inferred `E` is what flows through `app.useContext`,
- * `app.useEnv`, and `app.Resource`. Module augmentation of `Env`
- * is no longer required.
- */
-export type Env = Record<string, unknown>;
-/**
- * `E` generic for `shared.X<E, ...>` factories whose callers don't read
- * anything off the Env. Equivalent to `Record<never, never>` &mdash; the
- * named alias keeps consumer sites legible (`shared.Resource<Envless, T>`
- * over `shared.Resource<Record<never, never>, T>`) and signals intent.
- *
- * Reach for `Envless` only when the component or resource is genuinely
- * Env-agnostic. Anything that reads `context.env.x` should declare the
- * required shape (or a union of host Envs) as `E` instead.
- */
-export type Envless = Record<never, never>;
-/**
- * Provides a per-Boundary {@link Env} value to every component inside
+ * Provides a per-Boundary {@link EnvType} value to every component inside
  * the boundary. Usually wired in via the `<Boundary env={initial}>`
  * prop rather than used directly.
  *

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

@@ -1,6 +1,28 @@
 import { ReactNode } from 'react';
-import { Env } from './index';
-export type { Env } from './index';
+/**
+ * Loose runtime shape for the per-`<Boundary>` Env. Each {@link App}
+ * narrows this to its own typed env via `App<E>({ env })`; the
+ * loose type exists so the framework's internal plumbing
+ * (`<Boundary>`, `useEnv`, handler `context.env`, Resource
+ * fetcher `context.env`) does not need to be parametric over E.
+ *
+ * Consumers should declare their Env shape inline via `App({ env })`
+ * &mdash; the inferred `E` is what flows through `app.useContext`,
+ * `app.useEnv`, and `app.Resource`. Module augmentation of `Env`
+ * is no longer required.
+ */
+export type Env = Record<string, unknown>;
+/**
+ * `E` generic for `shared.X<E, ...>` factories whose callers don't read
+ * anything off the Env. Equivalent to `Record<never, never>` &mdash; the
+ * named alias keeps consumer sites legible (`shared.Resource<Envless, T>`
+ * over `shared.Resource<Record<never, never>, T>`) and signals intent.
+ *
+ * Reach for `Envless` only when the component or resource is genuinely
+ * Env-agnostic. Anything that reads `context.env.x` should declare the
+ * required shape (or a union of host Envs) as `E` instead.
+ */
+export type Envless = Record<never, never>;
 /**
  * Props for the Env provider component. Accepts the initial Env
  * value that satisfies the augmented {@link Env} interface.

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

@@ -1,5 +1,5 @@
 import { RefObject } from 'react';
-import { Env } from './index';
+import { Env } from './types.js';
 import * as React from "react";
 /**
  * React context exposing the per-Boundary Env ref. The ref itself is

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

@@ -1,2 +1,2 @@
-export { Context, useScope, getScope } from './utils';
-export type { ScopeEntry, ScopeContext } from './types';
+export { Context, useScope, getScope } from './utils.js';
+export type { ScopeEntry, ScopeContext } from './types.js';

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

@@ -1,4 +1,4 @@
-import { BroadcastEmitter } from '../broadcast/utils';
+import { BroadcastEmitter } from '../broadcast/utils.js';
 /**
  * Runtime entry for a single multicast scope opened by an
  * `<app.Scope().Boundary>`. The `id` uniquely identifies this scope

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

@@ -1,4 +1,4 @@
-import { ScopeContext, ScopeEntry } from './types';
+import { ScopeContext, ScopeEntry } from './types.js';
 import * as React from "react";
 /**
  * React context for the nearest multicast scope. `null` at the root.

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

@@ -1,4 +1,4 @@
-import { Invocation } from '../../../resource/index';
+import { Invocation } from '../../../resource/index.js';
 import * as React from "react";
 /**
  * Per-`<Boundary>` registry for `.coalesce(token)` sharing. Outer map

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

@@ -1,7 +1,7 @@
-import { Props } from './types';
+import { Props } from './types.js';
 import * as React from "react";
-export { useTap } from './utils';
-export type { Tap, Taps, Invocation, Failure, Mutations, Snapshot, } from './types';
+export { useTap } from './utils.js';
+export type { Tap, Taps, Invocation, Failure, Mutations, Snapshot, } from './types.js';
 /**
  * Internal provider that wires a {@link Tap} observer into the React
  * context consumed by `useActions` during dispatch. Rendered by the

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

@@ -1,5 +1,5 @@
-import { Reason } from '../../../error/types';
-import { Task } from '../tasks/types';
+import { Reason } from '../../../error/types.js';
+import { Task } from '../tasks/types.js';
 import type * as React from "react";
 /**
  * Identity of a handler invocation: the action being handled and the

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

@@ -1,4 +1,4 @@
-import { Tap } from './types';
+import { Tap } from './types.js';
 import * as React from "react";
 /**
  * React context carrying the active {@link Tap} observer for the

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

@@ -1,6 +1,6 @@
-import { Props } from './types';
+import { Props } from './types.js';
 import * as React from "react";
-export type { Task } from './types';
+export type { Task } from './types.js';
 /**
  * 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

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

@@ -1,4 +1,4 @@
-import { Tasks } from './types';
+import { Tasks } from './types.js';
 import * as React from "react";
 /**
  * React context for the shared tasks Set.

package/dist/boundary/index.d.ts

@@ -1,4 +1,4 @@
-import { Props } from './types';
+import { Props } from './types.js';
 import * as React from "react";
 /**
  * Low-level boundary primitive. Wraps children with the Broadcaster,

package/dist/boundary/types.d.ts

@@ -1,5 +1,5 @@
-import { Env } from './components/env/types';
-import { Tap } from './components/tap/types';
+import { Env } from './components/env/types.js';
+import { Tap } from './components/tap/types.js';
 import type * as React from "react";
 /**
  * Props accepted by the bare `<Boundary>` provider.

package/dist/cache/index.d.ts

@@ -1,5 +1,35 @@
-import { Adapter, Stored } from './types';
-export type { Adapter, Encoded } from './types';
+import { Adapter, Stored } from './types.js';
+import { Env } from '../boundary/components/env/types.js';
+export type { Adapter, Encoded } from './types.js';
+/**
+ * Context passed to {@link CacheConfig.key}. Mirrors the shape an
+ * `app.Resource` fetcher receives, restricted to the field the cache
+ * needs to scope on: the live per-`<Boundary>` Env. Future-extensible
+ * &mdash; new fields can land here without breaking the call shape.
+ *
+ * @template E The Env shape the cache is parameterised by.
+ */
+export type CacheContext<E extends object> = {
+    readonly env: E;
+};
+/**
+ * Configuration accepted by the {@link Cache} factory. Combines the
+ * synchronous {@link Adapter} (`get`/`set`/`remove`/`clear`/`keys?`)
+ * with an optional `key(context)` callback in a single flat object,
+ * so all the cache's plumbing lives in one literal at the call site.
+ *
+ * - `key` &mdash; derives a per-context cache scope. Called every time
+ *   a cache key is assembled with the same `{ env }` shape an
+ *   `app.Resource` fetcher receives; the returned string is prepended
+ *   to the per-resource namespace and params so different scopes
+ *   (e.g. one cache slot per access token, locale, or tenant id) can
+ *   coexist in the same backing store. Return `""`, `null`, or
+ *   `undefined` to skip prefixing &mdash; useful for "not signed in"
+ *   gaps where the scope is genuinely empty.
+ */
+export type CacheConfig<E extends object> = Adapter & {
+    readonly key?: (context: CacheContext<E>) => string | null | undefined;
+};
 /**
  * Persistence-aware cache for a single {@link Resource}. Wraps a
  * **strictly synchronous** {@link Adapter} (localStorage, MMKV,
@@ -25,6 +55,21 @@ export type { Adapter, Encoded } from './types';
  * persistent store; when supplied, the adapter is the **only** tier
  * &mdash; the Cache does not maintain a separate in-memory mirror.
  *
+ * Pass `key(context)` alongside the adapter methods to scope cache
+ * slots by the per-`<Boundary>` Env. The returned string is prepended
+ * to every cache key the Resource layer assembles, so different
+ * tenants / sessions / locales share the adapter without stepping on
+ * each other.
+ *
+ * The `E` generic lives on the {@link Cache} factory and on
+ * {@link CacheConfig}: it parameterises the `key(context)` callback
+ * at construction time so the caller can read `context.env.X` with
+ * full typing. The returned {@link Cache} value is itself
+ * env-agnostic &mdash; the runtime `scope(env)` method takes the
+ * loose {@link Env} record and narrows internally before invoking
+ * the callback &mdash; which keeps it freely assignable across
+ * differently-typed Apps without variance gymnastics.
+ *
  * @example
  * ```ts
  * // In-memory, scoped to this instance.
@@ -38,6 +83,16 @@ export type { Adapter, Encoded } from './types';
  *   clear: () => localStorage.clear(),
  * });
  *
+ * // Multi-tenant: writes go under `${accessToken}:…`.
+ * type AppEnv = { session: { accessToken: string } | null };
+ * const cache = Cache<AppEnv>({
+ *   get: (key) => localStorage.getItem(key),
+ *   set: (key, value) => localStorage.setItem(key, value),
+ *   remove: (key) => localStorage.removeItem(key),
+ *   clear: () => localStorage.clear(),
+ *   key: ({ env }) => env.session?.accessToken ?? "",
+ * });
+ *
  * // Wire it into a Resource — successful runs write through automatically.
  * export const cat = Resource({
  *   cache,
@@ -87,14 +142,41 @@ export type Cache = {
      * stored params satisfy a `where` pattern.
      */
     keys(): Iterable<string>;
+    /**
+     * Returns the per-context prefix derived from the configured
+     * `key(context)`. The returned string is appended with `:` by the
+     * Resource layer to compose the full cache key. Always `""` when
+     * no `key` option was supplied or when the callback returned an
+     * empty value &mdash; "no scope" is encoded as the empty string.
+     *
+     * Takes the loose {@link Env} record at runtime &mdash; the typed
+     * `E` lives on the `key(context)` callback registered at
+     * construction time, which the cache narrows to `E` internally
+     * before invoking.
+     *
+     * @internal Public surface lives on the Resource layer; consumers
+     *   should not need to call this directly.
+     */
+    scope(env: Env | undefined): string;
 };
 /**
- * Constructs a {@link Cache} backed by `adapter`, or by an in-memory
- * `Map` when none is supplied. The returned object is the same shape
- * regardless &mdash; only the durability differs.
+ * Constructs a {@link Cache} from `config`. The config object carries
+ * the synchronous adapter methods (`get`/`set`/`remove`/`clear`/`keys?`)
+ * and, optionally, a `key(context)` callback that scopes every cache
+ * slot by the live per-`<Boundary>` Env. Omit `config` entirely for an
+ * in-memory cache scoped to this instance.
+ *
+ * When `key` is supplied, it runs each time the Resource layer
+ * assembles a cache key, receiving the same `{ env }` shape an
+ * `app.Resource` fetcher sees; its return value is prepended
+ * (separated by `:`) to the per-resource namespace and params JSON.
  *
- * @param adapter Optional synchronous backing store (localStorage, MMKV,
- *   or a custom sync facade). Omit for an in-memory cache scoped to
- *   this instance.
+ * @template E The Env shape `config.key` is typed against. Defaults
+ *   to the loose {@link Env} record so callers that don't scope by
+ *   env can keep using `Cache({ ...adapter })` without supplying a
+ *   generic.
+ * @param config Optional adapter-plus-options literal. Omit for an
+ *   in-memory cache; supply adapter methods alone for a persisted
+ *   cache; add `key` to also scope writes by the live Env.
  */
-export declare function Cache(adapter?: Adapter): Cache;
+export declare function Cache<E extends object = Env>(config?: CacheConfig<E>): Cache;

package/dist/cache/types.d.ts

@@ -1,4 +1,4 @@
-export type { Stored } from '../utils/types';
+export type { Stored } from '../utils/types.js';
 /**
  * On-disk JSON shape of a `Stored` envelope. The Cache wrapper
  * encodes a populated Stored as `{ data, at: at.toString() }` so the

package/dist/cli/bin/mh.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { main } from "../lib/index.js";
+main(process.argv.slice(2)).catch((error) => {
+    if (error instanceof Error && error.name === "ExitPromptError") {
+        process.exit(130);
+    }
+    console.error(error);
+    process.exit(1);
+});

package/dist/cli/lib/banner/index.js

@@ -0,0 +1,14 @@
+import figlet from "figlet";
+import kleur from "kleur";
+import { config } from "../utils.js";
+export function banner() {
+    const art = figlet.textSync(config.banner.title, {
+        font: config.banner.font,
+        horizontalLayout: "default",
+        verticalLayout: "default",
+    });
+    console.log(kleur.magenta(art));
+    console.log(kleur.gray(`  ${config.banner.tagline}  `) +
+        kleur.dim(config.banner.subtitle));
+    console.log();
+}

package/dist/cli/lib/commands/app/index.js

@@ -0,0 +1,37 @@
+import path from "node:path";
+import kleur from "kleur";
+import { pascalCase, capitalCase } from "change-case";
+import { scaffold } from "../../runner/index.js";
+import { askName, askDescription, pickDirectory, requireProjectRoot, } from "../../prompt/index.js";
+export async function newPage({ positional, flags, }) {
+    const root = requireProjectRoot();
+    const name = positional[0] || (await askName("Page name (kebab-case)"));
+    const heading = (typeof flags.heading === "string" ? flags.heading : undefined) ||
+        capitalCase(name);
+    const tagline = (typeof flags.tagline === "string" ? flags.tagline : undefined) ||
+        (await askDescription("Page tagline", `Welcome to ${heading}`));
+    await scaffold("app", "page", { name, heading, tagline, pascalName: pascalCase(name) }, { cwd: root });
+    console.log(kleur.green("\n  Page ready."), kleur.dim(`Wire it up in src/app/index.tsx with <${pascalCase(name)}Page />.`));
+}
+export async function integration({ positional }) {
+    const root = requireProjectRoot();
+    const pagesRoot = path.join(root, "src", "app", "pages");
+    const name = positional[0] || (await pickDirectory("page", pagesRoot));
+    await scaffold("app", "integration", { name, pascalName: pascalCase(name) }, { cwd: root });
+    console.log(kleur.green("\n  Integration test added."), kleur.dim(`Run with \`make integration\` or \`npx playwright test\`.`));
+}
+export async function action({ positional, flags, }) {
+    const root = requireProjectRoot();
+    const pagesRoot = path.join(root, "src", "app", "pages");
+    const page = positional[0] || (await pickDirectory("page", pagesRoot));
+    const name = positional[1] ||
+        (typeof flags.name === "string" ? flags.name : undefined) ||
+        (await askName("Action name (PascalCase)"));
+    await scaffold("app", "action", {
+        page,
+        name: pascalCase(name),
+        pascalName: pascalCase(name),
+        rawName: name,
+    }, { cwd: root });
+    console.log(kleur.green("\n  Action added."), kleur.dim(`Dispatch with actions.dispatch(Actions.${pascalCase(name)}).`));
+}