@nwire/cli 0.9.1 → 0.10.0

package/dist/lib/package-manager.js

@@ -0,0 +1,67 @@
+/**
+ * Detect the consumer's package manager from lockfile / packageManager
+ * field. `pnpm` is preferred when ambiguous (matches Nwire's own dev
+ * convention) but the CLI follows whatever the project already uses.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+export function detectPackageManager(cwd = process.cwd()) {
+    const pkgPath = resolve(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+            if (pkg.packageManager) {
+                if (pkg.packageManager.startsWith("pnpm"))
+                    return "pnpm";
+                if (pkg.packageManager.startsWith("yarn"))
+                    return "yarn";
+                if (pkg.packageManager.startsWith("bun"))
+                    return "bun";
+                if (pkg.packageManager.startsWith("npm"))
+                    return "npm";
+            }
+        }
+        catch {
+            // fall through to lockfile detection
+        }
+    }
+    if (existsSync(resolve(cwd, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (existsSync(resolve(cwd, "yarn.lock")))
+        return "yarn";
+    if (existsSync(resolve(cwd, "bun.lockb")))
+        return "bun";
+    if (existsSync(resolve(cwd, "package-lock.json")))
+        return "npm";
+    return "npm";
+}
+/**
+ * Build the command + args for `<pm> run <script>`.
+ */
+export function runScriptCommand(pm, script) {
+    switch (pm) {
+        case "pnpm":
+        case "yarn":
+        case "bun":
+            return [pm, ["run", script]];
+        case "npm":
+            return ["npm", ["run", script]];
+    }
+}
+/**
+ * Build the command + args for `<pm> exec <bin> [...args]`. yarn 1.x
+ * does not have `exec`; we fall back to invoking `node_modules/.bin/<bin>`
+ * directly for that case.
+ */
+export function execBinaryCommand(pm, bin, args = []) {
+    switch (pm) {
+        case "pnpm":
+            return ["pnpm", ["exec", bin, ...args]];
+        case "yarn":
+            return ["yarn", [bin, ...args]];
+        case "bun":
+            return ["bun", ["x", bin, ...args]];
+        case "npm":
+            return ["npx", ["--no-install", bin, ...args]];
+    }
+}

package/dist/lib/process-state.d.ts

@@ -27,4 +27,3 @@ export declare function writeRecord(cwd: string, record: ProcessRecord): void;
 export declare function readRecord(cwd: string, id: string): ProcessRecord | undefined;
 export declare function listRecords(cwd: string): ProcessRecord[];
 export declare function removeRecord(cwd: string, id: string): void;
-//# sourceMappingURL=process-state.d.ts.map

package/dist/lib/process-state.js

@@ -65,4 +65,3 @@ export function removeRecord(cwd, id) {
         // already gone
     }
 }
-//# sourceMappingURL=process-state.js.map

package/dist/lib/project.d.ts

@@ -1,7 +1,7 @@
 /**
- * Project introspection — figures out what shape of Nwire project we're
- * sitting inside. Commands use this to render the greeting and to validate
- * arguments before spawning anything.
+ * Project introspection. Thin adapter over `detectLayout` — preserves
+ * the older `ProjectInfo` shape so existing CLI callers keep working
+ * while pointing at the unified layout discoverer.
  */
 export interface ProjectInfo {
     readonly cwd: string;
@@ -12,4 +12,3 @@ export interface ProjectInfo {
     readonly hasPlease: boolean;
 }
 export declare function detectProject(cwd?: string): ProjectInfo;
-//# sourceMappingURL=project.d.ts.map

package/dist/lib/project.js

@@ -1,52 +1,34 @@
 /**
- * Project introspection — figures out what shape of Nwire project we're
- * sitting inside. Commands use this to render the greeting and to validate
- * arguments before spawning anything.
+ * Project introspection. Thin adapter over `detectLayout` — preserves
+ * the older `ProjectInfo` shape so existing CLI callers keep working
+ * while pointing at the unified layout discoverer.
  */
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
+import { detectLayout } from "./layout.js";
 export function detectProject(cwd = process.cwd()) {
-    const pkgPath = resolve(cwd, "package.json");
+    const layout = detectLayout(cwd);
     let name = "(unnamed)";
-    try {
-        if (existsSync(pkgPath)) {
+    const pkgPath = resolve(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
             const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
             if (pkg.name)
                 name = pkg.name;
         }
-    }
-    catch {
-        // keep default name
-    }
-    const appsDir = resolve(cwd, "apps");
-    const wires = [];
-    let hasDevAll = false;
-    let hasPlease = false;
-    if (existsSync(appsDir)) {
-        for (const entry of readdirSync(appsDir, { withFileTypes: true })) {
-            if (!entry.isDirectory())
-                continue;
-            const appDir = resolve(appsDir, entry.name);
-            // A wire is any app folder with a recognized entry file. We accept
-            // both the older `run.ts` convention and the current `main.ts`
-            // convention so the greeting works across projects mid-migration.
-            const hasEntry = existsSync(resolve(appDir, "run.ts")) || existsSync(resolve(appDir, "main.ts"));
-            if (hasEntry)
-                wires.push(entry.name);
-            if (entry.name === "dev-all" && existsSync(resolve(appDir, "run.ts"))) {
-                hasDevAll = true;
-            }
-            if (existsSync(resolve(appDir, "run.please.ts")))
-                hasPlease = true;
+        catch {
+            // keep default
         }
     }
+    const wires = layout.wires.map((w) => w.name).sort();
+    const hasDevAll = wires.includes("dev-all");
+    const hasPlease = layout.wires.some((w) => w.entry.endsWith("run.please.ts") || w.entry.endsWith("please.ts"));
     return {
         cwd,
         name,
-        hasNwireConfig: existsSync(resolve(cwd, "nwire.config.ts")),
-        wires: wires.sort(),
+        hasNwireConfig: !!layout.configPath,
+        wires,
         hasDevAll,
         hasPlease,
     };
 }
-//# sourceMappingURL=project.js.map

package/dist/lib/run-task.d.ts

@@ -29,4 +29,3 @@ export declare function runCommand(spec: TaskRunSpec): Promise<{
  * is set). Returns the aggregate exit code.
  */
 export declare function runTaskList(tasks: readonly TaskRunSpec[]): Promise<number>;
-//# sourceMappingURL=run-task.d.ts.map

package/dist/lib/run-task.js

@@ -72,4 +72,3 @@ export async function runTaskList(tasks) {
     }
     return aggregate;
 }
-//# sourceMappingURL=run-task.js.map

package/dist/lib/scan-cache.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Incremental scan cache. Walks the project's source tree, computes a
+ * fingerprint over file mtimes and sizes, and persists it under
+ * `.nwire/scan-fingerprint.json`. `isFresh()` returns true when the
+ * current tree matches the saved fingerprint — in that case CLI
+ * commands can read the existing `.nwire/manifest.json` without
+ * re-running the consumer's app to rebuild it.
+ *
+ * The fingerprint is intentionally cheap: a single sha1 over a sorted
+ * list of `<relative path> <mtimeMs> <size>` lines for every `.ts`,
+ * `.mts`, `.js`, `.mjs` file under the project root, excluding
+ * `node_modules/`, `dist/`, `.nwire/`, `.turbo/`, and dotfiles.
+ *
+ * The cost of a fresh fingerprint scan on a typical service-sized tree
+ * (hundreds of files) is a few milliseconds — fast enough to run on
+ * every CLI invocation that needs it.
+ */
+export declare function fingerprint(cwd: string): string;
+export declare function readFingerprint(cwd: string): string | undefined;
+export declare function writeFingerprint(cwd: string, value: string): void;
+/**
+ * True when `.nwire/manifest.json` exists AND the saved fingerprint
+ * matches the current tree. The caller passes the fingerprint it just
+ * computed so the same scan can serve both "is fresh?" and "what's the
+ * new fingerprint to save?"
+ */
+export declare function isFresh(cwd: string, currentFingerprint: string): boolean;

package/dist/lib/scan-cache.js

@@ -0,0 +1,102 @@
+/**
+ * Incremental scan cache. Walks the project's source tree, computes a
+ * fingerprint over file mtimes and sizes, and persists it under
+ * `.nwire/scan-fingerprint.json`. `isFresh()` returns true when the
+ * current tree matches the saved fingerprint — in that case CLI
+ * commands can read the existing `.nwire/manifest.json` without
+ * re-running the consumer's app to rebuild it.
+ *
+ * The fingerprint is intentionally cheap: a single sha1 over a sorted
+ * list of `<relative path> <mtimeMs> <size>` lines for every `.ts`,
+ * `.mts`, `.js`, `.mjs` file under the project root, excluding
+ * `node_modules/`, `dist/`, `.nwire/`, `.turbo/`, and dotfiles.
+ *
+ * The cost of a fresh fingerprint scan on a typical service-sized tree
+ * (hundreds of files) is a few milliseconds — fast enough to run on
+ * every CLI invocation that needs it.
+ */
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, statSync, writeFileSync, readFileSync, mkdirSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+const SCAN_EXTENSIONS = [".ts", ".mts", ".js", ".mjs"];
+const SKIP_DIRS = new Set(["node_modules", "dist", ".nwire", ".turbo", ".git", ".vitepress"]);
+function walk(root, out) {
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (entry.name.startsWith("."))
+            continue;
+        if (SKIP_DIRS.has(entry.name))
+            continue;
+        const full = resolve(root, entry.name);
+        if (entry.isDirectory()) {
+            walk(full, out);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if (entry.name.endsWith(".d.ts"))
+            continue;
+        if (!SCAN_EXTENSIONS.some((ext) => entry.name.endsWith(ext)))
+            continue;
+        out.push(full);
+    }
+}
+export function fingerprint(cwd) {
+    const files = [];
+    walk(cwd, files);
+    files.sort();
+    const h = createHash("sha1");
+    for (const f of files) {
+        try {
+            const st = statSync(f);
+            h.update(`${relative(cwd, f)} ${st.mtimeMs} ${st.size}\n`);
+        }
+        catch {
+            // Race with concurrent rm; skip — the next fingerprint will catch it.
+        }
+    }
+    // Include package.json so dependency edits invalidate too.
+    const pkg = resolve(cwd, "package.json");
+    if (existsSync(pkg)) {
+        const st = statSync(pkg);
+        h.update(`package.json ${st.mtimeMs} ${st.size}\n`);
+    }
+    return h.digest("hex");
+}
+const FILE = "scan-fingerprint.json";
+export function readFingerprint(cwd) {
+    const p = resolve(cwd, ".nwire", FILE);
+    if (!existsSync(p))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(p, "utf8"));
+        return parsed.version === 1 ? parsed.fingerprint : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeFingerprint(cwd, value) {
+    const dir = resolve(cwd, ".nwire");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const payload = {
+        version: 1,
+        fingerprint: value,
+        generatedAt: new Date().toISOString(),
+    };
+    writeFileSync(resolve(dir, FILE), JSON.stringify(payload, null, 2));
+}
+/**
+ * True when `.nwire/manifest.json` exists AND the saved fingerprint
+ * matches the current tree. The caller passes the fingerprint it just
+ * computed so the same scan can serve both "is fresh?" and "what's the
+ * new fingerprint to save?"
+ */
+export function isFresh(cwd, currentFingerprint) {
+    const manifest = resolve(cwd, ".nwire", "manifest.json");
+    if (!existsSync(manifest))
+        return false;
+    const saved = readFingerprint(cwd);
+    return saved === currentFingerprint;
+}
+void dirname; // silence "imported but unused" in some builds

package/dist/lib/script-runner.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Run-an-operation-three-ways helper. Every CLI command that exists to
+ * orchestrate a check or build follows the same pattern:
+ *
+ *   1. If the consumer defined a `scripts.<name>` in their package.json,
+ *      run that. Honors whatever the project already encodes.
+ *   2. Otherwise, if a list of sub-scripts is defined (e.g. `check`
+ *      decomposes into `format:check`, `lint`, `typecheck`), run each
+ *      that the consumer has defined.
+ *   3. Otherwise, fall back to spawning installed binaries — but only
+ *      if the binary actually exists in `node_modules/.bin`. We never
+ *      spawn a tool we haven't verified is present, so consumers that
+ *      use a different formatter / linter / type checker don't see a
+ *      surprise `ENOENT` from our hardcoded defaults.
+ *
+ * The result is that `nwire check` reads as "run the project's check,
+ * whatever that means in this project" rather than "run our chosen
+ * formatter on the project, hope they have it installed."
+ */
+interface FallbackBinary {
+    /** Display title for the listr task. */
+    readonly title: string;
+    /** Binary name as installed under `node_modules/.bin/`. */
+    readonly bin: string;
+    /** Extra args appended after the binary name. */
+    readonly args?: readonly string[];
+}
+export interface ScriptStrategy {
+    /** Single script name to try first (e.g. "check"). */
+    readonly consumerScript?: string;
+    /** Sub-scripts to try in sequence if `consumerScript` is not defined. */
+    readonly consumerSubScripts?: readonly string[];
+    /** Binaries to try if no consumer scripts apply. */
+    readonly fallback?: readonly FallbackBinary[];
+    /** Title for the top-level operation; passed to error messages. */
+    readonly operationName: string;
+}
+export declare function runScriptStrategy(cwd: string, strategy: ScriptStrategy): Promise<{
+    code: number;
+    ran: boolean;
+}>;
+export {};

package/dist/lib/script-runner.js

@@ -0,0 +1,90 @@
+/**
+ * Run-an-operation-three-ways helper. Every CLI command that exists to
+ * orchestrate a check or build follows the same pattern:
+ *
+ *   1. If the consumer defined a `scripts.<name>` in their package.json,
+ *      run that. Honors whatever the project already encodes.
+ *   2. Otherwise, if a list of sub-scripts is defined (e.g. `check`
+ *      decomposes into `format:check`, `lint`, `typecheck`), run each
+ *      that the consumer has defined.
+ *   3. Otherwise, fall back to spawning installed binaries — but only
+ *      if the binary actually exists in `node_modules/.bin`. We never
+ *      spawn a tool we haven't verified is present, so consumers that
+ *      use a different formatter / linter / type checker don't see a
+ *      surprise `ENOENT` from our hardcoded defaults.
+ *
+ * The result is that `nwire check` reads as "run the project's check,
+ * whatever that means in this project" rather than "run our chosen
+ * formatter on the project, hope they have it installed."
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { detectPackageManager, execBinaryCommand, runScriptCommand, } from "./package-manager.js";
+import { runTaskList } from "./run-task.js";
+function readScripts(cwd) {
+    const p = resolve(cwd, "package.json");
+    if (!existsSync(p))
+        return {};
+    try {
+        const pkg = JSON.parse(readFileSync(p, "utf8"));
+        return pkg.scripts ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+function binaryInstalled(cwd, bin) {
+    return (existsSync(resolve(cwd, "node_modules", ".bin", bin)) ||
+        existsSync(resolve(cwd, "node_modules", ".bin", `${bin}.cmd`)));
+}
+function buildTasksForStrategy(cwd, pm, strategy) {
+    const scripts = readScripts(cwd);
+    if (strategy.consumerScript && scripts[strategy.consumerScript]) {
+        const [command, args] = runScriptCommand(pm, strategy.consumerScript);
+        return {
+            tasks: [
+                {
+                    title: `${pm} run ${strategy.consumerScript}`,
+                    command,
+                    args,
+                },
+            ],
+            source: "consumer-script",
+        };
+    }
+    if (strategy.consumerSubScripts && strategy.consumerSubScripts.length > 0) {
+        const available = strategy.consumerSubScripts.filter((s) => scripts[s] !== undefined);
+        if (available.length > 0) {
+            return {
+                tasks: available.map((script) => {
+                    const [command, args] = runScriptCommand(pm, script);
+                    return { title: `${pm} run ${script}`, command, args };
+                }),
+                source: "consumer-subscripts",
+            };
+        }
+    }
+    if (strategy.fallback && strategy.fallback.length > 0) {
+        const available = strategy.fallback.filter((f) => binaryInstalled(cwd, f.bin));
+        if (available.length > 0) {
+            return {
+                tasks: available.map((f) => {
+                    const [command, args] = execBinaryCommand(pm, f.bin, f.args);
+                    return { title: f.title, command, args };
+                }),
+                source: "fallback",
+            };
+        }
+    }
+    return { tasks: [], source: "none" };
+}
+export async function runScriptStrategy(cwd, strategy) {
+    const pm = detectPackageManager(cwd);
+    const { tasks, source } = buildTasksForStrategy(cwd, pm, strategy);
+    if (source === "none") {
+        return { code: 0, ran: false };
+    }
+    void source;
+    const code = await runTaskList(tasks);
+    return { code, ran: true };
+}

package/dist/lib/sse.d.ts

@@ -21,4 +21,3 @@ export declare class SseParser {
      */
     feed(chunk: string): unknown[];
 }
-//# sourceMappingURL=sse.d.ts.map

package/dist/lib/sse.js

@@ -60,4 +60,3 @@ function parseFrame(frame) {
         return undefined;
     }
 }
-//# sourceMappingURL=sse.js.map

package/dist/lib/version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Single-source the CLI version from its own package.json. Read once at
+ * module import; the result is stable across the process lifetime.
+ *
+ * Looks for `package.json` next to the compiled `dist/lib/version.js` or
+ * next to the source `src/lib/version.ts` (the dev runner path).
+ */
+export declare function cliVersion(): string;

package/dist/lib/version.js

@@ -0,0 +1,29 @@
+/**
+ * Single-source the CLI version from its own package.json. Read once at
+ * module import; the result is stable across the process lifetime.
+ *
+ * Looks for `package.json` next to the compiled `dist/lib/version.js` or
+ * next to the source `src/lib/version.ts` (the dev runner path).
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const here = dirname(fileURLToPath(import.meta.url));
+function locate() {
+    for (const candidate of [
+        resolve(here, "..", "..", "package.json"),
+        resolve(here, "..", "..", "..", "package.json"),
+    ]) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    throw new Error("nwire-cli: package.json not found relative to version.ts");
+}
+let cached;
+export function cliVersion() {
+    if (cached)
+        return cached;
+    const pkg = JSON.parse(readFileSync(locate(), "utf8"));
+    cached = pkg.version ?? "0.0.0";
+    return cached;
+}

package/dist/lib/vite-node.d.ts

@@ -7,4 +7,3 @@ export declare function viteNodeWatch(scriptPath: string): {
     child: import("child_process").ChildProcess;
     done: Promise<number>;
 };
-//# sourceMappingURL=vite-node.d.ts.map

package/dist/lib/vite-node.js

@@ -11,4 +11,3 @@ export function viteNodeWatch(scriptPath) {
         stoppedMessage: "Dev server stopped.",
     });
 }
-//# sourceMappingURL=vite-node.js.map

package/dist/lib/wire-discovery.d.ts

@@ -6,4 +6,3 @@
  * whose `/_nwire/events/recent?limit=1` responds with a JSON array.
  */
 export declare function findWireUrl(): Promise<string | null>;
-//# sourceMappingURL=wire-discovery.d.ts.map

package/dist/lib/wire-discovery.js

@@ -78,4 +78,3 @@ function isNwireWire(port, timeoutMs) {
         });
     });
 }
-//# sourceMappingURL=wire-discovery.js.map

package/dist/load-config.d.ts

@@ -24,4 +24,3 @@ export interface NwireConfig {
 export declare function defineConfig(cfg: NwireConfig): NwireConfig;
 export declare function loadConfig(cwd: string): Promise<NwireConfig>;
 export declare function resolveAppsEntry(cwd: string, config: NwireConfig): string;
-//# sourceMappingURL=load-config.d.ts.map

package/dist/load-config.js

@@ -47,4 +47,3 @@ export function resolveAppsEntry(cwd, config) {
     }
     return resolve(cwd, "apps/apps.ts"); // canonical default; will error if missing
 }
-//# sourceMappingURL=load-config.js.map

package/dist/ls-runner.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=ls-runner.d.ts.map

package/dist/ls-runner.js

@@ -1,55 +1,49 @@
 // `nwire ls` — list every wire + every action across all apps.
+import { existsSync, readFileSync } from "node:fs";
 import { relative, resolve } from "node:path";
-import { readdirSync, statSync, existsSync } from "node:fs";
-function listWires(appsRoot) {
-    if (!existsSync(appsRoot))
-        return [];
-    const wires = [];
-    for (const app of readdirSync(appsRoot)) {
-        const appDir = resolve(appsRoot, app);
-        if (!statSync(appDir).isDirectory())
-            continue;
-        for (const file of readdirSync(appDir)) {
-            if (!file.startsWith("run") || !file.endsWith(".ts"))
-                continue;
-            if (file.endsWith(".d.ts"))
-                continue;
-            const stem = file.slice(0, -3);
-            const variant = stem === "run" ? "" : `.${stem.slice(4)}`;
-            wires.push({ wire: `${app}${variant}`, path: resolve(appDir, file) });
-        }
+import { detectLayout } from "./lib/layout.js";
+function loadManifest(cwd) {
+    const p = resolve(cwd, ".nwire", "manifest.json");
+    if (!existsSync(p))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(p, "utf8"));
+    }
+    catch {
+        return undefined;
     }
-    return wires;
 }
 async function main() {
     const cwd = process.cwd();
-    const appsRoot = resolve(cwd, "apps");
-    const wires = listWires(appsRoot);
+    const layout = detectLayout(cwd);
     console.log("Wires:");
-    for (const { wire, path } of wires) {
-        const rel = relative(cwd, path);
-        console.log(`  ${wire.padEnd(28)} ${rel}`);
+    if (layout.wires.length === 0) {
+        console.log("  (none — add an entry under app/, apps/<name>/, or src/)");
     }
-    console.log();
-    // Try to list actions from the apps registry.
-    const appsPath = resolve(cwd, "apps/apps.ts");
-    if (existsSync(appsPath)) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const mod = await import(/* @vite-ignore */ appsPath);
-        const apps = mod.allApps ?? mod.apps ?? [];
-        console.log("Actions:");
-        for (const app of apps) {
-            for (const module of app.modules) {
-                for (const action of module.manifest.actions ?? []) {
-                    const label = `${action.name}`.padEnd(40);
-                    console.log(`  ${label} ${app.name}/${module.name}`);
-                }
-            }
+    else {
+        for (const w of layout.wires) {
+            console.log(`  ${w.name.padEnd(28)} ${relative(cwd, w.entry)}`);
         }
     }
+    console.log();
+    const manifest = loadManifest(cwd);
+    if (!manifest) {
+        console.log("Actions: (run `nwire cache` to populate)");
+        return;
+    }
+    const actions = manifest.actions ?? [];
+    if (actions.length === 0) {
+        console.log("Actions: (none registered)");
+        return;
+    }
+    console.log("Actions:");
+    for (const a of actions) {
+        const label = a.name.padEnd(40);
+        const owner = a.app && a.module ? `${a.app}/${a.module}` : "";
+        console.log(`  ${label} ${owner}`);
+    }
 }
 main().catch((err) => {
     console.error(err);
     process.exit(1);
 });
-//# sourceMappingURL=ls-runner.js.map

package/dist/ui/dev-dashboard.d.ts

@@ -20,4 +20,3 @@ interface DevDashboardProps {
 }
 export declare function DevDashboard({ title, subtitle, subscribe, maxLines, }: DevDashboardProps): React.ReactElement;
 export {};
-//# sourceMappingURL=dev-dashboard.d.ts.map

package/dist/ui/dev-dashboard.js

@@ -50,4 +50,3 @@ export function DevDashboard({ title, subtitle, subscribe, maxLines = 18, }) {
     const statusLabel = ready.ready ? "running" : "booting";
     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 2, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: title }), subtitle ? _jsx(Text, { dimColor: true, children: ` · ${subtitle}` }) : null] }), _jsxs(Box, { marginTop: 1, children: [_jsx(Box, { width: 10, children: _jsx(Text, { dimColor: true, children: "status" }) }), _jsx(Text, { color: statusColor, children: statusLabel }), ready.url ? _jsx(Text, { dimColor: true, children: ` · ${ready.url}` }) : null, ready.elapsed ? _jsx(Text, { dimColor: true, children: ` · ${ready.elapsed}` }) : null] }), _jsxs(Box, { children: [_jsx(Box, { width: 10, children: _jsx(Text, { dimColor: true, children: "output" }) }), _jsx(Text, { dimColor: true, children: `${counter} line${counter === 1 ? "" : "s"}` })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Ctrl+C to stop." }) })] }), _jsx(Box, { flexDirection: "column", marginTop: 1, marginLeft: 1, children: _jsx(Static, { items: lines, children: (chunk) => (_jsx(Box, { children: _jsx(Text, { color: chunk.stream === "stderr" ? "red" : undefined, children: chunk.text }) }, chunk.id)) }) })] }));
 }
-//# sourceMappingURL=dev-dashboard.js.map

package/dist/ui/greeting.d.ts

@@ -13,4 +13,3 @@ interface GreetingProps {
 }
 export declare function Greeting({ project, version }: GreetingProps): React.ReactElement;
 export {};
-//# sourceMappingURL=greeting.d.ts.map

package/dist/ui/greeting.js

@@ -13,4 +13,3 @@ export function Greeting({ project, version }) {
                                     ? project.wires.join(", ")
                                     : "(none detected — expected apps/<name>/{run,main}.ts)" })] }), _jsxs(Box, { children: [_jsx(Box, { width: 10, children: _jsx(Text, { dimColor: true, children: "please" }) }), _jsx(Text, { color: project.hasPlease ? "green" : undefined, children: project.hasPlease ? "ready" : "—" })] }), _jsxs(Box, { children: [_jsx(Box, { width: 10, children: _jsx(Text, { dimColor: true, children: "config" }) }), _jsx(Text, { color: project.hasNwireConfig ? "green" : undefined, children: project.hasNwireConfig ? "nwire.config.ts" : "(default)" })] })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 1, children: [_jsx(Text, { dimColor: true, children: "Try:" }), suggestions.map((s) => (_jsxs(Box, { children: [_jsx(Text, { color: "magenta", children: "  › " }), _jsx(Text, { children: s })] }, s)))] })] }));
 }
-//# sourceMappingURL=greeting.js.map