@north-light/crouter 0.3.318 → 0.3.320

package/dist/build-root.js

@@ -1,198 +1 @@
-import { defineBranch, defineRoot, GLOBAL_TOKENS } from './core/command.js';
-import { createCoreHookCatalog } from './core/command-hooks/catalog.js';
-import { composeCoreHooks } from './core/command-hooks/compose.js';
-import { mark } from './core/timing.js';
-const TAGLINE = 'crtr: agentic runtime.';
-/** Flags handled before dispatch, so they belong to no leaf schema and are
- *  stated once at root (help.ts renders them as the Globals footer). */
-const GLOBALS = [
-    {
-        name: '--json',
-        desc: "stdout as the leaf's declared outputs in raw JSON instead of prose — for scripts (a cron's bash, external tooling) that must branch on canvas state; prose stays the contract for what you read yourself.",
-    },
-];
-/** Lazy registry: subtree name → dynamic importer that builds its BranchDef.
- *  The whole point is that each `import()` only compiles that one subtree's
- *  module graph. The hot path (`crtr surface node focus …`, `crtr push …`, …) dispatches
- *  into a single leaf, so it must load ONE subtree — not the attach TUI and
- *  every other subtree it never touches. `crtr` cold-start is dominated by Node
- *  module loading; keeping the
- *  other subtrees off the path is the biggest, lowest-risk win.
- *
- *  Null-prototype: `resolveRoot` indexes this by the raw first argv token, so a
- *  normal object literal would resolve `Object.prototype` members — `crtr
- *  toString` would build a root from a non-loader and report "Valid children:"
- *  with nothing after it, and `crtr hasOwnProperty` would die untyped. With no
- *  prototype every non-subtree token misses and falls through to the real
- *  unknown-path error. */
-const SUBTREE_LOADERS = Object.assign(Object.create(null), {
-    memory: async () => (await import('./commands/memory.js')).registerMemory(),
-    profile: async () => (await import('./commands/profile.js')).registerProfile(),
-    pkg: async () => (await import('./commands/pkg.js')).registerPkg(),
-    human: async () => (await import('./commands/human.js')).registerHuman(),
-    sys: async () => (await import('./commands/sys.js')).registerSys(),
-    node: async () => (await import('./commands/node.js')).registerNode(),
-    push: async () => (await import('./commands/push.js')).registerPush(),
-    cron: async () => (await import('./commands/cron.js')).registerCron(),
-    canvas: async () => (await import('./commands/canvas.js')).registerCanvas(),
-    surface: async () => (await import('./commands/surface.js')).registerSurface(),
-});
-/** Every shipped subtree name. Cheap (no module loading) — the front-door
- *  recursion guard and the dispatcher's first-token routing need only names. */
-export const SUBTREE_NAMES = Object.freeze(Object.keys(SUBTREE_LOADERS));
-/** Every core command path, space-joined ("cron", "cron add", …) — the set
- *  plugin `helpAddenda` keys are validated against at the strict gates
- *  (install, bundle parse, doctor/inspect reports). Loads every core subtree,
- *  so call it only from those gates, never on a dispatch path. Passthrough
- *  branches are excluded: crtr never renders their help, so an addendum
- *  targeting one could never appear. */
-/** Every core subtree, built once per process. The hook catalog and the full
- *  root both need the complete set; a recognized core first token still loads
- *  only its own subtree until something actually demands the whole tree. */
-let coreSubtrees;
-function loadCoreSubtrees() {
-    coreSubtrees ??= Promise.all(SUBTREE_NAMES.map((n) => SUBTREE_LOADERS[n]()));
-    return coreSubtrees;
-}
-/** Complete static catalog of hook-eligible core leaves. Lifecycle and recovery
- *  inspection share the same memoized subtree load as root composition. */
-let hookCatalog;
-export function coreHookCatalog() {
-    mark('cli.hooks.catalog');
-    hookCatalog ??= loadCoreSubtrees().then(createCoreHookCatalog);
-    return hookCatalog;
-}
-/** A loader for the effective hook registry, compiled over the COMPLETE core
- *  catalog so a hook targeting any other subtree is never mistaken for a stale
- *  target. Loading is lazy — only eligible leaf help or dispatch reaches it,
- *  and static help discovery never runs a plugin executable. The memoization
- *  is per composed root, never process-global: discovery reads
- *  stored plugin bytes and the caller's scope stack, so a plugin install,
- *  update, or disable (and a cwd change in a long-lived host) must govern the
- *  next root instead of being pinned by the first one. */
-function hookRegistryLoader() {
-    let registry;
-    return () => {
-        // Dynamic import keeps hook discovery (manifest/artifact validation, plugin
-        // resolution) off the module graph of an invocation that neither renders
-        // eligible leaf help nor dispatches one, matching this file's lazy rationale.
-        registry ??= (async () => {
-            const { compileHookRegistry, effectiveHookPlugins } = await import('./core/command-hooks/discovery.js');
-            const plugins = effectiveHookPlugins();
-            mark('cli.hooks.effective_plugins', { count: plugins.length });
-            if (plugins.length === 0) {
-                mark('cli.hooks.empty_registry');
-                return compileHookRegistry(createCoreHookCatalog([]), []);
-            }
-            return compileHookRegistry(await coreHookCatalog(), plugins);
-        })();
-        return registry;
-    };
-}
-function commandPathsFor(core) {
-    const paths = new Set();
-    const visit = (node, prefix) => {
-        if (node.kind === 'branch' && node.passthrough !== undefined)
-            return;
-        paths.add(prefix);
-        if (node.kind === 'branch')
-            for (const child of node.children)
-                visit(child, `${prefix} ${child.name}`);
-    };
-    for (const subtree of core)
-        visit(subtree, subtree.name);
-    return paths;
-}
-export async function coreCommandPaths() {
-    return commandPathsFor(await loadCoreSubtrees());
-}
-export async function extensibleCoreBranches() {
-    return new Set((await loadCoreSubtrees()).filter((branch) => branch.extensible === true).map((branch) => branch.name));
-}
-async function composeCorePluginMounts(core) {
-    const extensible = new Set(core.filter((branch) => branch.extensible === true).map((branch) => branch.name));
-    if (extensible.size === 0)
-        return core;
-    const [{ buildExternalCommandSnapshot }, { composeCoreBranchMounts }] = await Promise.all([
-        import('./core/command-plugins/discovery.js'),
-        import('./core/command-plugins/compose.js'),
-    ]);
-    const snapshot = buildExternalCommandSnapshot(new Set(SUBTREE_NAMES), undefined, undefined, commandPathsFor(core), extensible);
-    return core.map((branch) => {
-        const mounted = composeCoreBranchMounts(snapshot.coreMounts, [branch.name]);
-        if (mounted.length === 0)
-            return branch;
-        const { listing: _listing, ...help } = branch.help;
-        return defineBranch({
-            name: branch.name,
-            ...(branch.description !== undefined ? { description: branch.description } : {}),
-            ...(branch.whenToUse !== undefined ? { whenToUse: branch.whenToUse } : {}),
-            ...(branch.tier !== undefined ? { tier: branch.tier } : {}),
-            ...(branch.rootEntry !== undefined ? { rootEntry: branch.rootEntry } : {}),
-            ...(branch.extensible === true ? { extensible: true } : {}),
-            ...(branch.slash !== undefined ? { slash: branch.slash } : {}),
-            ...(branch.passthrough !== undefined ? { passthrough: branch.passthrough } : {}),
-            help,
-            children: [...branch.children, ...mounted],
-        });
-    });
-}
-/** Whether argv targets the daemon-control subtree after the dispatcher's global-token normalization. This only selects a smaller canonical tree; `runCli` still parses, renders help, and reports errors. */
-export function isDaemonControlInvocation(argv) {
-    const tokens = argv.slice(2).filter((token) => !GLOBAL_TOKENS.has(token));
-    return tokens[0] === 'sys' && tokens[1] === 'daemon';
-}
-/** Assemble the canonical daemon-control definitions without loading settings or plugin discovery. This path exists so `crtr sys daemon restart` can start the new generation that converts pre-SQL user state. */
-export async function resolveDaemonControlRoot() {
-    const { registerDaemonControlSys } = await import('./commands/sys/daemon.js');
-    return defineRoot({ tagline: TAGLINE, globals: GLOBALS, subtrees: [registerDaemonControlSys()] });
-}
-/** Build a root that contains only the subtree `first` dispatches into.
- *  Returns the FULL root when `first` is not a recognized subtree — bare `crtr`,
- *  `-h`/`--help`, `--version`, and any unknown leading token all need the
- *  complete tree (root -h lists every subtree; the unknown-path error names
- *  every valid child). This keeps every help/error surface byte-identical while
- *  the common leaf-dispatch path loads exactly one subtree. */
-export async function resolveRoot(first) {
-    const loader = first !== undefined ? SUBTREE_LOADERS[first] : undefined;
-    if (loader !== undefined) {
-        const core = [await loader()];
-        return defineRoot({ tagline: TAGLINE, globals: GLOBALS, subtrees: composeCoreHooks(await composeCorePluginMounts(core), hookRegistryLoader()) });
-    }
-    return buildRoot();
-}
-/** Assemble the full crtr command tree: every core subtree plus every top-level
- *  branch contributed by an external command source — enabled command plugins
- *  AND registered HTTP-transport plugins, folded together through ONE unified,
- *  collision-resolved snapshot (`buildExternalCommandSnapshot`). Used for root
- *  -h, the unknown-path error, bare-root boot, front-door recognition, and the
- *  listing-completeness test — i.e. only the FALLTHROUGH path, never the core
- *  fast path (`resolveRoot` short-circuits a recognized core first token with
- *  zero plugin transport I/O). Root owns only the tagline; every subtree (core or
- *  external) declares its own root representation via its rootEntry.
- *
- *  Order is deterministic: core subtrees in declared order first, then accepted
- *  external branches sorted by contributor name (from the unified snapshot).
- *  Composition is invocation-local and reads only stored manifest bytes — no
- *  cache, no persistence, ZERO network — so a plugin enable/update/remove or an
- *  HTTP-transport plugin manifest replacement takes effect on the next invocation
- *  automatically. Composition performs no network I/O. */
-export async function buildRoot() {
-    const core = await loadCoreSubtrees();
-    // Dynamic import keeps external command discovery/compose (plugin +
-    // HTTP-transport plugin, and their resolver/manifest/HTTP deps) OFF the hot leaf
-    // path's module graph — they load only here, on the fallthrough, matching
-    // this file's lazy-subtree rationale.
-    const [{ buildExternalCommandSnapshot }, { composeExternalSubtrees }] = await Promise.all([
-        import('./core/command-plugins/discovery.js'),
-        import('./core/command-plugins/compose.js'),
-    ]);
-    // ONE collision-resolved snapshot over every command plugin transport. Core always wins: any external contribution claiming a core top-level
-    // name is dropped + recorded as an issue (surfaced via pkg plugin show,
-    // sys doctor). Reads only stored manifests — zero network.
-    const composedCore = await composeCorePluginMounts(core);
-    const snapshot = buildExternalCommandSnapshot(new Set(SUBTREE_NAMES), undefined, undefined, commandPathsFor(core), new Set(composedCore.filter((branch) => branch.extensible === true).map((branch) => branch.name)));
-    const external = composeExternalSubtrees(snapshot);
-    // Only core leaves are hookable, so external contributions compose unwrapped.
-    return defineRoot({ tagline: TAGLINE, globals: GLOBALS, subtrees: [...composeCoreHooks(composedCore, hookRegistryLoader()), ...external] });
-}
+var E=Object.defineProperty;var o=(e,n)=>E(e,"name",{value:n,configurable:!0});import{defineBranch as b,defineRoot as u,GLOBAL_TOKENS as P}from"./core/command.js";import{createCoreHookCatalog as y}from"./core/command-hooks/catalog.js";import{composeCoreHooks as h}from"./core/command-hooks/compose.js";import{mark as l}from"./core/timing.js";const m="crtr: agentic runtime.",p=[{name:"--json",desc:"stdout as the leaf's declared outputs in raw JSON instead of prose \u2014 for scripts (a cron's bash, external tooling) that must branch on canvas state; prose stays the contract for what you read yourself."}],d=Object.assign(Object.create(null),{memory:o(async()=>(await import("./commands/memory.js")).registerMemory(),"memory"),profile:o(async()=>(await import("./commands/profile.js")).registerProfile(),"profile"),pkg:o(async()=>(await import("./commands/pkg.js")).registerPkg(),"pkg"),human:o(async()=>(await import("./commands/human.js")).registerHuman(),"human"),sys:o(async()=>(await import("./commands/sys.js")).registerSys(),"sys"),node:o(async()=>(await import("./commands/node.js")).registerNode(),"node"),push:o(async()=>(await import("./commands/push.js")).registerPush(),"push"),cron:o(async()=>(await import("./commands/cron.js")).registerCron(),"cron"),canvas:o(async()=>(await import("./commands/canvas.js")).registerCanvas(),"canvas"),surface:o(async()=>(await import("./commands/surface.js")).registerSurface(),"surface")}),f=Object.freeze(Object.keys(d));let w;function c(){return w??=Promise.all(f.map(e=>d[e]())),w}o(c,"loadCoreSubtrees");let S;function v(){return l("cli.hooks.catalog"),S??=c().then(y),S}o(v,"coreHookCatalog");function x(){let e;return()=>(e??=(async()=>{const{compileHookRegistry:n,effectiveHookPlugins:s}=await import("./core/command-hooks/discovery.js"),r=s();return l("cli.hooks.effective_plugins",{count:r.length}),r.length===0?(l("cli.hooks.empty_registry"),n(y([]),[])):n(await v(),r)})(),e)}o(x,"hookRegistryLoader");function g(e){const n=new Set,s=o((r,i)=>{if(!(r.kind==="branch"&&r.passthrough!==void 0)&&(n.add(i),r.kind==="branch"))for(const t of r.children)s(t,`${i} ${t.name}`)},"visit");for(const r of e)s(r,r.name);return n}o(g,"commandPathsFor");async function j(){return g(await c())}o(j,"coreCommandPaths");async function A(){return new Set((await c()).filter(e=>e.extensible===!0).map(e=>e.name))}o(A,"extensibleCoreBranches");async function C(e){const n=new Set(e.filter(t=>t.extensible===!0).map(t=>t.name));if(n.size===0)return e;const[{buildExternalCommandSnapshot:s},{composeCoreBranchMounts:r}]=await Promise.all([import("./core/command-plugins/discovery.js"),import("./core/command-plugins/compose.js")]),i=s(new Set(f),void 0,void 0,g(e),n);return e.map(t=>{const a=r(i.coreMounts,[t.name]);if(a.length===0)return t;const{listing:R,...k}=t.help;return b({name:t.name,...t.description!==void 0?{description:t.description}:{},...t.whenToUse!==void 0?{whenToUse:t.whenToUse}:{},...t.tier!==void 0?{tier:t.tier}:{},...t.rootEntry!==void 0?{rootEntry:t.rootEntry}:{},...t.extensible===!0?{extensible:!0}:{},...t.slash!==void 0?{slash:t.slash}:{},...t.passthrough!==void 0?{passthrough:t.passthrough}:{},help:k,children:[...t.children,...a]})})}o(C,"composeCorePluginMounts");function M(e){const n=e.slice(2).filter(s=>!P.has(s));return n[0]==="sys"&&n[1]==="daemon"}o(M,"isDaemonControlInvocation");async function N(){const{registerDaemonControlSys:e}=await import("./commands/sys/daemon.js");return u({tagline:m,globals:p,subtrees:[e()]})}o(N,"resolveDaemonControlRoot");async function U(e){const n=e!==void 0?d[e]:void 0;if(n!==void 0){const s=[await n()];return u({tagline:m,globals:p,subtrees:h(await C(s),x())})}return O()}o(U,"resolveRoot");async function O(){const e=await c(),[{buildExternalCommandSnapshot:n},{composeExternalSubtrees:s}]=await Promise.all([import("./core/command-plugins/discovery.js"),import("./core/command-plugins/compose.js")]),r=await C(e),i=n(new Set(f),void 0,void 0,g(e),new Set(r.filter(a=>a.extensible===!0).map(a=>a.name))),t=s(i);return u({tagline:m,globals:p,subtrees:[...h(r,x()),...t]})}o(O,"buildRoot");export{f as SUBTREE_NAMES,O as buildRoot,j as coreCommandPaths,v as coreHookCatalog,A as extensibleCoreBranches,M as isDaemonControlInvocation,N as resolveDaemonControlRoot,U as resolveRoot};

package/dist/cli.js

@@ -1,100 +1,4 @@
 #!/usr/bin/env node
-import './suppress-experimental-warnings.js';
-import { openSync } from 'node:fs';
-import { enableCompileCache } from 'node:module';
-import { fileURLToPath } from 'node:url';
-import { isDaemonControlInvocation, resolveDaemonControlRoot, resolveRoot } from './build-root.js';
-import { maybeBootRoot } from './core/runtime/front-door.js';
-import { maybeAutoUpdate } from './core/auto-update.js';
-import { ensureProjectScope } from './core/bootstrap.js';
-import { provisionExports, pruneLegacyExports } from './core/host-exports/export.js';
-import { revalidateBundlePlugins } from './core/command-plugins/revalidate.js';
-import { runCli } from './core/command.js';
-import { dispatchWithStaleRecovery } from './core/manifest-recovery.js';
-import { installStdoutErrorPolicy } from './core/stdout-errors.js';
-import { handle } from './core/io.js';
-import { CrtrError } from './core/errors.js';
-import { ApiError } from './api/index.js';
-import { mark } from './core/timing.js';
-// Keep this runtime generation visible to installer GC for this CLI process's lifetime.
-openSync(fileURLToPath(import.meta.url), 'r');
-installStdoutErrorPolicy();
-// CRTR_TIMING=1 phase markers (src/core/timing.ts). This is the first one, and
-// its `up=` column is how long node itself took to boot and evaluate the cli
-// entry's static import graph before any crtr code ran.
-mark('cli.entry', { cmd: process.argv[2] ?? '(bare)' });
-// V8 compile-cache (Node 22+): persist compiled bytecode across runs so a cold
-// `crtr` re-spawn skips recompiling its module graph. Biggest payoff is the
-// heavy attach-viewer bundle that main() dynamic-imports via resolveRoot — this
-// runs first, so the cache is active before that import() compiles. Measured
-// neutral on the tiny leaf path (feed/node), a clear win on attach. Best-effort:
-// older Node lacks the API.
-try {
-    enableCompileCache();
-}
-catch { /* pre-22 Node: no compile cache */ }
-mark('cli.compile_cache');
-async function main() {
-    // Prune legacy generated host artifacts before the front door can boot pi,
-    // otherwise stale Agent Skills can leak into the prompt for bare `crtr`. The
-    // prune needs no command tree; the export WRITES do, and bare `crtr` skips
-    // them, so they run after the front door instead.
-    pruneLegacyExports(process.argv);
-    // The front door: bare `crtr` (or `crtr [dir] ["prompt"]`) boots a resident
-    // root node and execs pi in this terminal. Recognized subcommands fall through
-    // to the normal dispatcher. Must run before anything that assumes a subcommand
-    // — and BEFORE the command tree is assembled, which a root boot never reads.
-    if (await maybeBootRoot(process.argv)) {
-        // bootRoot exec'd pi inline and exited; unreachable.
-    }
-    mark('cli.front_door_passed');
-    // Daemon control must remain callable immediately after an upgrade: its
-    // selected successor performs the user/provider store conversion, so this
-    // dispatch cannot first read scoped settings, installed plugins, or hooks.
-    // The compact tree reuses the daemon definitions and the normal dispatcher.
-    if (isDaemonControlInvocation(process.argv)) {
-        await runCli(await resolveDaemonControlRoot(), process.argv);
-        return;
-    }
-    // Bring installed bundle plugins back in step with their endpoints before the
-    // tree is built, so a package this pass replaces is the one this invocation
-    // dispatches against. TTL-gated and non-fatal — see revalidate.ts.
-    await revalidateBundlePlugins(process.argv);
-    mark('cli.plugins_revalidated');
-    // Lazy command tree: load only the subtree this invocation dispatches into.
-    // resolveRoot returns the full tree only for help/version/unknown, where
-    // every subtree is genuinely needed (root -h, the unknown-path error). The
-    // hot leaf-dispatch path loads one subtree, keeping the other 11 and their
-    // heavy dependencies — including the attach TUI — off cold-start.
-    const root = await resolveRoot(process.argv[2]);
-    mark('cli.root_resolved');
-    provisionExports(root, process.argv);
-    ensureProjectScope(process.argv);
-    maybeAutoUpdate(process.argv);
-    mark('cli.dispatch_start');
-    await dispatchWithStaleRecovery(root, process.argv);
-    mark('cli.dispatch_done');
-}
-main().catch((err) => {
-    // A command stopped mid-run (Ctrl-C / an aborted AbortSignal) surfaces as an
-    // AbortError whose default message is "This operation was aborted" — noise for
-    // an intentional interrupt. Report it as a plain "Interrupted" instead.
-    const isAbort = (err instanceof Error && err.name === 'AbortError') ||
-        (err instanceof Error && /operation was aborted/i.test(err.message));
-    if (isAbort) {
-        process.stderr.write('crtr: Interrupted\n');
-        process.exit(130);
-    }
-    // Front-door boot/resume (`maybeBootRoot`) runs before the dispatcher's own
-    // `handle()`, so route its structured failures through the same contract: a
-    // daemon-down `ApiError` maps to NETWORK exit + the start-crtrd hint instead
-    // of a raw message at exit 1. Generic (non-structured) throws keep the plain
-    // front-door print.
-    if (err instanceof ApiError || err instanceof CrtrError) {
-        handle(err);
-        process.exit(typeof process.exitCode === 'number' ? process.exitCode : 1);
-    }
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`crtr: ${msg}\n`);
-    process.exit(1);
-});
+var s=Object.defineProperty;var e=(o,t)=>s(o,"name",{value:t,configurable:!0});import"./suppress-experimental-warnings.js";import{openSync as a}from"node:fs";import{enableCompileCache as c}from"node:module";import{fileURLToPath as p}from"node:url";import{isDaemonControlInvocation as m,resolveDaemonControlRoot as n,resolveRoot as f}from"./build-root.js";import{maybeBootRoot as l}from"./core/runtime/front-door.js";import{maybeAutoUpdate as d}from"./core/auto-update.js";import{ensureProjectScope as v}from"./core/bootstrap.js";import{provisionExports as g,pruneLegacyExports as u}from"./core/host-exports/export.js";import{revalidateBundlePlugins as b}from"./core/command-plugins/revalidate.js";import{runCli as h}from"./core/command.js";import{dispatchWithStaleRecovery as y}from"./core/manifest-recovery.js";import{installStdoutErrorPolicy as w}from"./core/stdout-errors.js";import{handle as E}from"./core/io.js";import{CrtrError as C}from"./core/errors.js";import{ApiError as x}from"./api/index.js";import{mark as r}from"./core/timing.js";a(p(import.meta.url),"r"),w(),r("cli.entry",{cmd:process.argv[2]??"(bare)"});try{c()}catch{}r("cli.compile_cache");async function _(){if(u(process.argv),await l(process.argv),r("cli.front_door_passed"),m(process.argv)){await h(await n(),process.argv);return}await b(process.argv),r("cli.plugins_revalidated");const o=await f(process.argv[2]);r("cli.root_resolved"),g(o,process.argv),v(process.argv),d(process.argv),r("cli.dispatch_start"),await y(o,process.argv),r("cli.dispatch_done")}e(_,"main"),_().catch(o=>{(o instanceof Error&&o.name==="AbortError"||o instanceof Error&&/operation was aborted/i.test(o.message))&&(process.stderr.write(`crtr: Interrupted
+`),process.exit(130)),(o instanceof x||o instanceof C)&&(E(o),process.exit(typeof process.exitCode=="number"?process.exitCode:1));const i=o instanceof Error?o.message:String(o);process.stderr.write(`crtr: ${i}
+`),process.exit(1)});

package/dist/clients/attach/ansi-cells.js

@@ -1,137 +1 @@
-// ansi-cells.ts — cell arithmetic over a rendered terminal row.
-//
-// A composed frame row mixes printable graphemes with SGR colors, OSC-8 link
-// boundaries, and pi-tui's APC cursor marker. Anything that addresses a row by
-// terminal column — link hit tests, mouse selection — has to walk it the way the
-// terminal does: escapes take no cell, wide graphemes take two. Both the attach
-// session and the renderers need that walk, so it lives at the client root
-// rather than inside either peer.
-import stringWidth from 'string-width';
-const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
-const INVERSE_ON = '\x1b[7m';
-const INVERSE_OFF = '\x1b[27m';
-/** Read one terminal control sequence so non-printing ANSI never takes a cell.
- *  `undefined` means the sequence runs off the end of the row. */
-export function readEscape(line, start) {
-    const kind = line[start + 1];
-    if (kind === undefined)
-        return undefined;
-    // OSC, APC, DCS, and PM are string controls terminated by BEL or ST. pi-tui's
-    // cursor marker uses APC, so it must consume no display cells here.
-    if (kind === ']' || kind === '_' || kind === 'P' || kind === '^') {
-        const bel = line.indexOf('\x07', start + 2);
-        const st = line.indexOf('\x1b\\', start + 2);
-        const end = bel === -1 ? st : st === -1 ? bel : Math.min(bel, st);
-        if (end === -1)
-            return undefined;
-        return { text: line.slice(start, end + (end === bel ? 1 : 2)), end: end + (end === bel ? 1 : 2) };
-    }
-    if (kind === '[') {
-        let end = start + 2;
-        while (end < line.length && (line.charCodeAt(end) < 0x40 || line.charCodeAt(end) > 0x7e))
-            end++;
-        if (end >= line.length)
-            return undefined;
-        return { text: line.slice(start, end + 1), end: end + 1 };
-    }
-    return { text: line.slice(start, start + 2), end: start + 2 };
-}
-/** Walk `line` as the terminal does, calling `onGlyph` per printable grapheme
- *  and `onEscape` per control sequence, in row order. Returns the cell count. */
-export function walkRow(line, visit) {
-    let cell = 0;
-    let index = 0;
-    while (index < line.length) {
-        if (line[index] === '\x1b') {
-            const escape = readEscape(line, index);
-            if (escape === undefined)
-                break;
-            visit.onEscape?.(escape.text);
-            index = escape.end;
-            continue;
-        }
-        const nextEscape = line.indexOf('\x1b', index);
-        const text = line.slice(index, nextEscape === -1 ? undefined : nextEscape);
-        for (const segment of GRAPHEMES.segment(text)) {
-            const width = stringWidth(segment.segment);
-            visit.onGlyph?.({ text: segment.segment, cell, width });
-            cell += width;
-        }
-        index = nextEscape === -1 ? line.length : nextEscape;
-    }
-    return cell;
-}
-/** Cells the row occupies on screen. */
-export function rowCells(line) {
-    return walkRow(line, {});
-}
-/** Plain text of cells `[from, to)` — every escape, link boundary, and cursor
- *  marker dropped, exactly what a terminal copies out of that span. */
-export function sliceCells(line, from, to) {
-    let text = '';
-    walkRow(line, {
-        onGlyph: (glyph) => {
-            if (glyph.cell >= from && glyph.cell < to)
-                text += glyph.text;
-        },
-    });
-    return text;
-}
-export const INVERSE_STYLE = { on: INVERSE_ON, off: INVERSE_OFF };
-/** Style cells `[from, to)`, re-asserting `style.on` after any SGR inside the
- *  span (a reset there would otherwise drop the styling mid-span). A short row
- *  is padded with spaces so a multi-row span reads as one block, never past
- *  `maxCells`. Escapes are non-printing, so passes compose: styling an already
- *  styled row leaves every cell position unmoved. */
-export function styleCells(line, from, to, maxCells, style = INVERSE_STYLE) {
-    const end = Math.min(to, maxCells);
-    if (end <= from || from < 0)
-        return line;
-    let out = '';
-    let inside = false;
-    // The SGRs in force at the current point, so a color span can hand the row
-    // back exactly as it found it. A full reset clears the list.
-    const active = [];
-    const open = () => { if (!inside) {
-        out += style.on;
-        inside = true;
-    } };
-    const close = () => {
-        if (!inside)
-            return;
-        out += style.restore === true ? `\x1b[0m${active.join('')}` : style.off;
-        inside = false;
-    };
-    const cells = walkRow(line, {
-        onEscape: (escape) => {
-            out += escape;
-            if (!escape.endsWith('m'))
-                return;
-            if (escape === '\x1b[0m' || escape === '\x1b[m')
-                active.length = 0;
-            else
-                active.push(escape);
-            // An SGR inside the span may have reset every attribute, including ours.
-            if (inside)
-                out += style.on;
-        },
-        onGlyph: (glyph) => {
-            if (glyph.cell >= from && glyph.cell < end)
-                open();
-            else
-                close();
-            out += glyph.text;
-        },
-    });
-    close();
-    if (cells < end) {
-        const gap = Math.max(0, from - cells);
-        const styled = end - Math.max(from, cells);
-        out += ' '.repeat(gap) + style.on + ' '.repeat(styled) + (style.restore === true ? '\x1b[0m' : style.off);
-    }
-    return out;
-}
-/** Reverse-video cells `[from, to)` — the drag-selection highlight. */
-export function highlightCells(line, from, to, maxCells) {
-    return styleCells(line, from, to, maxCells);
-}
+var a=Object.defineProperty;var i=(e,t)=>a(e,"name",{value:t,configurable:!0});import E from"string-width";const g=new Intl.Segmenter(void 0,{granularity:"grapheme"}),b="\x1B[7m",w="\x1B[27m";function C(e,t){const r=e[t+1];if(r!==void 0){if(r==="]"||r==="_"||r==="P"||r==="^"){const n=e.indexOf("\x07",t+2),o=e.indexOf("\x1B\\",t+2),f=n===-1?o:o===-1?n:Math.min(n,o);return f===-1?void 0:{text:e.slice(t,f+(f===n?1:2)),end:f+(f===n?1:2)}}if(r==="["){let n=t+2;for(;n<e.length&&(e.charCodeAt(n)<64||e.charCodeAt(n)>126);)n++;return n>=e.length?void 0:{text:e.slice(t,n+1),end:n+1}}return{text:e.slice(t,t+2),end:t+2}}}i(C,"readEscape");function l(e,t){let r=0,n=0;for(;n<e.length;){if(e[n]==="\x1B"){const c=C(e,n);if(c===void 0)break;t.onEscape?.(c.text),n=c.end;continue}const o=e.indexOf("\x1B",n),f=e.slice(n,o===-1?void 0:o);for(const c of g.segment(f)){const d=E(c.segment);t.onGlyph?.({text:c.segment,cell:r,width:d}),r+=d}n=o===-1?e.length:o}return r}i(l,"walkRow");function G(e){return l(e,{})}i(G,"rowCells");function I(e,t,r){let n="";return l(e,{onGlyph:i(o=>{o.cell>=t&&o.cell<r&&(n+=o.text)},"onGlyph")}),n}i(I,"sliceCells");const S={on:b,off:w};function M(e,t,r,n,o=S){const f=Math.min(r,n);if(f<=t||t<0)return e;let c="",d=!1;const s=[],m=i(()=>{d||(c+=o.on,d=!0)},"open"),h=i(()=>{d&&(c+=o.restore===!0?`\x1B[0m${s.join("")}`:o.off,d=!1)},"close"),u=l(e,{onEscape:i(x=>{c+=x,x.endsWith("m")&&(x==="\x1B[0m"||x==="\x1B[m"?s.length=0:s.push(x),d&&(c+=o.on))},"onEscape"),onGlyph:i(x=>{x.cell>=t&&x.cell<f?m():h(),c+=x.text},"onGlyph")});if(h(),u<f){const x=Math.max(0,t-u),p=f-Math.max(t,u);c+=" ".repeat(x)+o.on+" ".repeat(p)+(o.restore===!0?"\x1B[0m":o.off)}return c}i(M,"styleCells");function N(e,t,r,n){return M(e,t,r,n)}i(N,"highlightCells");export{S as INVERSE_STYLE,N as highlightCells,C as readEscape,G as rowCells,I as sliceCells,M as styleCells,l as walkRow};

package/dist/clients/attach/chrome/bash-jobs.js

@@ -1,31 +1 @@
-// chrome/bash-jobs.ts — the attach-side formatter for live backgrounded bash jobs,
-// mirroring chrome/cron-wait.ts: the compact one-row cockpit summary. Pure — takes
-// the already-scanned job list, never touches disk itself (that's
-// activeBackgroundBashJobs' job, in core/bash-jobs.ts). Enter on that row opens
-// the Inspector's `jobs` section, which owns the drill-in rendering.
-import { bashJobCommandLine, formatBashElapsed } from '../../../core/bash-jobs.js';
-/** The job's command line, capped to `cap` columns. A
- *  shell one-liner is cut on a word boundary when there is one near the cap, so
- *  the cell ends on a readable token instead of mid-`$((`. */
-function cmdCell(command, cap) {
-    const oneLine = bashJobCommandLine(command);
-    if (oneLine.length <= cap)
-        return oneLine;
-    const cut = oneLine.slice(0, Math.max(1, cap - 1));
-    const space = cut.lastIndexOf(' ');
-    return `${(space >= cap - 12 ? cut.slice(0, space) : cut).trimEnd()}…`;
-}
-/** Compact cockpit row: state first (matching the cron row), then the running
- *  command. `cmdCap` is the columns the caller has left for that command, so the
- *  cell shrinks with the pane instead of being clipped after the row's own key
- *  hints. `undefined` for an empty list — the caller omits the row entirely. */
-export function bashJobsWaitSummary(jobs, nowMs = Date.now(), cmdCap = 26) {
-    if (jobs.length === 0)
-        return undefined;
-    if (jobs.length === 1) {
-        const job = jobs[0];
-        return `bash job · ${formatBashElapsed(nowMs - job.startedAtMs)} · ${cmdCell(job.command, Math.max(12, cmdCap))}`;
-    }
-    const oldest = jobs[0]; // activeBackgroundBashJobs returns oldest-first
-    return `${jobs.length} bash jobs · oldest ${formatBashElapsed(nowMs - oldest.startedAtMs)}`;
-}
+var i=Object.defineProperty;var s=(t,n)=>i(t,"name",{value:n,configurable:!0});import{bashJobCommandLine as m,formatBashElapsed as o}from"../../../core/bash-jobs.js";function d(t,n){const e=m(t);if(e.length<=n)return e;const a=e.slice(0,Math.max(1,n-1)),r=a.lastIndexOf(" ");return`${(r>=n-12?a.slice(0,r):a).trimEnd()}\u2026`}s(d,"cmdCell");function h(t,n=Date.now(),e=26){if(t.length===0)return;if(t.length===1){const r=t[0];return`bash job \xB7 ${o(n-r.startedAtMs)} \xB7 ${d(r.command,Math.max(12,e))}`}const a=t[0];return`${t.length} bash jobs \xB7 oldest ${o(n-a.startedAtMs)}`}s(h,"bashJobsWaitSummary");export{h as bashJobsWaitSummary};