@habemus-papadum/aiui 0.2.0 → 0.5.0

package/dist/util/chrome.d.ts

@@ -19,10 +19,14 @@ type ChromeFlags = Pick<AiuiArgs, "chrome" | "noChrome" | "chromeProfile" | "chr
  * npx download + Chrome launch), with `--aiui-no-chrome`, or with
  * `chrome.enabled: false` in config. `--aiui-chrome` forces it on even under
  * CI; `chrome.enabled: true` merely restates the default and does not.
+ *
+ * Deliberately gated on CI alone, not the wider `isHeadless` check from
+ * aiui-util: on a headless-but-interactive box (SSH into a dev machine)
+ * the MCP still works — it just launches/attaches a headless-capable Chrome —
+ * whereas *opening a page for the user* would be pointless. Only commands that
+ * put a window in front of someone consult the broader signals.
  */
 export declare function chromeDevtoolsEnabled(args: Pick<ChromeFlags, "chrome" | "noChrome">, config?: ChromeConfig, env?: NodeJS.ProcessEnv): boolean;
-/** Truthy `CI` env var, with the conventional "false"/"0" escape hatches. */
-export declare function isCi(env?: NodeJS.ProcessEnv): boolean;
 /** The launch-relevant Chrome settings after flags and config are reconciled. */
 export interface ChromeSettings {
     /** Absolute user data dir for this launch. */
@@ -42,7 +46,6 @@ export interface ChromeSettings {
     /** Installed Chrome release channel to launch, if configured. */
     channel?: ChromeChannel;
     headless: boolean;
-    buildExtension: boolean;
 }
 /**
  * Reconcile CLI flags with config into the settings for this launch.
@@ -65,43 +68,61 @@ export declare function chromeUserDataDir(ids: {
     dataDir?: string;
     profile?: string;
 }, base?: string): string;
+/** The intent client's MV3 bundle directory name (see its build-ext.ts: a
+ * THIRD shape of that package — dist/ is the library, dist-ext/ the unpacked
+ * extension). */
+export declare const INTENT_CLIENT_OUT_DIR = "dist-ext";
 /**
- * The built aiui-devtools-extension directory, if available.
+ * What we found when looking for the intent client's extension — the one
+ * launches AUTO-LOAD.
  *
- * The package publishes `extension/` prebuilt, so this resolves both in a dev
- * workspace (where `extension/js` appears once built — see
- * {@link buildDevtoolsExtension}) and installed from npm. Without `js/` the
- * extension is an empty shell, so an unbuilt dev checkout returns undefined.
+ * Deliberately simple: the bundle is a static build with no dev server and no
+ * dev/prod split — the client's hot-iteration surface is the channel-served
+ * plain page, so the extension only ever needs to be BUILT.
  */
-export declare function devtoolsExtensionDir(): string | undefined;
-/**
- * Rebuild the aiui-devtools-extension package so the auto-loaded panel is never stale.
- *
- * A full tsc of the extension (plus the debug-ui esbuild bundle) is well
- * under a second — cheap enough to run on every launch rather than tracking
- * staleness. Best-effort by design: outside a dev
- * checkout (no devtools package, no typescript) it silently does nothing, and
- * a failing compile warns loudly but never blocks the launch — whatever
- * `extension/js` already holds is what gets loaded.
- */
-export declare function buildDevtoolsExtension(): Promise<void>;
+export type IntentClientExtension = {
+    state: "absent";
+} | {
+    state: "unbuilt";
+    root: string;
+} | {
+    state: "ready";
+    dir: string;
+};
+/** Absolute paths for the intent client's bundle, in a checkout. */
+export declare function intentClientExtensionPaths(): {
+    root: string;
+    outDir: string;
+} | undefined;
+/** {@link findIntentClientExtension}'s decision, against explicit paths. */
+export declare function resolveIntentClientExtension(paths: {
+    root: string;
+    outDir: string;
+} | undefined): IntentClientExtension;
+/** The intent client extension, as this checkout can load it. No build-on-
+ * launch (the same rule as the frozen extension's ladder): the bundle is a
+ * deliberate act — `pnpm -C packages/aiui-intent-client build:ext`. */
+export declare function findIntentClientExtension(): IntentClientExtension;
+/** One launch-time note when the client is resolvable but unbuilt — printed
+ * every launch while true (actionable; it disappears once fixed). */
+export declare function warnIntentClientState(intent: IntentClientExtension): void;
 /**
- * One-time tip when the extension exists but the chosen browser won't
- * auto-load it (no `executablePath` means a branded Chrome — installed
+ * One-time tip when extensions exist but the chosen browser won't
+ * auto-load them (no `executablePath` means a branded Chrome — installed
  * stable or a `channel` build — and branded builds ≥ 137 ignore
  * `--load-extension`). Printed once per profile: the marker file lives in the
  * user data dir, so it survives exactly as long as the profile whose manual
  * install it recommends.
  */
-export declare function maybeExtensionAutoloadHint(settings: ChromeSettings, extensionDir: string | undefined): void;
+export declare function maybeExtensionAutoloadHint(settings: ChromeSettings, extensionDirs: string[]): void;
 /**
  * The `mcpServers` entry that launches chrome-devtools-mcp.
  *
  * Uses the documented `npx -y chrome-devtools-mcp@latest` invocation with the
  * user data dir pinned to ours. Puppeteer's default launch args include
- * `--disable-extensions`, which would neuter both the auto-loaded panel and
- * anything installed manually into the profile — so it is always stripped.
- * When an extension dir is given, additionally ask Chrome to load it.
+ * `--disable-extensions`, which would neuter both the auto-loaded extensions
+ * and anything installed manually into the profile — so it is always stripped.
+ * When extension dirs are given, additionally ask Chrome to load them.
  */
 /**
  * The `mcpServers` entry that *attaches* chrome-devtools-mcp to an existing
@@ -113,7 +134,7 @@ export declare function chromeMcpAttachServer(browserUrl: string): {
     command: string;
     args: string[];
 };
-export declare function chromeMcpServer(settings: ChromeSettings, extensionDir?: string): {
+export declare function chromeMcpServer(settings: ChromeSettings, extensionDirs?: string[]): {
     command: string;
     args: string[];
 };

package/dist/util/config-schema.d.ts

@@ -0,0 +1,96 @@
+/**
+ * The declarative schema for aiui's `config.json` — one table that drives
+ * everything config-shaped:
+ *
+ *   - validation (util/config.ts walks these sections instead of hand-rolled
+ *     per-key checks),
+ *   - the `aiui config` commands (show/get/set/unset use it to resolve keys,
+ *     parse CLI values, and report defaults),
+ *   - the `aiui config tui` browser (docs, defaults, and enum choices all
+ *     render from here).
+ *
+ * Because docs, defaults, and validation come from the same rows, they cannot
+ * drift apart. `docs/guide/config.md` remains the long-form narrative; the
+ * `doc` strings here are the terminal-sized versions.
+ *
+ * **How a component participates.** `CONFIG_SECTIONS` is the registry: a
+ * section is plain data, so a future component that grows file-backed settings
+ * (say, an `intent` section for the pipeline) joins by contributing one
+ * `ConfigSectionSchema` object here and a matching optional section on
+ * `AiuiConfig`. Nothing else — validation, show/get/set, and the TUI pick it
+ * up from the table. (The intent pipeline's current config is deliberately
+ * *not* here: it is per-app, passed as `aiuiDevOverlay({ intent: { … } })` in
+ * the app's Vite config — see docs/guide/intent-overlay.md.)
+ */
+export { CHROME_CHANNELS, type ChromeChannel } from "@habemus-papadum/aiui-util";
+export declare const FOR_TESTING_MODES: readonly ["prompt", "auto", "off"];
+export type ForTestingMode = (typeof FOR_TESTING_MODES)[number];
+export declare const CHROME_MODES: readonly ["attach", "launch"];
+export type ChromeMode = (typeof CHROME_MODES)[number];
+export declare const CHANNEL_BINDS: readonly ["loopback", "host"];
+export type ChannelBind = (typeof CHANNEL_BINDS)[number];
+/** Every config leaf is a JSON scalar; sections never nest further. */
+export type ConfigValue = boolean | number | string;
+export interface ConfigFieldSchema {
+    /** Leaf key within its section, e.g. `"skipPermissions"`. */
+    key: string;
+    /** `"enum"` is a string constrained to {@link values}. */
+    type: "boolean" | "number" | "string" | "enum";
+    /** The allowed values when {@link type} is `"enum"`. */
+    values?: readonly string[];
+    /** The built-in default, when the fallback is a plain value. */
+    default?: ConfigValue;
+    /**
+     * Human phrasing of the default when a bare value would mislead (dynamic
+     * fallbacks, first-run prompts). Shown instead of {@link default}.
+     */
+    defaultText?: string;
+    /** One-line summary — the TUI's list row. */
+    summary: string;
+    /** The rest of the documentation (terminal-sized; optional). */
+    doc?: string;
+    /**
+     * Constraint beyond type/enum. Returns the "expected …" tail of the error
+     * message, or undefined when the value is fine.
+     */
+    validate?: (value: ConfigValue) => string | undefined;
+}
+export interface ConfigSectionSchema {
+    /** Top-level key in config.json, e.g. `"chrome"`. */
+    name: string;
+    /** One-line summary of what the section configures. */
+    summary: string;
+    fields: ConfigFieldSchema[];
+}
+export declare const CONFIG_SECTIONS: ConfigSectionSchema[];
+/** A field paired with its section — what key-resolution hands back. */
+export interface ResolvedField {
+    section: ConfigSectionSchema;
+    field: ConfigFieldSchema;
+    /** The dotted path, e.g. `"chrome.mode"`. */
+    path: string;
+}
+/** Every field in schema order, with dotted paths. */
+export declare function allConfigFields(): ResolvedField[];
+/** Resolve a dotted path like `"chrome.mode"`; undefined when unknown. */
+export declare function findConfigField(path: string): ResolvedField | undefined;
+/** The `typeof` a field's values (enums are strings). */
+export declare function fieldRuntimeType(field: ConfigFieldSchema): "boolean" | "number" | "string";
+/**
+ * Constraint check beyond the runtime type: enum membership, then the field's
+ * own `validate`. Returns the "expected …" tail for the error, or undefined.
+ */
+export declare function invalidReason(field: ConfigFieldSchema, value: ConfigValue): string | undefined;
+/**
+ * Parse a CLI-provided string into the field's type and validate it — how
+ * `aiui config set` and the TUI turn text into a config value.
+ */
+export declare function parseFieldValue(field: ConfigFieldSchema, raw: string): {
+    value: ConfigValue;
+} | {
+    error: string;
+};
+/** Render a value the way config.json would hold it (strings quoted). */
+export declare function formatConfigValue(value: ConfigValue): string;
+/** The default, phrased for humans: `defaultText` wins, then the value, then "unset". */
+export declare function describeDefault(field: ConfigFieldSchema): string;

package/dist/util/config.d.ts

@@ -1,83 +1,49 @@
+import { type ChannelBind, type ChromeChannel, type ChromeMode, type ForTestingMode } from "./config-schema";
+export { CHANNEL_BINDS, CHROME_CHANNELS, CHROME_MODES, type ChannelBind, type ChromeChannel, type ChromeMode, FOR_TESTING_MODES, type ForTestingMode, } from "./config-schema";
 export declare const CONFIG_FILENAME = "config.json";
-export declare const CHROME_CHANNELS: readonly ["stable", "beta", "dev", "canary"];
-export type ChromeChannel = (typeof CHROME_CHANNELS)[number];
-export declare const FOR_TESTING_MODES: readonly ["prompt", "auto", "off"];
-export type ForTestingMode = (typeof FOR_TESTING_MODES)[number];
-export declare const CHROME_MODES: readonly ["attach", "launch"];
-export type ChromeMode = (typeof CHROME_MODES)[number];
+/**
+ * The typed shape of a config file. Must mirror `CONFIG_SECTIONS` in
+ * config-schema.ts — the schema rows carry the full per-key documentation and
+ * defaults; the comments here are just orientation.
+ */
 export interface AiuiConfig {
     claude?: {
-        /**
-         * Launch Claude Code with `--dangerously-skip-permissions`. A personal
-         * preference with real consequences (see docs/guide/warning) — the first
-         * interactive launch asks and persists the answer here; when unset in a
-         * non-interactive session it defaults to true.
-         */
+        /** Launch Claude Code with `--dangerously-skip-permissions`. */
         skipPermissions?: boolean;
-        /**
-         * Auto-dismiss Claude Code's development-channel acknowledgement prompt
-         * by injecting an Enter keypress into the terminal at startup (see
-         * util/enter-nudge.ts). Chosen on first interactive run; defaults to true
-         * when unset.
-         */
+        /** Auto-dismiss Claude Code's development-channel prompt (util/enter-nudge.ts). */
         enterNudge?: boolean;
     };
+    channel?: {
+        /** Which interface the channel web server binds: loopback (default) or host (LAN). */
+        bind?: ChannelBind;
+    };
     chrome?: {
-        /**
-         * Attach the Chrome DevTools MCP (default: true). `false` turns it off
-         * everywhere; `true` does not override the CI default-off — only the
-         * `--aiui-chrome` flag forces it on under CI.
-         */
+        /** Attach the Chrome DevTools MCP (default: true). */
         enabled?: boolean;
-        /**
-         * How the MCP reaches a browser (default: "attach"). `"attach"` shares a
-         * user-visible session browser: an already-running one is discovered by
-         * profile, or an interactive launch starts one eagerly. `"launch"` is the
-         * hands-off mode: chrome-devtools-mcp launches its own private browser
-         * lazily, on the agent's first browser tool call.
-         */
+        /** How the MCP reaches a browser: shared session browser, or its own. */
         mode?: ChromeMode;
-        /**
-         * Attach to this Chrome DevTools endpoint (e.g. "http://127.0.0.1:9222")
-         * instead of managing a browser at all — the remote-development key: the
-         * browser runs on another machine (started there with `aiui browser`) and
-         * its port is tunneled over. Setting it implies `mode: "attach"` and makes
-         * every local-browser setting (profile, executablePath, channel,
-         * forTesting…) irrelevant.
-         */
+        /** Attach to this DevTools endpoint instead of managing a browser at all. */
         browserUrl?: string;
-        /**
-         * Fixed DevTools debug port for session browsers aiui launches
-         * (default: 0 — an OS-assigned free port). Pin it (e.g. 9222) when
-         * something else must find the port, like an ssh tunnel.
-         */
+        /** Fixed DevTools debug port for session browsers aiui launches (0 = OS-assigned). */
         debugPort?: number;
         /** Named profile under `.aiui-cache/chrome/` (default: "default"). */
         profile?: string;
         /** Explicit Chrome user data dir; takes precedence over `profile`. */
         dataDir?: string;
-        /**
-         * Chrome binary to launch — e.g. a Chrome for Testing install, which
-         * still honors `--load-extension`. Mutually exclusive with `channel`.
-         */
+        /** Chrome binary to launch. Mutually exclusive with `channel`. */
         executablePath?: string;
-        /** Installed Chrome release channel to launch (default: stable). */
+        /** Installed Chrome release channel to launch. */
         channel?: ChromeChannel;
-        /**
-         * How `aiui claude` manages Chrome for Testing, the recommended browser
-         * (default: "prompt"). `"prompt"` asks before installing or updating it —
-         * interactive sessions only, never under CI; `"auto"` installs/updates
-         * without asking; `"off"` never checks. Skipped entirely when
-         * `executablePath` or `channel` picks a browser explicitly.
-         */
+        /** How `aiui claude` manages the Chrome for Testing install. */
         forTesting?: ForTestingMode;
         /** Launch Chrome headless (default: false). */
         headless?: boolean;
-        /**
-         * In a dev checkout, rebuild the aiui-devtools-extension package (~0.3s of tsc)
-         * on every launch so the auto-loaded panel is never stale (default: true).
-         */
+        /** OBSOLETE (the devtools extension is deleted): parsed and ignored so old
+         * configs stay valid. */
         buildExtension?: boolean;
+        /** OBSOLETE (page-side getDisplayMedia capture is gone): parsed and
+         * ignored so old configs stay valid. */
+        autoCapture?: boolean;
     };
 }
 /** The `config.json` paths consulted, user-level first (base: the project dir). */
@@ -102,3 +68,9 @@ export declare function readConfigFile(file: string): AiuiConfig | undefined;
  * in the project file, which may be shared/committed by a team.
  */
 export declare function updateUserConfig(mutate: (config: AiuiConfig) => void): string;
+/**
+ * Persist a change to a specific config file — the general form behind
+ * {@link updateUserConfig}, and how `aiui config set --project` writes the
+ * project level deliberately.
+ */
+export declare function updateConfigFile(file: string, mutate: (config: AiuiConfig) => void): string;

package/dist/util/first-run.d.ts

@@ -2,15 +2,18 @@
  * First-run choices: settings that deserve a deliberate answer, not a silent
  * default.
  *
- * Two of `aiui claude`'s behaviors are pure personal preference with real
- * consequences: whether to launch with `--dangerously-skip-permissions`, and
+ * Three of `aiui claude`'s behaviors are pure personal preference with real
+ * consequences: whether to launch with `--dangerously-skip-permissions`,
  * whether to auto-dismiss the development-channel acknowledgement prompt by
- * typing into the user's terminal. Neither should be something the user
- * "tagged along" with because a default existed — so the first interactive
- * launch asks (definitively: the prompts have no Enter-through default), and
- * the answers persist to the **user-level** config, after which nothing asks
- * again. Non-interactive sessions never prompt; unset values fall back to the
- * documented defaults (skip: true, nudge: true).
+ * typing into the user's terminal, and whether the channel's web server binds
+ * loopback-only or the host interface (the trusted-LAN posture that makes the
+ * whole unauthenticated surface — iPad paint page included — reachable from
+ * the network). None should be something the user "tagged along" with because
+ * a default existed — so the first interactive launch asks (definitively: the
+ * prompts have no Enter-through default), and the answers persist to the
+ * **user-level** config, after which nothing asks again. Non-interactive
+ * sessions never prompt; unset values fall back to the documented defaults
+ * (skip: true, nudge: true, bind: loopback).
  */
 import { type AiuiConfig } from "./config";
 import { type Choice } from "./prompt";

package/dist/util/gemini-preflight.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Gemini key preflight for `aiui claude` — the GEMINI_API_KEY twin of
+ * {@link ./openai-preflight}.
+ *
+ * The realtime submode's reference engine is Gemini Live, and it runs in the
+ * *channel* process, which inherits the environment `aiui claude` launches in.
+ * Same key story as OpenAI: **`GEMINI_API_KEY` in the environment**, never
+ * config, never a flag. And the same failure this catches: a missing or stale
+ * key that would otherwise surface as an opaque closed WebSocket deep in a
+ * live session ("gemini live session closed") rather than a clear message up
+ * front. Degradation, not refusal — a bad key never blocks the launch; the
+ * realtime tier is simply unavailable until it's fixed.
+ *
+ * We record only a status — never the key or any prefix of it — so the
+ * launch-info summary can explain a degraded pipeline without seeing the
+ * secret.
+ */
+import type { OpenAiKeyStatus } from "@habemus-papadum/aiui-claude-channel";
+export interface GeminiPreflightOptions {
+    /**
+     * Perform the authenticated network check. True only for interactive,
+     * non-CI launches. When false the check is skipped silently and a present
+     * key is reported as "unverified", never contacted.
+     */
+    verify?: boolean;
+    /** Injectable for tests; defaults to the process environment. */
+    env?: NodeJS.ProcessEnv;
+    /** Injectable for tests; defaults to global `fetch`. */
+    fetchImpl?: typeof fetch;
+    /** Network budget for the status check (default {@link DEFAULT_TIMEOUT_MS}). */
+    timeoutMs?: number;
+}
+/**
+ * Determine the status of `GEMINI_API_KEY` for this launch. Same contract as
+ * `preflightOpenAiKey`: never throws, never prints, never returns the key.
+ * The key rides the query string (Gemini's auth shape — no bearer header) and
+ * a rejected key answers 400/401/403 depending on how it's malformed, so all
+ * three read as "invalid".
+ */
+export declare function preflightGeminiKey(opts?: GeminiPreflightOptions): Promise<OpenAiKeyStatus>;
+interface PreflightMessage {
+    level: "warn" | "note";
+    title: string;
+    detail: string;
+}
+/**
+ * The user-facing message for a preflight status, or `null` when there's
+ * nothing to say. Unlike the OpenAI twin, a **missing** Gemini key is a quiet
+ * `note`, not a warning: the default transcription tiers don't need it — only
+ * the realtime (Gemini Live) submode does — so its absence degrades one
+ * opt-in tier, not the pipeline's default path.
+ */
+export declare function geminiPreflightMessage(status: OpenAiKeyStatus): PreflightMessage | null;
+/** Print the preflight message for `status` (nothing, for a valid key). */
+export declare function reportGeminiPreflight(status: OpenAiKeyStatus): void;
+export {};

package/dist/util/openai-preflight.d.ts

@@ -11,9 +11,10 @@
  *
  * So the launcher's whole job is to *preflight* that env var and tell the user
  * what it found — degradation, not refusal. A missing or rejected key never
- * blocks the launch; the modality still mounts and transcription/correction
- * fall back to mock/off. The most valuable case this catches is the one that
- * bit the bench twice (see workbench field-notes, "Keys & config"): a **stale
+ * blocks the launch; the modality still mounts, but transcription/correction are
+ * unavailable until the key is set (the widget says so — `mock` is the explicit
+ * offline choice, not a silent fallback). The most valuable case this catches is the one that
+ * bit the bench twice (archive/workbench/field-notes.md, "Keys & config"): a **stale
  * shell export** shadowing the real key, which surfaces as a confusing 401 deep
  * in the pipeline rather than a clear message up front.
  *

package/dist/util/resolve-cli.d.ts

@@ -1,14 +1,4 @@
-/**
- * Absolute root directory of an installed (or workspace-linked) dependency.
- *
- * Rather than resolve the package *through* the module system — which would hit
- * its `exports` map (forcing a built `dist/`, and normally blocking access to
- * `package.json`) — we ask Node for the `node_modules` dirs it would search and
- * read `package.json` straight off disk. This needs nothing special from the
- * target package (no `exports` entry) and works even when it has not been
- * built, so dev iteration requires no compile step.
- */
-export declare function packageRoot(packageName: string): string;
+export { packageRoot } from "@habemus-papadum/aiui-util";
 /** How to spawn a CLI: a program plus the args that precede any subcommand. */
 export interface CliInvocation {
     command: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@habemus-papadum/aiui",
-  "version": "0.2.0",
+  "version": "0.5.0",
   "description": "ai ui frontends",
   "type": "module",
   "license": "MIT",
@@ -14,7 +14,8 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "main": "./dist/index.js",
@@ -24,22 +25,25 @@
     "aiui": "./dist/cli.js"
   },
   "files": [
-    "dist",
-    "templates"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
+    "@inquirer/prompts": "^7.2.0",
     "@puppeteer/browsers": "^2.10.5",
     "chalk": "^5.3.0",
     "commander": "^15.0.0",
     "execa": "^9.6.1",
     "vite": "^6.4.3",
-    "@habemus-papadum/aiui-claude-plugin": "^0.2.0",
-    "@habemus-papadum/aiui-util": "^0.2.0",
-    "@habemus-papadum/aiui-claude-channel": "^0.2.0",
-    "@habemus-papadum/aiui-devtools-extension": "^0.2.0"
+    "@habemus-papadum/aiui-claude-channel": "^0.5.0",
+    "@habemus-papadum/aiui-trace-ui": "^0.5.0",
+    "@habemus-papadum/aiui-claude-plugin": "^0.5.0",
+    "@habemus-papadum/aiui-util": "^0.5.0"
+  },
+  "devDependencies": {
+    "@habemus-papadum/aiui-lowering-pipeline": "^0.5.0"
   },
   "scripts": {
     "build": "tsc --emitDeclarationOnly -p tsconfig.json && vite build",

package/dist/commands/demo.d.ts

@@ -1,28 +0,0 @@
-export interface DemoOptions {
-    /** Scaffold only — skip `npm install` (used by the packaging test/CI). */
-    skipInstall?: boolean;
-}
-/** What `aiui demo` finds at the target path. */
-export type DemoTargetState = "new" | "existing-demo" | "occupied";
-export declare function runDemo(dir: string | undefined, opts?: DemoOptions): Promise<void>;
-/**
- * Decide what to do with the target: `new` (missing or empty), an
- * `existing-demo` (package.json carries the scaffold marker — continue), or
- * `occupied` (anything else — refuse; never clobber unknown content).
- */
-export declare function classifyDemoTarget(target: string): DemoTargetState;
-/**
- * The dependency range the scaffold pins aiui packages to: this build's exact
- * release line when it has one, `latest` from a dev build (whose `0.0.0+dev`
- * doesn't exist on the registry).
- */
-export declare function demoDependencyRange(version: string): string;
-/** Copy the template, restore `.gitignore`, and pin dependency ranges. */
-export declare function scaffoldDemo(template: string, target: string): void;
-/**
- * The template directory shipped with this install. Probed upward from this
- * module because the relative depth differs between layouts: `dist/cli.js`
- * (bundled, installed) sits one level below the package root; the tsx-run
- * `src/commands/demo.ts` sits two below.
- */
-export declare function templateRoot(): string | undefined;

package/dist/util/browser.d.ts

@@ -1,44 +0,0 @@
-import type { ChromeChannel } from "./config";
-export interface SessionBrowser {
-    /** The DevTools endpoint chrome-devtools-mcp attaches to. */
-    browserUrl: string;
-    port: number;
-}
-/**
- * A live session browser for this profile, if one is running.
- * Never launches anything; safe to call from non-interactive paths.
- */
-export declare function discoverSessionBrowser(userDataDir: string): Promise<SessionBrowser | undefined>;
-/**
- * Which binary a session-browser launch should run: an explicit
- * executablePath (usually the managed Chrome for Testing) wins; otherwise the
- * system install of the requested channel (default stable). Throws when no
- * such browser is installed.
- */
-export declare function sessionBrowserBinary(settings: {
-    executablePath?: string;
-    channel?: ChromeChannel;
-}): string;
-/**
- * Launch the session browser detached (it deliberately outlives the aiui
- * process — it's the user's window too) and wait for its debug endpoint.
- *
- * `debugPort` 0 lets the OS pick a free port; Chrome reports the choice via
- * `DevToolsActivePort`, which is removed first so a stale file from a previous
- * run can't win the poll. Fails fast if the process exits early — the classic
- * cause being an already-running Chrome on the same profile *without* a debug
- * port, which swallows the new invocation as a URL-handoff and exits.
- */
-export declare function launchSessionBrowser(opts: {
-    binary: string;
-    userDataDir: string;
-    debugPort?: number;
-    extensionDir?: string;
-    headless?: boolean;
-    startUrl?: string;
-}): Promise<SessionBrowser>;
-/**
- * Open a URL as a new tab in a session browser, via the DevTools HTTP API
- * (`PUT /json/new` — PUT is required by current Chrome).
- */
-export declare function openInSessionBrowser(browserUrl: string, url: string): Promise<void>;

package/templates/demo/CLAUDE.md

@@ -1,16 +0,0 @@
-# aiui demo playground
-
-This directory is a scaffolded, disposable aiui demo — a sandbox the user is exploring the aiui
-workflow in. Ground rules for working here:
-
-- **The app is scenery.** `src/main.ts` renders a fake "spectra" viewer purely so there's
-  something to point at and modify. Redesign it, extend it, replace it — that's the point of the
-  demo. Prefer small, visible changes the user can watch land.
-- **Don't remove the integration.** The `aiuiDevOverlay()` plugin in `vite.config.ts` is what
-  mounts the intent tool and connects it to this session's channel. The demo stops working
-  without it.
-- The dev server runs via `npm run dev` (which is `aiui vite dev` — it injects the channel port
-  as `VITE_AIUI_PORT`). Plain `vite` also serves the app, but the intent tool won't find the
-  channel.
-- This is a standalone git repo scaffolded by `aiui demo`; commit freely — history here belongs
-  to the user's sandbox and goes nowhere else.

package/templates/demo/README.md

@@ -1,36 +0,0 @@
-# aiui demo playground
-
-A disposable sandbox for trying [aiui](https://habemus-papadum.github.io/pdum_aiui/): a Claude
-Code session with a custom channel, a shared agent+human browser, and a web intent tool floating
-over a demo app. It's a local git repo of its own — let the agent redesign, break, and rebuild
-the app; nothing flows back anywhere.
-
-> ⚠️ First read *Read before running* in the aiui docs: `aiui claude` can skip permissions and
-> gives the agent a browser. This sandbox assumes you've decided to trust it.
-
-## Run it
-
-```sh
-npm run claude   # terminal 1 — Claude Code with the aiui channel + session browser
-npm run dev      # terminal 2 — the demo app (Vite + the intent tool overlay)
-```
-
-Then open the app **in the session browser** (the window you share with the agent):
-
-```sh
-npx aiui open http://localhost:5173
-```
-
-Click the floating **✳ aiui** button, type an intent — *"make the baseline curve red"* — and
-watch it land in the Claude session as a prompt. The 🔍 button shows how your input was lowered
-into that prompt.
-
-## What's what
-
-- `vite.config.ts` — the **entire** aiui integration: one `aiuiDevOverlay()` plugin. This is the
-  part you'd copy into your own app.
-- `src/main.ts` — throwaway scenery (a fake spectrum viewer). No aiui code in it.
-- Re-running the scaffold command in this directory just picks up where you left off — it never
-  overwrites your (or the agent's) changes.
-
-Docs: <https://habemus-papadum.github.io/pdum_aiui/guide/getting-started>

package/templates/demo/gitignore

@@ -1,4 +0,0 @@
-node_modules/
-dist/
-.aiui-cache/
-*.log

package/templates/demo/index.html

@@ -1,11 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>spectra — aiui demo playground</title>
-  </head>
-  <body>
-    <script type="module" src="/src/main.ts"></script>
-  </body>
-</html>