@twobirds/microcomponents 0.11.0 → 0.13.0

package/README.md

@@ -100,20 +100,25 @@ pnpm run cli -- new my-card --target-html --target-css --dry-run
 ```bash
 pnpm run cli -- create --namespace mc --dir mc-app
 # created mc-app/package.json
+# created mc-app/tsconfig.json
+# created mc-app/tsconfig.test.json
+# created mc-app/vitest.config.ts
 # created mc-app/opencode.jsonc
+# created mc-app/.opencode/skills/components/SKILL.md
 # created mc-app/src/index.html
 # created mc-app/src/index-dev.html
 # created mc-app/src/mc/app.ts
-# created mc-app/src/mc/app.target.html
+# created mc-app/src/mc/app.html
 # created mc-app/src/mc/app.target.css
 # created mc-app/src/mc/bundle.ts
+# created mc-app/test/mc/app.spec.ts
 # ...
 # project "mc" created in mc-app/ — run: cd mc-app && pnpm install && pnpm dev
 ```
 
-`pnpm dev` runs `mc dev`: `tsc -w` plus a `node:http` server serving `build/`, so a saved component reaches the browser through `autoload()` with nothing bundled; companion assets are mirrored into `build/` next to the compiled component, and the library is resolved through an import map to the served `microcomponents.min.js`. `pnpm build` runs `tsc` then `mc bundle`, which emits one `bundle.js` into `public/` with every companion asset inlined by the CLI bundler, the concatenated `bundle.css`, and the production shell — a single script tag, no autoloader. `pnpm preview` serves `public/`. `opencode.jsonc` registers the MCP server, so opencode picks it up when you open the project.
+`pnpm dev` runs `mc dev`: `tsc -w` plus a `node:http` server serving `build/`, so a saved component reaches the browser through `autoload()` with nothing bundled; companion assets and plain `.js` components are mirrored into `build/` next to the compiled component, and the server rewrites the `@twobirds/microcomponents` specifier in the JS it serves to the `/microcomponents.min.js` it answers, so the page carries no import map. `pnpm build` runs `tsc` then `mc bundle`, which emits one `bundle.js` into `public/` with every companion asset inlined by the CLI bundler, the concatenated `bundle.css`, and the production shell — a single script tag, no autoloader. `pnpm preview` serves `public/`. `pnpm typecheck` checks `src/` and `test/` in two contexts, and `pnpm test` runs the specs under vitest in jsdom, so component class code executes against a real DOM. `opencode.jsonc` registers the MCP server, so opencode picks it up when you open the project.
 
-The namespace (1 to 4 lowercase letters) becomes the `src/<namespace>/` folder and the first segment of every component tag, so `mc` is the home of tags like `<mc-app>`. Because the dev shell is the autoload base, `import.meta.url` + the tag-to-path rule resolves `<mc-app>` to `build/mc/app.js` — the compiled starter. New components are served automatically by the autoloader, but the bundle walks one entry, so add each one to `src/<namespace>/bundle.ts`. `--dir` defaults to the namespace, `--dry-run` prints the plan without touching disk.
+The namespace (lowercase letters and digits, starting with a letter, any length) becomes the `src/<namespace>/` folder and the first segment of every component tag, so `mc` is the home of tags like `<mc-app>`. The project owns its namespace, so length is allowed; past 5 characters `mc create` warns and asks for confirmation, and `--yes` skips the prompt for scripted runs. Because the dev shell is the autoload base, `import.meta.url` + the tag-to-path rule resolves `<mc-app>` to `build/mc/app.js` — the compiled starter. New components are served automatically by the autoloader, but the bundle walks one entry, so add each one to `src/<namespace>/bundle.ts`. `--dir` defaults to the namespace, `--dry-run` prints the plan without touching disk.
 
 The project is written into a folder of its own, so its files are reported under that folder (`mc-app/src/mc/app.ts`) — the path you can find from the directory you ran the command in, not relative to the project root.
 
@@ -121,7 +126,7 @@ Existing files are never overwritten silently: every target is checked before th
 
 ```bash
 pnpm run cli -- create --namespace mc
-# refusing to overwrite 10 existing file(s):
+# refusing to overwrite 16 existing file(s):
 #         mc/package.json
 #         mc/src/mc/app.ts
 #         ...
@@ -134,11 +139,16 @@ Once installed from npm the same command is available as `mc` (and as `microcomp
 ```bash
 mc new my-card [--css] [--html] [--target-html] [--shadow-html] [--target-css] [--shadow-css] [--js] [--dir <path>] [--force] [--dry-run]
 mc create --namespace <ns> [--dir <path>] [--force] [--dry-run]
+mc dev [--port <n>] [--host <addr>]
+mc bundle
+mc preview [--port <n>] [--host <addr>]
 mc clean
 mc check
 mc --version
 ```
 
+`dev` serves `build/` with `tsc -w` running, and `preview` serves `public/`. Both bind to `127.0.0.1` by default, so the served files are not reachable off the machine; pass `--host 0.0.0.0` (or an interface address) when you want the LAN to reach them.
+
 `clean` and `check` are thin wrappers around the package.json scripts of the same name, so the scripts remain the single source of truth for what they do — `mc check` type-checks every project context (lib, cli, mcp, test, demo, node) and exits with the script's exit code. `mc --version` (`-v`) prints the version of the package the CLI ships in, read from its own package.json, so it reports the installed library, not the version of the project the command runs in.
 
 Nothing has to be installed to run it once — `npx` fetches the package into its own cache and runs the bin from there:

package/dist/cli/bundle.d.ts

@@ -4,8 +4,9 @@
 
  The chain is `src/` → `build/` → `public/`. The scaffolded `build` script runs
  `tsc -p tsconfig.json` (so `build/` holds one `.js` per component at its
- autoload path), then `mc bundle` mirrors the companion assets into `build/`,
- walks the barrel entry named by `src/bundle.json` through {@link bundleEntry}
+ autoload path), then `mc bundle` mirrors the files `tsc` does not compile —
+ companion assets and plain `.js` components — into `build/`, walks the barrel
+ entry named by `src/bundle.json` through {@link bundleEntry}
  (inlining every `static assets`), rewrites the `@twobirds/microcomponents`
  specifier to the self-contained `microcomponents.min.js` shipped next to the
  bundle, concatenates the plain `.css` token presets into `bundle.css`, and
@@ -28,29 +29,35 @@ export interface BundleConfig {
     outDir?: string;
 }
 /**
- * Whether a file is a companion asset to mirror into `build/`.
+ * Whether a file in `src/` is copied verbatim into `build/`. Companion assets
+ * (`.css`, `.html`, `.json`) sit next to their compiled `.js`, and a plain `.js`
+ * component (`mc new --js`) is copied as it is: `tsc` compiles only `.ts`, so plain
+ * JS reaches the autoloader by copying, not by compiling. The page shells are not
+ * mirrored by this rule — `mc dev` copies the dev shell itself.
  *
  * @example
  * ```ts
- * isCompanion('app.target.html');  // true
- * isCompanion('index.html');       // false
+ * isMirrored('app.target.html');  // true
+ * isMirrored('app.js');           // true — a plain JS component
+ * isMirrored('index.html');       // false
  * ```
  * @param name Basename of the file.
  */
-export declare function isCompanion(name: string): boolean;
+export declare function isMirrored(name: string): boolean;
 /**
- * Mirror companion assets (`.css`, `.html`, `.json`) from `src/` into `build/`,
- * preserving the tree, so the bundler reads each asset next to its compiled `.js`.
+ * Mirror the files `tsc` does not compile (`.css`, `.html`, `.json`, `.js`) from
+ * `src/` into `build/`, preserving the tree, so the bundler reads each asset and
+ * each plain JS component next to its compiled `.js`.
  *
  * @example
  * ```ts
- * await mirrorCompanions('<root>/src', '<root>/build');
+ * await mirrorSources('<root>/src', '<root>/build');
  * ```
  * @param srcDir Source root to walk.
  * @param buildDir Folder to write into.
  * @param rel Path of the walked directory relative to `srcDir`.
  */
-export declare function mirrorCompanions(srcDir: string, buildDir: string, rel?: string): Promise<void>;
+export declare function mirrorSources(srcDir: string, buildDir: string, rel?: string): Promise<void>;
 /**
  * Collect the plain `.css` token presets under `src/`, skipping the companion
  * `.target.css` / `.shadow.css` files, which the bundler inlines into the JS.
@@ -67,14 +74,17 @@ export declare function collectPlainCss(srcDir: string, rel?: string, found?: st
 /**
  * Rewrite the library specifier in a bundled module to the self-contained bundle
  * shipped next to it, so the browser can resolve `@twobirds/microcomponents`
- * without a bare-specifier import map.
+ * without a bare-specifier import map. Subpath imports resolve to the same module,
+ * so the library stays one instance. This is the single source of truth for the
+ * rule: the bundler uses the relative target, the dev server passes its served URL.
  *
- * @example Turns the package specifier into a relative path.
+ * @example Turns the package specifier into a relative path, leaves others alone.
  * ```ts
  * rewriteLibrarySpecifier("import { DC } from '@twobirds/microcomponents';");
+ * rewriteLibrarySpecifier("import { z } from 'zod';"); // unchanged
  * ```
  * @param code Bundled module source.
- * @param target Relative specifier to point the import at.
+ * @param target Specifier to point the import at.
  */
 export declare function rewriteLibrarySpecifier(code: string, target?: string): string;
 /**

package/dist/cli/bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../src/cli/bundle.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;GAeG;AAMH;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAKD;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGjD;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAYhG;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CACpC,MAAM,EAAE,MAAM,EACd,GAAG,SAAK,EACR,KAAK,GAAE,MAAM,EAAO,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC,CAUnB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,SAA6B,GAAG,MAAM,CAEjG;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAClC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/D,OAAO,CAAC,MAAM,EAAE,CAAC,CAkCnB;AAED;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC9B,WAAW,GAAE,MAAsB,EACnC,KAAK,GAAE,MAAuE,GAC5E,OAAO,CAAC,MAAM,CAAC,CAIjB"}
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../src/cli/bundle.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;GAgBG;AAMH;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAKD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGhD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAY7F;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CACpC,MAAM,EAAE,MAAM,EACd,GAAG,SAAK,EACR,KAAK,GAAE,MAAM,EAAO,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC,CAUnB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,SAA6B,GAAG,MAAM,CAEjG;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAClC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/D,OAAO,CAAC,MAAM,EAAE,CAAC,CAmCnB;AAED;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC9B,WAAW,GAAE,MAAsB,EACnC,KAAK,GAAE,MAAuE,GAC5E,OAAO,CAAC,MAAM,CAAC,CAIjB"}

package/dist/cli/create.d.ts

@@ -8,8 +8,10 @@ runtime autoload loader uses, so the scaffold and the runtime can never disagree
 where a component lives.
 
 The namespace is the first segment of every component tag, so `xxx` makes `src/xxx/`
-the home of tags like `<xxx-app>` (tagPath `xxx-app` → `xxx/app`). The generated
-environment follows the three-path chain the library's own demos use: `src/` holds the
+the home of tags like `<xxx-app>` (tagPath `xxx-app` → `xxx/app`). The project owns its
+namespace, so it can be any length: `isLongNamespace` flags the ones past
+`LONG_NAMESPACE` (5) for the CLI to warn about and confirm before anything is written.
+The generated environment follows the three-path chain the library's own demos use: `src/` holds the
 authored sources, `build/` receives the per-file `tsc` output that the dev server
 serves through `autoload()`, and `public/` receives the bundled production site. Because
 the dev shell is the autoload base, `import.meta.url` + `tagPath('xxx-app')` resolves to
@@ -18,17 +20,35 @@ the dev shell is the autoload base, `import.meta.url` + `tagPath('xxx-app')` res
 @module CLI/Project
 */
 /**
-Whether a string is a valid project namespace: 1 to 4 lowercase letters.
+Whether a string is a valid project namespace: lowercase letters and digits, starting
+with a letter, any length. The project owns its namespace, so length is the user's
+call — {@link isLongNamespace} flags the ones worth confirming before writing.
 
 @example
 ```ts
 console.log(isValidNamespace('mc'));
-console.log(isValidNamespace('mcxyz'));
-console.log(isValidNamespace('toolong'));
+console.log(isValidNamespace('microcomponents'));
+console.log(isValidNamespace('Shop'));
 ```
 @param ns - Candidate namespace.
 */
 export declare function isValidNamespace(ns: string): boolean;
+/** A namespace longer than this is confirmed before the project is written. */
+export declare const LONG_NAMESPACE = 5;
+/**
+Whether a namespace is long enough to warn about. The namespace is the project's own
+and the first segment of every component tag, so a long one lands in every tag, every
+folder path, and every bundle import.
+
+@example
+```ts
+console.log(isLongNamespace('mc'));              // false
+console.log(isLongNamespace('shop'));            // false
+console.log(isLongNamespace('microcomponents')); // true
+```
+@param ns - Candidate namespace.
+*/
+export declare function isLongNamespace(ns: string): boolean;
 /** Result of {@link scaffoldProject}. */
 export interface ProjectResult {
     /** Files to write, keyed by path relative to the project root. */
@@ -45,9 +65,9 @@ const { namespace, files } = scaffoldProject('mc');
 console.log(namespace);
 console.log(Object.keys(files));
 ```
-@param namespace - 1 to 4 lowercase letters; becomes the `src/<namespace>/` folder and
-the first segment of every component tag.
-@throws If `namespace` is not 1 to 4 lowercase letters.
+@param namespace - lowercase letters and digits, starting with a letter, any length;
+becomes the `src/<namespace>/` folder and the first segment of every component tag.
+@throws If `namespace` is not lowercase letters and digits starting with a letter.
 */
 export declare function scaffoldProject(namespace: string): ProjectResult;
 //# sourceMappingURL=create.d.ts.map

package/dist/cli/create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/cli/create.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;EAkBE;AAUF;;;;;;;;;;EAUE;AACF,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,yCAAyC;AACzC,MAAM,WAAW,aAAa;IAC7B,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;EAYE;AACF,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,CA0BhE"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/cli/create.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;EAoBE;AAUF;;;;;;;;;;;;EAYE;AACF,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,+EAA+E;AAC/E,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC;;;;;;;;;;;;EAYE;AACF,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,yCAAyC;AACzC,MAAM,WAAW,aAAa;IAC7B,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;EAYE;AACF,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,CA6BhE"}

package/dist/cli/dev.d.ts

@@ -3,12 +3,14 @@
 
  A minimal `node:http` static server rooted at the project's `build/` folder, so
  a saved component reaches the browser through `autoload()` with no bundling. It
- mirrors companion assets from `src/` into `build/` (on startup and on every
- change), runs `tsc -w` for the lifetime of the server, serves companion
+ mirrors the files `tsc` does not compile — companion assets and plain `.js`
+ components — from `src/` into `build/` (on startup and on every change), runs
+ `tsc -w` for the lifetime of the server, serves companion
  `.css` / `.html` / `.json` as raw text (so `loadAssets()` receives markup it
- can use), redirects `/` to the autoload shell (`index-dev.html`), and serves
- the self-contained library at `/microcomponents.min.js` — the target of the
- import map in the dev shell.
+ can use), redirects `/` to the autoload shell (`index-dev.html`), serves the
+ self-contained library at `/microcomponents.min.js`, and rewrites the
+ `@twobirds/microcomponents` specifier in served JS to that URL, so a compiled
+ component resolves the library with no import map in the page.
 
  There is no HMR: a page reload picks up the recompiled component.
 
@@ -45,8 +47,9 @@ export declare function mimeFor(name: string): string;
  */
 export declare function resolveTarget(url: string, buildRoot: string, minJs: string): string | undefined;
 /**
- * Mirror companion assets from `src/` into `build/`, preserving the tree, so the
- * served folder stays autoload-ready.
+ * Mirror the files `tsc` does not compile — companion assets and plain `.js`
+ * components — from `src/` into `build/`, preserving the tree, so the served
+ * folder stays autoload-ready.
  *
  * @example
  * ```ts
@@ -81,7 +84,9 @@ export declare function createDevServer(projectRoot: string, options: {
  * @param projectRoot Project root (defaults to the current directory).
  * @param minJs Path of `microcomponents.min.js` (defaults to this package's `dist/`).
  * @param port Dev-server port.
+ * @param host Bind address. Defaults to loopback, so a dev server serving source files is
+ *   not reachable off the machine. Pass an interface address to serve the LAN.
  * @returns The process exit code (the server keeps running until killed).
  */
-export declare function runDev(projectRoot?: string, minJs?: string, port?: number): Promise<number>;
+export declare function runDev(projectRoot?: string, minJs?: string, port?: number, host?: string): Promise<number>;
 //# sourceMappingURL=dev.d.ts.map

package/dist/cli/dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/cli/dev.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAsC,KAAK,MAAM,EAAuB,MAAM,WAAW,CAAC;AASjG;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO5C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAO/F;AA8BD;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAW/F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC9B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACtC,MAAM,CAKR;AAED;;;;;;;;GAQG;AAEH,wBAAsB,MAAM,CAC3B,WAAW,GAAE,MAAsB,EACnC,KAAK,GAAE,MAAuE,EAC9E,IAAI,GAAE,MAAa,GACjB,OAAO,CAAC,MAAM,CAAC,CA8BjB"}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/cli/dev.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EAAsC,KAAK,MAAM,EAAuB,MAAM,WAAW,CAAC;AASjG;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO5C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAO/F;AAkCD;;;;;;;;;;;;GAYG;AACH,wBAAsB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAW/F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC9B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACtC,MAAM,CAKR;AAED;;;;;;;;;;GAUG;AAEH,wBAAsB,MAAM,CAC3B,WAAW,GAAE,MAAsB,EACnC,KAAK,GAAE,MAAuE,EAC9E,IAAI,GAAE,MAAa,EACnB,IAAI,GAAE,MAAoB,GACxB,OAAO,CAAC,MAAM,CAAC,CAiCjB"}

package/dist/cli/dispatch.d.ts

@@ -13,7 +13,10 @@ so the command works in any consumer project.
 */
 export type Runner = (script: string, options?: {
     port?: number;
+    host?: string;
 }) => Promise<number>;
+/** Asks the user to confirm a namespace long enough to be worth a second look. */
+export type Confirmer = (namespace: string) => Promise<boolean>;
 /**
 Runs a package.json script through pnpm and resolves with its exit code.
 
@@ -29,11 +32,13 @@ const code = await runScript('check');
 */
 export declare function runScript(script: string, options?: {
     port?: number;
+    host?: string;
 }): Promise<number>;
 /**
 Parses `argv` and routes it to the matching command, returning a process exit
 code. `run` is injectable so the script-wrapping commands can be tested without
-spawning anything.
+spawning anything, and `confirm` is injectable so the long-namespace prompt can be
+tested without a terminal.
 
 @example
 ```ts
@@ -46,6 +51,9 @@ const code = await main(['clean'], async (script) => {
 ```ts
 const code = await main(['--version']);
 ```
+@param argv - Arguments to route (usually `process.argv.slice(2)`).
+@param run - Runs a package.json script (defaults to {@link runScript}).
+@param confirm - Confirms a long namespace (defaults to the terminal prompt).
 */
-export declare function main(argv: string[], run?: Runner): Promise<number>;
+export declare function main(argv: string[], run?: Runner, confirm?: Confirmer): Promise<number>;
 //# sourceMappingURL=dispatch.d.ts.map

package/dist/cli/dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../src/cli/dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;EAYE;AAoEF,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAwHtF;;;;;;;;;;;;EAYE;AACF,wBAAsB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAW5F;AAED;;;;;;;;;;;;;;;;EAgBE;AACF,wBAAsB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,GAAE,MAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAsHnF"}
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../src/cli/dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;EAYE;AAwEF,MAAM,MAAM,MAAM,GAAG,CACpB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,KACtC,OAAO,CAAC,MAAM,CAAC,CAAC;AAErB,kFAAkF;AAClF,MAAM,MAAM,SAAS,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAyIhE;;;;;;;;;;;;EAYE;AACF,wBAAsB,SAAS,CAC9B,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACxC,OAAO,CAAC,MAAM,CAAC,CAajB;AAED;;;;;;;;;;;;;;;;;;;;EAoBE;AACF,wBAAsB,IAAI,CACzB,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,GAAE,MAAkB,EACvB,OAAO,GAAE,SAA4B,GACnC,OAAO,CAAC,MAAM,CAAC,CA4IjB"}