@north-light/crouter 0.3.170 → 0.3.172

package/dist/core/view/stream-local.js

@@ -1,231 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { CrtrClient, ApiError } from '../../api/index.js';
-import { BrokerClient, BrokerUnavailableError } from '../broker-client/index.js';
-function makeInvalidTargetError(target) {
-    return {
-        kind: 'invalid-target',
-        display: {
-            headline: `invalid stream target: ${target}`,
-            explanation: 'Stream targets must be plain node ids.',
-            nextStep: 'Use a node id without /, \\, or .., then reconnect.',
-            level: 'error',
-            blocking: false,
-        },
-    };
-}
-function makeNoNodeError(target) {
-    return {
-        kind: 'no-node',
-        display: {
-            headline: `node ${target} does not exist`,
-            explanation: 'No node with that id was found in the canvas.',
-            nextStep: 'Check the node id and try again.',
-            level: 'error',
-            blocking: false,
-        },
-    };
-}
-function makeNoBrokerError(target) {
-    return {
-        kind: 'broker-unavailable',
-        display: {
-            headline: `node ${target} has no running broker`,
-            explanation: 'The stream transport connects only to an already-running broker.',
-            nextStep: `Run crtr surface node focus ${target} or crtr node lifecycle revive ${target}, then reconnect.`,
-            level: 'error',
-            blocking: false,
-        },
-    };
-}
-function isValidTarget(target) {
-    return target.length > 0 && !target.includes('/') && !target.includes('\\') && !target.includes('..');
-}
-// A local view stream is a pure broker-IPC consumer (view.sock), so the ONE
-// canvas-state fact it needs — does the node exist, and has it reached a terminal
-// status — goes through crtrd's /v1 API (CrtrClient over the local socket), never
-// a direct canvas-db read: a CLI/view leaf must not open the store (V-1). One
-// lazy client; `autostart: false` because merely observing a node must not boot
-// the daemon.
-let sharedApiClient = null;
-function apiClient() {
-    sharedApiClient ??= CrtrClient.forLocalSocket({ autostart: false });
-    return sharedApiClient;
-}
-/** Node presence for the two facts this stream needs, resolved through the API.
- *  `live` = exists and not terminal (proceed / keep reconnecting); `terminal` =
- *  done|dead|canceled (give up); `gone` = definitively absent, a 404 (no-node);
- *  `unknown` = the daemon was unreachable or errored — we can't tell, so we NEVER
- *  falsely claim absence: the existence check proceeds to the broker path (which
- *  reports no-broker), and reconnect KEEPS RETRYING (only a confirmed
- *  `terminal`/`gone` gives up), so a transient daemon blip can't kill a
- *  recoverable stream. */
-async function nodePresence(target) {
-    try {
-        const status = (await apiClient().getNode(target)).status;
-        if (status === 'done' || status === 'dead' || status === 'canceled')
-            return 'terminal';
-        return 'live';
-    }
-    catch (err) {
-        if (err instanceof ApiError && err.status === 404)
-            return 'gone';
-        return 'unknown';
-    }
-}
-export function openLocalStream(req, handlers) {
-    const channelId = randomUUID();
-    const role = req.role ?? 'controller';
-    let client = null;
-    let closedByView = false;
-    let closeReported = false;
-    let reconnecting = false;
-    let everConnected = false;
-    let initialBrokerUnavailableReported = false;
-    const channel = {
-        id: channelId,
-        send(frame) {
-            client?.send(frame);
-        },
-        close() {
-            closedByView = true;
-            try {
-                client?.close();
-            }
-            catch {
-                /* best-effort */
-            }
-        },
-    };
-    const terminalClose = (reason) => {
-        if (closeReported || closedByView)
-            return;
-        closeReported = true;
-        try {
-            client?.close();
-        }
-        catch {
-            /* best-effort */
-        }
-        try {
-            handlers.onClose(reason);
-        }
-        catch {
-            /* best-effort */
-        }
-    };
-    const reportError = (err) => {
-        if (closeReported || closedByView)
-            return;
-        try {
-            handlers.onError(err);
-        }
-        catch {
-            /* best-effort */
-        }
-    };
-    const deferTerminalFailure = (reason, err) => {
-        queueMicrotask(() => {
-            reportError(err);
-            terminalClose(reason);
-        });
-    };
-    if (!isValidTarget(req.target)) {
-        deferTerminalFailure('invalid stream target', makeInvalidTargetError(req.target));
-        return channel;
-    }
-    const sendHello = () => {
-        client?.send({ type: 'hello', role, client_id: channelId });
-    };
-    const reconnect = async () => {
-        // reconnect only runs after begin() sets `client` and a first connect, so
-        // `client` is non-null here; the guard keeps that a hard invariant.
-        if (closedByView || closeReported || reconnecting || client === null)
-            return;
-        reconnecting = true;
-        let delay = 200;
-        try {
-            while (!closedByView && !closeReported) {
-                try {
-                    await client.redial();
-                    // Reconnected: the broker is serving frames again. Do NOT re-check
-                    // presence here — a slow or `unknown` status call must never tear
-                    // down a stream that has just successfully reconnected.
-                    return;
-                }
-                catch {
-                    if (closedByView || closeReported)
-                        return;
-                    // Redial failed. Give up ONLY when the node is confirmed no longer
-                    // reachable: a terminal status (done|dead|canceled) or a definitive
-                    // 404. `live` and `unknown` (daemon slow/restarting under load) both
-                    // keep retrying — a transient blip must not kill a recoverable stream.
-                    const presence = await nodePresence(req.target);
-                    if (presence === 'terminal' || presence === 'gone') {
-                        terminalClose('broker connection closed');
-                        return;
-                    }
-                    await new Promise((resolve) => setTimeout(resolve, delay));
-                    delay = Math.min(delay * 2, 1000);
-                }
-            }
-        }
-        finally {
-            reconnecting = false;
-        }
-    };
-    // The existence check is a canvas-state read routed through the API, so it is
-    // async: the channel is returned synchronously (callers rely on that) while the
-    // node lookup settles on a later tick. A definitively-absent node (404) reports
-    // no-node then closes; a present or indeterminate node proceeds to open the
-    // broker socket (a missing broker then reports no-broker via the error path).
-    const begin = async () => {
-        if (closedByView || closeReported)
-            return;
-        if ((await nodePresence(req.target)) === 'gone') {
-            reportError(makeNoNodeError(req.target));
-            terminalClose('no node');
-            return;
-        }
-        if (closedByView || closeReported)
-            return;
-        client = new BrokerClient(req.target, { emitUnmatchedDataFrames: true });
-        client.on('connect', () => {
-            if (closedByView || closeReported)
-                return;
-            everConnected = true;
-            sendHello();
-        });
-        client.on('frame', (frame) => {
-            if (closedByView || closeReported)
-                return;
-            try {
-                handlers.onFrame(frame);
-            }
-            catch {
-                /* best-effort */
-            }
-        });
-        client.on('error', (err) => {
-            if (closedByView || closeReported)
-                return;
-            if (err instanceof BrokerUnavailableError && !everConnected && !initialBrokerUnavailableReported) {
-                initialBrokerUnavailableReported = true;
-                reportError(makeNoBrokerError(req.target));
-            }
-        });
-        client.on('close', () => {
-            if (closedByView || closeReported)
-                return;
-            if (reconnecting)
-                return;
-            if (!everConnected) {
-                terminalClose('node has no running broker');
-                return;
-            }
-            void reconnect();
-        });
-        client.connect();
-    };
-    void begin();
-    return channel;
-}

package/dist/core/view/transport-cache.d.ts

@@ -1,8 +0,0 @@
-import type { SourceRequest } from './contract.js';
-import type { Transport } from './transport.js';
-export interface BurstCoalescingOptions {
-    ttlMs: number;
-    shouldCache(req: SourceRequest): boolean;
-    now?: () => number;
-}
-export declare function createBurstCoalescingTransport(inner: Transport, opts: BurstCoalescingOptions): Transport;

package/dist/core/view/transport-cache.js

@@ -1,38 +0,0 @@
-// transport-cache.ts — small host-side burst coalescing for expensive reads.
-//
-// The SourceRequest/Transport contract stays unchanged: callers still send the
-// same request and receive the same RawResponse. This decorator only changes the
-// host's scheduling for requests the host explicitly marks cacheable.
-export function createBurstCoalescingTransport(inner, opts) {
-    const now = opts.now ?? Date.now;
-    const inflight = new Map();
-    const cache = new Map();
-    const send = async (req) => {
-        if (!opts.shouldCache(req))
-            return inner.send(req);
-        const key = JSON.stringify(req);
-        const cached = cache.get(key);
-        if (cached !== undefined) {
-            if (cached.expiresAt > now())
-                return cached.response;
-            cache.delete(key);
-        }
-        const pending = inflight.get(key);
-        if (pending !== undefined)
-            return pending;
-        const run = inner.send(req).then((response) => {
-            cache.set(key, { expiresAt: now() + opts.ttlMs, response });
-            return response;
-        }).finally(() => {
-            inflight.delete(key);
-        });
-        inflight.set(key, run);
-        return run;
-    };
-    return {
-        send,
-        open(req, handlers) {
-            return inner.open(req, handlers);
-        },
-    };
-}

package/dist/core/view/transport-local.d.ts

@@ -1,7 +0,0 @@
-import type { Transport } from './transport.js';
-export interface LocalTransportOptions {
-    /** Working directory for `exec` requests that don't carry their own cwd.
-     *  Defaults to process.cwd(). */
-    cwd?: string;
-}
-export declare function createLocalTransport(opts?: LocalTransportOptions): Transport;

package/dist/core/view/transport-local.js

@@ -1,83 +0,0 @@
-// transport-local.ts — the BUILT local transport: fulfills SourceRequests on
-// this machine. exec→execFile (cwd = the view's cwd unless the request says
-// otherwise), file→readFile, http→fetch.
-//
-// Never throws. Transport-level failure (binary missing, file unreadable,
-// network down) ⇒ { ok:false, stderr }. A spawned process exiting non-zero is
-// transport-level SUCCESS (ok:true + exitCode) — classifying that is the
-// source's parse() job.
-import { execFile } from 'node:child_process';
-import { readFile } from 'node:fs/promises';
-import { openLocalStream } from './stream-local.js';
-const MAX_BUFFER = 10 * 1024 * 1024;
-export function createLocalTransport(opts = {}) {
-    const baseCwd = opts.cwd ?? process.cwd();
-    return {
-        async send(req) {
-            switch (req.kind) {
-                case 'exec': return sendExec(req, baseCwd);
-                case 'file': return sendFile(req);
-                case 'http': return sendHttp(req);
-            }
-        },
-        open(req, handlers) {
-            return openLocalStream(req, handlers);
-        },
-    };
-}
-function sendExec(req, baseCwd) {
-    return new Promise((resolve) => {
-        const child = execFile(req.bin, req.args, { cwd: req.cwd ?? baseCwd, maxBuffer: MAX_BUFFER, encoding: 'utf8' }, (err, stdout, stderr) => {
-            if (!err) {
-                resolve({ ok: true, exitCode: 0, stdout, stderr });
-                return;
-            }
-            const code = err.code;
-            if (typeof code === 'number') {
-                // Ran but exited non-zero: transport-level success; parse() classifies.
-                resolve({ ok: true, exitCode: code, stdout: stdout ?? '', stderr: stderr ?? '' });
-                return;
-            }
-            const signal = err.signal;
-            if (signal) {
-                // Killed by signal: it ran; surface as a non-zero exit. A SIGKILL with
-                // no stderr at all (the live-incident shape: a guest OOM killer takes
-                // out the child before it ever writes anything) used to come back as
-                // a bare `failed (1)` with nothing to explain it — the signal itself
-                // IS the useful diagnostic here, so surface it when stderr is empty
-                // rather than discarding it.
-                const detail = stderr && stderr.trim() !== ''
-                    ? stderr
-                    : `killed by signal ${signal}${signal === 'SIGKILL' ? ' (often out-of-memory)' : ''}`;
-                resolve({ ok: true, exitCode: 1, stdout: stdout ?? '', stderr: detail });
-                return;
-            }
-            // Spawn-level failure (ENOENT/EACCES/maxBuffer): transport failure.
-            const msg = code === 'ENOENT' ? `${req.bin}: command not found` : err.message;
-            resolve({ ok: false, stdout: stdout ?? '', stderr: msg });
-        });
-        if (req.stdin != null && child.stdin) {
-            child.stdin.write(req.stdin);
-            child.stdin.end();
-        }
-    });
-}
-async function sendFile(req) {
-    try {
-        const text = await readFile(req.path, 'utf8');
-        return { ok: true, stdout: text, stderr: '' };
-    }
-    catch (e) {
-        return { ok: false, stdout: '', stderr: e instanceof Error ? e.message : String(e) };
-    }
-}
-async function sendHttp(req) {
-    try {
-        const res = await fetch(req.url, { method: req.method, headers: req.headers, body: req.body });
-        const body = await res.text();
-        return { ok: true, status: res.status, stdout: body, stderr: res.ok ? '' : res.statusText };
-    }
-    catch (e) {
-        return { ok: false, stdout: '', stderr: e instanceof Error ? e.message : String(e) };
-    }
-}

package/dist/core/view/transport-remote.d.ts

@@ -1,2 +0,0 @@
-import type { RawResponse } from './contract.js';
-export declare function createRemoteExec(previewEndpoint: string, relayToken: string, timeoutMs?: number): (bin: string, args: string[]) => Promise<RawResponse>;

package/dist/core/view/transport.d.ts

@@ -1,10 +0,0 @@
-import type { SourceRequest, RawResponse, StreamRequest, StreamChannel, SourceError } from './contract.js';
-export interface StreamHandlers {
-    onFrame(frame: unknown): void;
-    onClose(reason: string): void;
-    onError(err: SourceError): void;
-}
-export interface Transport {
-    send(req: SourceRequest): Promise<RawResponse>;
-    open(req: StreamRequest, handlers: StreamHandlers): StreamChannel;
-}

package/dist/core/view/transport.js

@@ -1,15 +0,0 @@
-// transport.ts — the transport seam between a view's declarative SourceRequests
-// and whatever fulfills them.
-//
-// The core is transport-blind: it only ever calls ctx.resolve(source, args) /
-// ctx.execute(command, args); the host threads Transport.send → source.parse.
-// Implementations:
-//   • transport-local.ts (BUILT) — Node-side: exec→execFile, file→readFile,
-//     http→fetch. Used directly by the TUI host and by the `view serve` bridge
-//     server on behalf of the browser bundle.
-//   • src/web/transport-http.ts (BUILT) — browser-side: POSTs the SourceRequest
-//     to the local bridge (`/__crtr/source`).
-//   • cloud (SEAM ONLY, not built) — same interface; send() POSTs the request
-//     to an endpoint that runs it server-side, or maps it to a real API call.
-//     Wiring a different Transport is the entire cloud migration.
-export {};

package/dist/pi-extensions/naming-tool.d.ts

@@ -1,24 +0,0 @@
-interface PiLike {
-    registerTool: (definition: Record<string, unknown>) => void;
-}
-/** The naming schema — the ONE definition of what a generated session name is.
- *  Both fields are required: a name without an icon renders a bare label, and
- *  an icon without a name is useless, so the model is made to decide both in a
- *  single constrained emission. */
-export declare const NAME_SESSION_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly name: {
-            readonly type: "string";
-            readonly description: "A 3-8 word kebab-case session name: lowercase words joined by single hyphens, e.g. refactor-auth-token-flow. No punctuation, quotes, or prose.";
-        };
-        readonly icon: {
-            readonly type: "string";
-            readonly description: "The Nerd Font glyph depicting this session, as a codepoint in U+XXXX form (e.g. U+F188).";
-        };
-    };
-    readonly required: readonly ["name", "icon"];
-    readonly additionalProperties: false;
-};
-export declare function registerNamingTool(pi: PiLike): void;
-export default registerNamingTool;

package/dist/pi-extensions/naming-tool.js

@@ -1,67 +0,0 @@
-// naming-tool.ts — the structured-output seam for session naming.
-//
-// Loaded ONLY by the headless namer subprocess (`runtime/naming.ts` passes it
-// with `-e` alongside `--no-extensions`), never by a canvas node. It registers a
-// single `name_session` tool whose parameters ARE the naming schema, with
-// pi's constrained sampling turned on, so the light model emits a real typed
-// object instead of prose we have to parse out of a text reply.
-//
-// The result travels back to the parent over a file: the parent creates a temp
-// path, passes it as CRTR_NAME_RESULT_FILE, and reads it after the subprocess
-// exits. stdout is unusable for this — pi print-mode writes its own chatter
-// there.
-//
-// Inert (registers nothing) when CRTR_NAME_RESULT_FILE is absent, so an
-// accidental load in any other context is a no-op.
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-/** The naming schema — the ONE definition of what a generated session name is.
- *  Both fields are required: a name without an icon renders a bare label, and
- *  an icon without a name is useless, so the model is made to decide both in a
- *  single constrained emission. */
-export const NAME_SESSION_SCHEMA = {
-    type: 'object',
-    properties: {
-        name: {
-            type: 'string',
-            description: 'A 3-8 word kebab-case session name: lowercase words joined by single hyphens, e.g. refactor-auth-token-flow. No punctuation, quotes, or prose.',
-        },
-        icon: {
-            type: 'string',
-            description: 'The Nerd Font glyph depicting this session, as a codepoint in U+XXXX form (e.g. U+F188).',
-        },
-    },
-    required: ['name', 'icon'],
-    additionalProperties: false,
-};
-export function registerNamingTool(pi) {
-    const out = process.env['CRTR_NAME_RESULT_FILE'];
-    if (out === undefined || out.trim() === '')
-        return;
-    pi.registerTool({
-        name: 'name_session',
-        label: 'Name session',
-        description: 'Record the name and icon for this coding session. Call exactly once, then stop.',
-        parameters: NAME_SESSION_SCHEMA,
-        // Ask the provider to constrain sampling to the schema. `prefer` degrades
-        // silently on a model without strict tool support (`require` would fail the
-        // whole request); the parent validates and falls back to a local slug
-        // either way, so this only makes a malformed emission rarer.
-        constrainedSampling: { type: 'json_schema', strict: 'prefer' },
-        execute(_id, params) {
-            try {
-                mkdirSync(dirname(out), { recursive: true });
-                writeFileSync(out, JSON.stringify(params ?? {}), 'utf8');
-            }
-            catch {
-                // The parent falls back to a local slug when the file never lands.
-            }
-            return {
-                content: [{ type: 'text', text: 'Recorded.' }],
-                details: { recorded: true },
-                terminate: true,
-            };
-        },
-    });
-}
-export default registerNamingTool;

package/dist/prompts/view.d.ts

@@ -1,7 +0,0 @@
-export interface ViewScaffoldVars {
-    id: string;
-    title: string;
-    description: string;
-}
-/** Build every file of a freshly scaffolded dual-target view, keyed by filename. */
-export declare function viewScaffold(v: ViewScaffoldVars): Record<string, string>;

package/dist/prompts/view.js

@@ -1,172 +0,0 @@
-// Scaffold stubs for surface-view authoring. Returns the four files of a dual-target
-// view directory — a portable `core.mjs` plus the TUI / web / text presenters —
-// that runs as-is via the surface view host (TUI/static snapshot) and the surface
-// web server (browser).
-//
-// Authoring guidance lives INSIDE each stub (the comment block at the top of the
-// generated file), so a view author reads the contract right where they edit.
-/** Escape a value for embedding inside a single-quoted JS string literal. */
-function jsStr(s) {
-    return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-}
-/** The portable core: manifest · init · sources · intents. Runs in BOTH Node
- *  (the TUI host) and the browser (the web bundle) — imports NOTHING. */
-function coreStub(v) {
-    const id = jsStr(v.id);
-    const title = jsStr(v.title);
-    const description = jsStr(v.description);
-    return `// ${v.title} — portable core (manifest · init · sources · intents).
-//
-// Runs in BOTH Node (the TUI host) and the browser (the web bundle), so it
-// imports NOTHING — no \`node:*\`, no crtr. ALL state + behavior live here;
-// presenters (tui.mjs / web.jsx) are pure reads that dispatch named intents.
-//
-//   Run it through the surface view host for TUI/static snapshots, or through
-//   the surface web server for the React + Tailwind browser page.
-//
-// THE CONTRACT:
-//   manifest          { id, title, description, refreshMs? } — id MUST equal
-//                     this view's directory name.
-//   init(opts)        cheap, SYNCHRONOUS initial state — NO fetch, NO screen.
-//                     CLI flags arrive in \`opts\` (for example port/target options).
-//   sources           { request, parse } READ descriptors. The host's transport
-//                     runs request() (exec/file/http) and hands parse() the bytes
-//                     — your parse is pure, runs in Node AND the browser.
-//   intents           semantic actions both targets dispatch. State updates are
-//                     IMMUTABLE via ctx.set; async effects (ctx.resolve a source)
-//                     live in the same handler. ctx.signal raises chrome signals.
-
-/** A READ source: a transport-agnostic request + a pure parse. */
-export const clockSource = {
-  id: 'clock',
-  request: () => ({ kind: 'exec', bin: 'date', args: [] }),
-  parse: (raw) =>
-    raw.ok && raw.exitCode === 0
-      ? { ok: true, data: raw.stdout.trim() }
-      : { ok: false, error: { kind: 'clock-failed', display: {
-          headline: 'Could not read the clock',
-          explanation: raw.stderr || 'the date command failed',
-          nextStep: 'Check the \`date\` binary is on PATH.',
-          level: 'error', blocking: true } } },
-};
-
-/** @type {import('@north-light/crouter/dist/core/view/contract.js').ViewCore} */
-const core = {
-  manifest: {
-    id: '${id}',
-    title: '${title}',
-    description: '${description}',
-    // refreshMs: 30000,   // uncomment to auto-poll; omit ⇒ on-demand (g) only
-  },
-
-  // Cheap, synchronous setup. Stash CLI flags off \`opts\` here.
-  init: (opts) => ({ count: 0, clock: null, port: opts.port ?? null }),
-
-  sources: { clockSource },
-
-  intents: {
-    // Async intent: ctx.set updates state immutably; ctx.resolve runs a source
-    // through the host transport. The host runs 'refresh' on launch, every
-    // manifest.refreshMs (if set), and on the \`g\` key (see tui.mjs).
-    async refresh(ctx) {
-      ctx.signal.setStatus('Reading clock…');
-      const r = await ctx.resolve(clockSource);
-      if (!r.ok) { ctx.signal.setBanner(r.error.display.headline, r.error.display.level); ctx.signal.setStatus(null); return; }
-      ctx.set((s) => ({ ...s, count: s.count + 1, clock: r.data }));
-      ctx.signal.clearBanner();
-      ctx.signal.setStatus(\`refreshed \${ctx.state.count}×\`);
-    },
-    quit: (ctx) => ctx.signal.quit(),
-  },
-};
-
-export default core;
-`;
-}
-/** The TUI presenter: render(state, draw, content) + keymap. Node only. */
-function tuiStub(v) {
-    const title = jsStr(v.title);
-    return `// ${v.title} — TUI presenter: render(state, draw, content) + keymap.
-//
-// A pure read of state — paint via draw.*; NEVER write ANSI. Keys map to the
-// core's intents (no logic here; the keymap names an intent, the host dispatches).
-//
-// draw API (all absolute cells inside \`content\`):
-//   draw.text(row,col,text,style?)            · draw.spans(row,col,spans,maxWidth?)
-//   draw.hline(row,fromCol?,toCol?)           · draw.box(rect,title?)
-//   draw.columns(rect,[1,2]) -> Rect[]        · draw.list(rect,items,cursor,scroll)
-//   style: { fg, bg, bold, dim, reverse }     (fg/bg honored only when color is on)
-
-export const keymap = [
-  { keys: ['g'], intent: 'refresh', hint: { keys: 'g', label: 'refresh' } },
-  { keys: ['q'], intent: 'quit', hint: { keys: 'q', label: 'quit' } },
-];
-
-export function render(state, draw, content) {
-  draw.text(content.row, content.col, '${title}', { bold: true });
-  draw.text(content.row + 2, content.col, \`clock: \${state.clock ?? '(loading…)'}\`);
-  draw.text(content.row + 3, content.col, \`refreshed \${state.count} time(s)\`, { dim: true });
-  draw.text(content.row + 4, content.col, \`port option: \${state.port ?? '(none)'}\`, { dim: true });
-  draw.text(content.row + 6, content.col, 'Edit core.mjs + tui.mjs to build your view — g refreshes, q quits.', { dim: true });
-}
-`;
-}
-/** The web presenter: a React + Tailwind component. Browser only (Vite owns the
- *  JSX + Tailwind transpile; this file is NEVER Node-imported). */
-function webStub(v) {
-    const title = jsStr(v.title);
-    return `// ${v.title} — web presenter: a React + Tailwind component.
-//
-// A pure function of \`state\`; DOM events call \`dispatch(intent)\`. Consumed ONLY
-// by the surface web host (Vite owns JSX + Tailwind) — never Node-imported. The
-// SAME state + intents the TUI reads; zero shared render code (an intentional fork).
-
-export default function View({ state, dispatch }) {
-  return (
-    <div
-      className="font-mono text-sm p-4 outline-none"
-      tabIndex={0}
-      onKeyDown={(e) => { if (e.key === 'g') dispatch('refresh'); }}
-    >
-      <h1 className="text-lg font-bold">${title}</h1>
-      <p className="mt-2">clock: {state.clock ?? '(loading…)'}</p>
-      <p className="text-gray-500">refreshed {state.count} time(s)</p>
-      <button
-        className="mt-3 rounded bg-blue-600 px-2 py-1 text-white hover:bg-blue-500"
-        onClick={() => dispatch('refresh')}
-      >
-        Refresh
-      </button>
-    </div>
-  );
-}
-`;
-}
-/** The text presenter: the piped / non-TTY snapshot. Node only. Optional — omit
- *  it and the host synthesizes a generic one-line dump. */
-function textStub(v) {
-    const title = jsStr(v.title);
-    return `// ${v.title} — text presenter: the piped / non-TTY snapshot (exits 0).
-//
-// A pure read of current state. Omit this file and the host synthesizes a
-// one-line dump (\`<title> — <n> items\`).
-
-export function dump(state) {
-  return [
-    '${title}',
-    '',
-    \`clock: \${state.clock ?? '(none)'}\`,
-    \`refreshed \${state.count} time(s)\`,
-  ].join('\\n');
-}
-`;
-}
-/** Build every file of a freshly scaffolded dual-target view, keyed by filename. */
-export function viewScaffold(v) {
-    return {
-        'core.mjs': coreStub(v),
-        'tui.mjs': tuiStub(v),
-        'web.jsx': webStub(v),
-        'text.mjs': textStub(v),
-    };
-}