march-hare 0.12.1 → 0.13.1

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,8 +1,8 @@
-import { PendingCall } from '../../../resource/index';
+import { Invocation } from '../../../resource/index.js';
 import * as React from "react";
 /**
  * Per-`<Boundary>` registry for `.coalesce(token)` sharing. Outer map
- * keys on the `PendingCall.run` function identity (stable per Resource
+ * keys on the `Invocation.run` function identity (stable per Resource
  * via the `build()` closure); inner map keys on
  * `${paramsKey}|${coalesceKey(token)}`. While an entry exists every
  * caller awaiting `.coalesce(token)` for the same Resource + params +
@@ -14,7 +14,7 @@ import * as React from "react";
  *
  * @internal
  */
-export type Sharing = WeakMap<PendingCall["run"], Map<string, Promise<unknown>>>;
+export type Sharing = WeakMap<Invocation<unknown, object>["run"], Map<string, Promise<unknown>>>;
 /**
  * React context exposing the per-Boundary sharing registry. The
  * fallback is a fresh `WeakMap` used when `useSharing()` is read

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,13 +1,13 @@
-import { Props } from './types';
+import { Props } from './types.js';
 import * as React from "react";
 /**
  * Low-level boundary primitive. Wraps children with the Broadcaster,
  * Env, and Tasks providers required by every March Hare hook.
  *
  * Most applications should reach for {@link App} instead —
- * `App<S>({ env })` returns a typed `app.Boundary` along with
+ * `App<E>({ env })` returns a typed `app.Boundary` along with
  * matching `useContext` / `useEnv` / `Resource` factories that all
- * close over the App's inferred env shape `S`. The bare `Boundary`
+ * close over the App's inferred env shape `E`. The bare `Boundary`
  * is exposed for advanced or library-internal use where the loose
  * Env record type is sufficient.
  *

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.
@@ -18,7 +18,7 @@ import type * as React from "react";
 export type Props = {
     /**
      * Initial value of the per-Boundary {@link Env}. Prefer `App({ env })`
-     * &mdash; it infers the Env shape `S` and threads it through
+     * &mdash; it infers the Env shape `E` and threads it through
      * `app.useContext`, `app.useEnv`, and `app.Resource`, so handler
      * `context.env` is typed accordingly. Pass `env` directly here only
      * for advanced cases where the loose record type is sufficient.

package/dist/cache/index.d.ts

@@ -1,19 +1,29 @@
-import { Adapter, Stored } from './types';
-export type { Adapter, Encoded } from './types';
+import { Adapter, Stored } from './types.js';
+export type { Adapter, Encoded } from './types.js';
 /**
  * Persistence-aware cache for a single {@link Resource}. Wraps a
- * synchronous {@link Adapter} (localStorage, MMKV, chrome.storage with a
- * sync facade, etc.) and traffics in {@link Stored} envelopes —
- * storage entries serialise as {@link Encoded}`<T>` so the
- * `Temporal.Instant` timestamp survives the string round-trip and
- * `.exceeds({...})` can short-circuit on the persisted timestamp after
- * a reload.
+ * **strictly synchronous** {@link Adapter} (localStorage, MMKV,
+ * chrome.storage with a sync facade, etc.) and traffics in {@link
+ * Stored} envelopes &mdash; storage entries serialise as {@link
+ * Encoded}`<T>` so the `Temporal.Instant` timestamp survives the
+ * string round-trip and `.exceeds({...})` can short-circuit on the
+ * persisted timestamp after a reload.
+ *
+ * Every method on the Cache is sync &mdash; the model-literal sync
+ * read has no place to wait, so the adapter contract foregoes
+ * `Promise` entirely. Async backends (IndexedDB, AsyncStorage,
+ * `chrome.storage.local`) need a sync facade hydrated at app entry;
+ * see `recipes/storage.md` for the pattern. React Native projects
+ * should reach for {@link https://github.com/mrousavy/react-native-mmkv
+ * `react-native-mmkv`} &mdash; it's synchronous out of the box and
+ * drops straight into the Adapter contract.
  *
  * Call with no arguments for an in-memory cache scoped to this
- * instance &mdash; useful for tests, ephemeral state, or when you want a
- * first-class cache object to share between Resources without
+ * instance &mdash; useful for tests, ephemeral state, or when you
+ * want a first-class cache object to share between Resources without
  * persistence. Pass an {@link Adapter} to back the cache with a
- * persistent store.
+ * persistent store; when supplied, the adapter is the **only** tier
+ * &mdash; the Cache does not maintain a separate in-memory mirror.
  *
  * @example
  * ```ts
@@ -36,9 +46,55 @@ export type { Adapter, Encoded } from './types';
  * ```
  */
 export type Cache = {
+    /**
+     * Returns the {@link Stored} envelope for `key`. The envelope is
+     * `empty()` when nothing is persisted; otherwise it carries the
+     * decoded payload and the timestamp recorded at write-time.
+     *
+     * @template T The payload type expected at `key`.
+     * @param key Cache slot identifier &mdash; usually the JSON-stringified
+     *   call-site params, prefixed by the Resource's namespace.
+     */
     get<T>(key: string): Stored<T>;
-    set<T>(key: string, value: Stored<T>): boolean;
+    /**
+     * Writes `value` to `key`. Skipped when the envelope has no concrete
+     * payload (e.g. an `empty()` slot), since there is nothing meaningful
+     * to persist. Serialisation, quota errors, and unserialisable payloads
+     * are swallowed &mdash; writes are best-effort.
+     *
+     * @template T The payload type contained in `value`.
+     * @param key Cache slot identifier &mdash; usually the JSON-stringified
+     *   call-site params, prefixed by the Resource's namespace.
+     * @param value Stored envelope carrying the payload and its
+     *   write-time `Temporal.Instant`.
+     */
+    set<T>(key: string, value: Stored<T>): void;
+    /**
+     * Drops a single cache slot. Best-effort &mdash; backing-store errors
+     * are swallowed.
+     *
+     * @param key Cache slot identifier.
+     */
     remove(key: string): void;
+    /**
+     * Drops every cache slot in the backing store. Best-effort &mdash;
+     * backing-store errors are swallowed.
+     */
     clear(): void;
+    /**
+     * Returns every key currently held by the backing store. Used by
+     * partial-match eviction (`evict(where)`) to iterate slots whose
+     * stored params satisfy a `where` pattern.
+     */
+    keys(): Iterable<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.
+ *
+ * @param adapter Optional synchronous backing store (localStorage, MMKV,
+ *   or a custom sync facade). Omit for an in-memory cache scoped to
+ *   this instance.
+ */
 export declare function Cache(adapter?: Adapter): 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
@@ -18,37 +18,51 @@ export type Encoded<T> = {
  * facade, etc.) and pass to {@link Cache}. The adapter shuttles raw
  * strings; JSON encoding and `Temporal.Instant` round-tripping happen
  * inside the Cache wrapper, so adapters stay trivial.
+ *
+ * **Every method is strictly synchronous.** The library never awaits
+ * adapter calls &mdash; the model-literal sync read has no place to
+ * wait. Async backends (IndexedDB, AsyncStorage, chrome.storage.local)
+ * need a sync facade hydrated at app entry; see `recipes/storage.md`
+ * for the pattern. React Native projects should use
+ * {@link https://github.com/mrousavy/react-native-mmkv `react-native-mmkv`}
+ * &mdash; it's sync out of the box and drops straight into this
+ * contract.
  */
 export type Adapter = {
     /**
      * Return the raw string stored under `key`, or `null` when no entry
-     * exists. The Cache wrapper handles JSON parsing and `Temporal.Instant`
-     * round-tripping, so this stays a plain string getter. Treat any
-     * read-time error (decryption, IPC, etc.) as "not found" and return
-     * `null` &mdash; the Cache falls through to its next fallback rather
-     * than crashing the render.
+     * exists. **Strictly sync.** Treat any read-time error (decryption,
+     * IPC, etc.) as "not found" and return `null` &mdash; the Cache will
+     * fall back to its empty state.
      */
     readonly get: (key: string) => string | null;
     /**
-     * Persist the raw string `value` under `key`. The Cache guarantees
-     * `value` is a JSON-encoded `{ data, at }` envelope produced by a
-     * resolved snapshot &mdash; never a placeholder. Throwing is fine on
-     * quota, private mode, sandboxed iframes, etc.; the Cache catches and
-     * swallows so a write failure can't poison an already-resolved fetch.
+     * Persist the raw string `value` under `key`. **Strictly sync.**
+     * Throwing is fine on quota, private mode, sandboxed iframes, etc.;
+     * the Cache catches and swallows so a failure can't poison an
+     * already-resolved fetch.
      */
     readonly set: (key: string, value: string) => void;
     /**
-     * Drop the entry at `key`. Idempotent &mdash; calling `remove` for a
-     * key that isn't present must not throw.
+     * Drop the entry at `key`. **Strictly sync.** Idempotent &mdash;
+     * calling `remove` for a key that isn't present must not throw.
      */
     readonly remove: (key: string) => void;
     /**
-     * Wipe every entry this adapter can see. On a shared backend such as
-     * `localStorage` this means the whole origin &mdash; third-party SDK
-     * state, dismissed banners, route hints, etc. all go with it. Adapter
-     * authors should either delegate to the backend's native clear
-     * (accepting that scope) or namespace by key prefix and remove only
-     * their own.
+     * Wipe every entry this adapter can see. **Strictly sync.** On a
+     * shared backend such as `localStorage` this means the whole origin
+     * &mdash; third-party SDK state, dismissed banners, route hints, etc.
+     * all go with it. Adapter authors should either delegate to the
+     * backend's native clear (accepting that scope) or namespace by key
+     * prefix and remove only their own.
      */
     readonly clear: () => void;
+    /**
+     * Optional enumerator over every key the adapter currently knows
+     * about. **Strictly sync** when implemented &mdash; partial-match
+     * evictions sweep these keys in the current tick. `localStorage`
+     * exposes this via `Object.keys(localStorage)`; MMKV via
+     * `getAllKeys()`.
+     */
+    readonly keys?: () => Iterable<string>;
 };

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)}).`));
+}

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

@@ -0,0 +1,55 @@
+import path from "node:path";
+import kleur from "kleur";
+import { pascalCase } from "change-case";
+import { scaffold } from "../../runner/index.js";
+import { askName, askConfirm, pickDirectory, requireProjectRoot, } from "../../prompt/index.js";
+async function resolveStateful(flags) {
+    if (flags.stateful !== undefined)
+        return flags.stateful !== false;
+    if (flags.presentational !== undefined)
+        return flags.presentational === false;
+    return askConfirm("Does this feature own state and actions?", true);
+}
+export async function newFeature({ positional, flags, }) {
+    const root = requireProjectRoot();
+    const name = positional[0] || (await askName("Feature name (kebab-case)"));
+    const stateful = await resolveStateful(flags);
+    const action = stateful ? "stateful" : "presentational";
+    await scaffold("feature", action, { name, pascalName: pascalCase(name) }, { cwd: root });
+    console.log(kleur.green("\n  Feature ready."), kleur.dim(`Mount it inside a page with <${pascalCase(name)} />.`));
+}
+export async function unit({ positional }) {
+    const root = requireProjectRoot();
+    const featuresRoot = path.join(root, "src", "features");
+    const name = positional[0] || (await pickDirectory("feature", featuresRoot));
+    await scaffold("feature", "unit", { name, pascalName: pascalCase(name) }, { cwd: root });
+}
+export async function action({ positional, flags, }) {
+    const root = requireProjectRoot();
+    const featuresRoot = path.join(root, "src", "features");
+    const feature = positional[0] || (await pickDirectory("feature", featuresRoot));
+    const name = positional[1] ||
+        (typeof flags.name === "string" ? flags.name : undefined) ||
+        (await askName("Action name (PascalCase)"));
+    await scaffold("feature", "action", {
+        feature,
+        name: pascalCase(name),
+        pascalName: pascalCase(name),
+        rawName: name,
+    }, { cwd: root });
+}
+export async function multicast({ positional, flags, }) {
+    const root = requireProjectRoot();
+    const featuresRoot = path.join(root, "src", "features");
+    const feature = positional[0] || (await pickDirectory("feature", featuresRoot));
+    const name = positional[1] ||
+        (typeof flags.name === "string" ? flags.name : undefined) ||
+        (await askName("Multicast action (PascalCase)"));
+    await scaffold("feature", "multicast", {
+        feature,
+        featurePascal: pascalCase(feature),
+        name: pascalCase(name),
+        pascalName: pascalCase(name),
+        rawName: name,
+    }, { cwd: root });
+}

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

@@ -0,0 +1,89 @@
+import * as init from "./init/index.js";
+import * as app from "./app/index.js";
+import * as feature from "./feature/index.js";
+import * as shared from "./shared/index.js";
+export const tree = {
+    init: {
+        leaf: true,
+        description: "Bootstrap a new March Hare project",
+        run: init.run,
+    },
+    app: {
+        leaf: false,
+        description: "Manage the host (pages, integration tests, actions)",
+        children: {
+            new: {
+                leaf: true,
+                description: "Create a new page under app/pages/",
+                run: app.newPage,
+            },
+            integration: {
+                leaf: true,
+                description: "Add an integration test for an existing page",
+                run: app.integration,
+            },
+            action: {
+                leaf: true,
+                description: "Add a new action handler to an existing page",
+                run: app.action,
+            },
+        },
+    },
+    feature: {
+        leaf: false,
+        description: "Manage features (slices, unit tests, actions)",
+        children: {
+            new: {
+                leaf: true,
+                description: "Create a new feature slice",
+                run: feature.newFeature,
+            },
+            unit: {
+                leaf: true,
+                description: "Add a unit test next to an existing feature",
+                run: feature.unit,
+            },
+            action: {
+                leaf: true,
+                description: "Add a new action handler to an existing feature",
+                run: feature.action,
+            },
+            multicast: {
+                leaf: true,
+                description: "Add a multicast action to an existing feature's Scope",
+                run: feature.multicast,
+            },
+        },
+    },
+    shared: {
+        leaf: false,
+        description: "Manage shared building blocks",
+        children: {
+            component: {
+                leaf: true,
+                description: "Create a new shared component",
+                run: shared.component,
+            },
+            resource: {
+                leaf: true,
+                description: "Create a new shared resource",
+                run: shared.resource,
+            },
+            util: {
+                leaf: true,
+                description: "Create a new shared utility",
+                run: shared.util,
+            },
+            type: {
+                leaf: true,
+                description: "Add a shared type/payload/broadcast namespace",
+                run: shared.type,
+            },
+            unit: {
+                leaf: true,
+                description: "Add a unit test next to an existing shared module",
+                run: shared.unit,
+            },
+        },
+    },
+};

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

@@ -0,0 +1,29 @@
+import path from "node:path";
+import process from "node:process";
+import kleur from "kleur";
+import { pascalCase } from "change-case";
+import { scaffold } from "../../runner/index.js";
+import { askName, askDescription } from "../../prompt/index.js";
+export async function run({ positional, flags }) {
+    const rawName = positional[0] ||
+        (typeof flags.name === "string" ? flags.name : undefined) ||
+        (await askName("Project name", "my-app"));
+    const description = (typeof flags.description === "string" ? flags.description : undefined) ||
+        (await askDescription("Short description", `A March Hare project: ${rawName}`));
+    const apiBase = (typeof flags.apiBase === "string" ? flags.apiBase : undefined) ||
+        (await askDescription("Default API base URL", "https://api.example.com"));
+    const cwd = path.resolve(process.cwd(), rawName);
+    const env = pascalCase(rawName);
+    console.log();
+    console.log(kleur.bold(`  Scaffolding ${kleur.magenta(rawName)} into ${kleur.gray(cwd)}`));
+    console.log();
+    await scaffold("init", "new", { name: rawName, description, apiBase, env }, { cwd });
+    console.log();
+    console.log(kleur.green("  Project ready."));
+    console.log();
+    console.log(kleur.bold("  Next steps:"));
+    console.log(`    cd ${rawName}`);
+    console.log("    yarn install");
+    console.log("    yarn dev");
+    console.log();
+}

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

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import path from "node:path";
+import kleur from "kleur";
+import { select } from "@inquirer/prompts";
+import { pascalCase } from "change-case";
+import { scaffold } from "../../runner/index.js";
+import { askName, pickDirectory, requireProjectRoot, } from "../../prompt/index.js";
+const sharedSubdirs = {
+    components: "component",
+    resources: "resource",
+    utils: "util",
+};
+export async function component({ positional }) {
+    const root = requireProjectRoot();
+    const name = positional[0] || (await askName("Component name (kebab-case)"));
+    await scaffold("shared", "component", { name, pascalName: pascalCase(name) }, { cwd: root });
+}
+export async function resource({ positional }) {
+    const root = requireProjectRoot();
+    const name = positional[0] || (await askName("Resource name (kebab-case)"));
+    await scaffold("shared", "resource", { name, pascalName: pascalCase(name) }, { cwd: root });
+    console.log(kleur.dim(`\n  Remember to re-export from src/shared/resources/index.ts: export * as ${name.replace(/-/g, "")} from "./${name}/index.ts";`));
+}
+export async function util({ positional }) {
+    const root = requireProjectRoot();
+    const name = positional[0] || (await askName("Util name (kebab-case)"));
+    await scaffold("shared", "util", { name, pascalName: pascalCase(name) }, { cwd: root });
+}
+export async function type({ positional, flags }) {
+    const root = requireProjectRoot();
+    const kind = positional[0] ||
+        (typeof flags.kind === "string" ? flags.kind : undefined) ||
+        (await select({
+            message: "Kind of type to add",
+            choices: [
+                { name: "Payload — cross-feature data type", value: "payload" },
+                { name: "Broadcast — global action class", value: "broadcast" },
+            ],
+        }));
+    const name = positional[1] || (await askName(`${kind} name (kebab-case)`));
+    await scaffold("shared", `type-${kind}`, { name, pascalName: pascalCase(name) }, { cwd: root });
+}
+export async function unit({ positional }) {
+    const root = requireProjectRoot();
+    const sharedRoot = path.join(root, "src", "shared");
+    const kindKey = positional[0] ||
+        (await select({
+            message: "Which kind of shared module?",
+            choices: Object.keys(sharedSubdirs)
+                .filter((key) => fs.existsSync(path.join(sharedRoot, key)))
+                .map((key) => ({ name: key, value: key })),
+        }));
+    const dir = path.join(sharedRoot, kindKey);
+    const name = positional[1] || (await pickDirectory(kindKey, dir));
+    await scaffold("shared", `unit-${sharedSubdirs[kindKey]}`, { name, pascalName: pascalCase(name), kind: kindKey }, { cwd: root });
+}