@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/broker-client/client.js

@@ -1,184 +1 @@
-// client.ts — THE broker protocol client. Every Node process that talks to a
-// node's broker over `view.sock` uses this one class: the `crtr surface attach`
-// viewer, `auth-reload`, `model-swap`, and the human-prompt dequeue path.
-//
-// The §0 ONE-WRITER INVARIANT lives here: a client has ONLY a Transport
-// (`transport.ts`) to an ALREADY-running headless broker — locally over its
-// unix socket (`SocketTransport`, `nodeDir(id)/view.sock`), or remotely over a
-// bearer-authenticated WebSocket to crtrd's preview-served attach endpoint
-// (`RelayTransport`, `transport-relay.ts`). BrokerClient NEVER spawns pi, NEVER opens the session
-// `.jsonl`, NEVER constructs an engine — if the broker is not running, connect
-// fails and the caller exits (focus/revive is what keeps a broker alive, not
-// attach). It also never uses pi's `RpcClient` (which would spawn its own
-// engine).
-//
-// Everything in this file is transport-agnostic: request correlation (the
-// pending map), the reconnect give-up predicate, and close handling are the
-// SAME regardless of which Transport is plugged in at construction — only the
-// wire differs. See `transport.ts` for the seam contract. Fault recording
-// (`viewer↔broker` canvas fault rows) belongs to the transport that can
-// produce a dial error, and lives in `SocketTransport`.
-//
-// Reconnect: a dropped broker emits `close`; the caller's reconnect supervisor
-// decides whether to re-dial (a yield/revive keeps the SAME target — a local
-// `view.sock` path, or a remote preview endpoint — `redial()` re-establishes
-// the connection to it) or give up ("broker gone"). A connect-time
-// unavailable-broker signal surfaces as `BrokerUnavailableError` so the FIRST
-// connect exits non-zero with a clear message; the same signal during a
-// redial rejects the redial promise as retryable.
-import { EventEmitter } from 'node:events';
-import { randomUUID } from 'node:crypto';
-import { SocketTransport } from './transport-socket.js';
-export { BrokerUnavailableError } from './transport.js';
-export { SocketTransport } from './transport-socket.js';
-export { RelayTransport } from './transport-relay.js';
-/** How long {@link BrokerClient.request} waits for the correlated reply before
- *  rejecting — bounds a pending picker fetch if the broker drops the request
- *  (it should always reply with `data` or a correlated `error`). */
-const REQUEST_TIMEOUT_MS = 10_000;
-/** The reconnect supervisor's give-up predicate (extracted pure so it is
- *  testable without a socket or TUI). After a broker close the viewer KEEPS
- *  re-dialing the same target while the node is still alive — a yield
- *  leaves `status='active'` (intent='refresh') and the daemon revives a fresh
- *  broker on the same path. It gives up only when the node is genuinely gone:
- *  a terminal status (done/dead/canceled) or a reaped row (null). `idle` and an
- *  exact unfinalized parked resident are NOT terminal — either can wake while
- *  the viewer remains seated. Local canvas rows only — a remote target has no
- *  local row, so callers driving a remote attach must not consult this. */
-export function reconnectShouldGiveUp(row) {
-    if (row === null)
-        return true;
-    if (row.lifecycle === 'resident'
-        && row.status === 'done'
-        && row.intent === 'parked'
-        && row.final_report == null)
-        return false;
-    return row.status === 'done' || row.status === 'dead' || row.status === 'canceled';
-}
-export class BrokerClient extends EventEmitter {
-    nodeId;
-    transport;
-    closeEmitted = false;
-    /** Tracks live connect↔close state so {@link request} can fail fast on a
-     *  dead/absent connection rather than parking a promise the reply will
-     *  never reach (transport-agnostic mirror of the old socket.destroyed
-     *  check). A post-close request lands here too — {@link rejectAllPending}
-     *  already ran by the time this flips false. */
-    connected = false;
-    /** The last transport-level error message, so a close can reject any
-     *  in-flight requests with the precise reason (e.g. an oversized-frame
-     *  overflow) instead of a generic one. Cleared on every fresh connect. */
-    lastTransportError;
-    /** In-flight correlated read-ops, keyed by the `id` minted in {@link request}.
-     *  Resolved by the matching `data` frame / rejected by the matching `error`
-     *  frame in {@link onFrame}, the request's timeout, or transport teardown. */
-    pending = new Map();
-    constructor(nodeId, options = {}) {
-        super();
-        this.nodeId = nodeId;
-        this.transport = options.transport ?? new SocketTransport(nodeId);
-        this.transport.on('connect', () => {
-            this.closeEmitted = false;
-            this.connected = true;
-            this.lastTransportError = undefined;
-            this.emit('connect');
-        });
-        this.transport.on('frame', (frame) => this.onFrame(frame));
-        this.transport.on('error', (err) => {
-            this.lastTransportError = err.message;
-            this.emitError(err);
-        });
-        this.transport.on('close', () => this.onClose());
-    }
-    /** Issue a correlated read-op and resolve with the broker's `data` reply (or
-     *  reject on the correlated `error`, a timeout, or transport teardown). Mints
-     *  the `id`, sends `{...frame, id}`, and parks a resolver consumed by
-     *  {@link onFrame}. The reply is narrowed by the caller on its `kind`. */
-    request(frame) {
-        const id = randomUUID();
-        return new Promise((resolve, reject) => {
-            if (!this.connected) {
-                reject(new Error(`cannot issue '${frame.type}': no live broker connection`));
-                return;
-            }
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`request '${frame.type}' timed out after ${REQUEST_TIMEOUT_MS}ms`));
-            }, REQUEST_TIMEOUT_MS);
-            if (typeof timer.unref === 'function')
-                timer.unref();
-            this.pending.set(id, { resolve, reject, timer });
-            this.send({ ...frame, id });
-        });
-    }
-    /** Reject + clear every in-flight request (connection gone / decode error)
-     *  so a picker fetch never hangs past the connection it rode on. */
-    rejectAllPending(reason) {
-        for (const { reject, timer } of this.pending.values()) {
-            clearTimeout(timer);
-            reject(new Error(reason));
-        }
-        this.pending.clear();
-    }
-    /** Open the connection. Emits `connect` on success or `error` (a
-     *  {@link BrokerUnavailableError} when the target has no reachable broker)
-     *  on failure. Idempotent guard is the caller's job — call once. */
-    connect() {
-        this.transport.connect();
-    }
-    /** Re-establish the connection after a broker exit (a yield→revive cycle),
-     *  to the SAME target. Resolves on `connect` (caller re-sends `hello`);
-     *  rejects on a retryable dial failure. */
-    redial(options) {
-        return this.transport.redial(options);
-    }
-    /** Encode + send one client→broker frame. No-op on a dead/absent
-     *  connection; never throws. */
-    send(frame) {
-        this.transport.send(frame);
-    }
-    /** Detach: tear down the transport. `close` fires → the caller tears down. */
-    close() {
-        this.transport.destroy();
-    }
-    onFrame(frame) {
-        // Correlated replies (read-ops + dequeue) are consumed by the pending-by-id
-        // resolver, NOT re-emitted as a generic 'frame' (the attach frame router
-        // would otherwise treat a `data` frame as an AgentSessionEvent). A `data`
-        // frame is ALWAYS a reply, so by default it is swallowed unconditionally —
-        // even a late post-timeout one (no pending entry) is dropped, never leaked
-        // to the router. An `error` is correlated only when its `id` matches an
-        // in-flight request; an uncorrelated error still flows through.
-        if (frame.type === 'data') {
-            const entry = typeof frame.id === 'string' ? this.pending.get(frame.id) : undefined;
-            if (entry) {
-                this.pending.delete(frame.id);
-                clearTimeout(entry.timer);
-                entry.resolve(frame);
-            }
-            return;
-        }
-        if (frame.type === 'error' && typeof frame.id === 'string' && this.pending.has(frame.id)) {
-            const entry = this.pending.get(frame.id);
-            this.pending.delete(frame.id);
-            clearTimeout(entry.timer);
-            entry.reject(new Error(frame.message || `request failed: ${frame.code}`));
-            return;
-        }
-        this.emit('frame', frame);
-    }
-    onClose() {
-        if (this.closeEmitted)
-            return;
-        this.closeEmitted = true;
-        this.connected = false;
-        this.rejectAllPending(this.lastTransportError ?? 'broker connection closed');
-        this.emit('close');
-    }
-    /** Emit `error` only when a listener exists — a bare EventEmitter `error`
-     *  with no listener throws, and this client must never throw uncaught. */
-    emitError(err) {
-        if (this.listenerCount('error') > 0)
-            this.emit('error', err);
-    }
-}
+var c=Object.defineProperty;var o=(r,t)=>c(r,"name",{value:t,configurable:!0});import{EventEmitter as l}from"node:events";import{randomUUID as p}from"node:crypto";import{SocketTransport as a}from"./transport-socket.js";import{BrokerUnavailableError as k}from"./transport.js";import{SocketTransport as x}from"./transport-socket.js";import{RelayTransport as S}from"./transport-relay.js";const d=1e4;function E(r){return r===null?!0:r.lifecycle==="resident"&&r.status==="done"&&r.intent==="parked"&&r.final_report==null?!1:r.status==="done"||r.status==="dead"||r.status==="canceled"}o(E,"reconnectShouldGiveUp");class g extends l{static{o(this,"BrokerClient")}nodeId;transport;closeEmitted=!1;connected=!1;lastTransportError;pending=new Map;constructor(t,e={}){super(),this.nodeId=t,this.transport=e.transport??new a(t),this.transport.on("connect",()=>{this.closeEmitted=!1,this.connected=!0,this.lastTransportError=void 0,this.emit("connect")}),this.transport.on("frame",n=>this.onFrame(n)),this.transport.on("error",n=>{this.lastTransportError=n.message,this.emitError(n)}),this.transport.on("close",()=>this.onClose())}request(t){const e=p();return new Promise((n,s)=>{if(!this.connected){s(new Error(`cannot issue '${t.type}': no live broker connection`));return}const i=setTimeout(()=>{this.pending.delete(e),s(new Error(`request '${t.type}' timed out after ${d}ms`))},d);typeof i.unref=="function"&&i.unref(),this.pending.set(e,{resolve:n,reject:s,timer:i}),this.send({...t,id:e})})}rejectAllPending(t){for(const{reject:e,timer:n}of this.pending.values())clearTimeout(n),e(new Error(t));this.pending.clear()}connect(){this.transport.connect()}redial(t){return this.transport.redial(t)}send(t){this.transport.send(t)}close(){this.transport.destroy()}onFrame(t){if(t.type==="data"){const e=typeof t.id=="string"?this.pending.get(t.id):void 0;e&&(this.pending.delete(t.id),clearTimeout(e.timer),e.resolve(t));return}if(t.type==="error"&&typeof t.id=="string"&&this.pending.has(t.id)){const e=this.pending.get(t.id);this.pending.delete(t.id),clearTimeout(e.timer),e.reject(new Error(t.message||`request failed: ${t.code}`));return}this.emit("frame",t)}onClose(){this.closeEmitted||(this.closeEmitted=!0,this.connected=!1,this.rejectAllPending(this.lastTransportError??"broker connection closed"),this.emit("close"))}emitError(t){this.listenerCount("error")>0&&this.emit("error",t)}}export{g as BrokerClient,k as BrokerUnavailableError,S as RelayTransport,x as SocketTransport,E as reconnectShouldGiveUp};

package/dist/core/broker-client/index.js

@@ -1,13 +1 @@
-// core/broker-client — the ONE `view.sock` protocol client for Node processes.
-//
-// `client.ts` owns the protocol (request correlation, the pending map, close
-// handling, the reconnect give-up predicate); `transport.ts` is the seam, with
-// two implementations — `transport-socket.ts` (local unix socket) and
-// `transport-relay.ts` (remote wss via the preview endpoint). The wire format
-// itself stays in `core/runtime/broker-protocol.ts`, which both the broker and
-// every client share.
-//
-// Nothing here reads or writes canvas state: a caller that needs the graph goes
-// to crtrd `/v1`, and a caller that needs a surface goes to tmux placement. That
-// is what keeps this module importable from a CLI leaf (V-1).
-export { BrokerClient, BrokerUnavailableError, reconnectShouldGiveUp, RelayTransport, SocketTransport, } from './client.js';
+import{BrokerClient as o,BrokerUnavailableError as a,reconnectShouldGiveUp as n,RelayTransport as t,SocketTransport as l}from"./client.js";export{o as BrokerClient,a as BrokerUnavailableError,t as RelayTransport,l as SocketTransport,n as reconnectShouldGiveUp};

package/dist/core/broker-client/transport-relay.js

@@ -1,157 +1 @@
-// transport-relay.ts — the REMOTE Transport: a bearer-authenticated WebSocket
-// to crtrd's `wss://<previewEndpoint>/v1/nodes/<id>/attach` endpoint. One JSON
-// frame per WS message in both directions; no FrameDecoder is needed because
-// WebSocket preserves message boundaries.
-//
-// Callers keep the bearer token off argv and shell history (see
-// `core/remote-canvas-target.ts`). This transport sends it only as a request
-// header and never logs it.
-import { EventEmitter } from 'node:events';
-import { WebSocket } from 'ws';
-import { classify } from '../fault-classifier.js';
-import { BrokerUnavailableError } from './transport.js';
-function relayUrl(target, nodeId) {
-    const url = new URL(target.previewEndpoint);
-    url.protocol = url.protocol === 'http:' ? 'ws:' : 'wss:';
-    url.pathname = `/v1/nodes/${encodeURIComponent(nodeId)}/attach`;
-    // A person typed `crtr surface attach` at this node, so an exact parked
-    // resident is woken for it — the same thing the LOCAL attach ensure does for
-    // a direct attach. The bridge leaves a parked node parked without this, which
-    // is what a product page reconnecting its viewport wants.
-    url.search = '?wakeParked=1';
-    url.hash = '';
-    return url.toString();
-}
-export class RelayTransport extends EventEmitter {
-    nodeId;
-    target;
-    ws;
-    closeEmitted = false;
-    constructor(nodeId, target) {
-        super();
-        this.nodeId = nodeId;
-        this.target = target;
-    }
-    get url() {
-        return relayUrl(this.target, this.nodeId);
-    }
-    dial() {
-        const ws = new WebSocket(this.url, {
-            headers: { authorization: `Bearer ${this.target.relayToken}` },
-            perMessageDeflate: false,
-        });
-        this.ws = ws;
-        return ws;
-    }
-    connect() {
-        const ws = this.dial();
-        ws.on('open', () => {
-            this.emit('connect');
-        });
-        ws.on('message', (data) => this.onMessage(data));
-        ws.on('error', (err) => this.onError(err));
-        ws.on('close', (code, reason) => this.onClose(code, reason.toString()));
-    }
-    /** Re-dial the same crtrd attach endpoint — the preview endpoint is the
-     *  stable remote anchor, as `view.sock` is locally. */
-    redial(_options) {
-        this.destroy();
-        this.closeEmitted = false;
-        return new Promise((resolve, reject) => {
-            const ws = this.dial();
-            let settled = false;
-            ws.on('open', () => {
-                if (settled)
-                    return;
-                settled = true;
-                this.emit('connect');
-                resolve();
-            });
-            ws.on('message', (data) => this.onMessage(data));
-            ws.on('error', (err) => {
-                if (settled) {
-                    this.onError(err);
-                    return;
-                }
-                settled = true;
-                try {
-                    ws.terminate();
-                }
-                catch {
-                    /* ignore */
-                }
-                reject(err);
-            });
-            ws.on('close', (code, reason) => {
-                if (!settled)
-                    return; // the 'error' handler above already rejected
-                this.onClose(code, reason.toString());
-            });
-        });
-    }
-    send(frame) {
-        const ws = this.ws;
-        if (ws === undefined || ws.readyState !== WebSocket.OPEN)
-            return;
-        try {
-            ws.send(JSON.stringify(frame));
-        }
-        catch {
-            /* dead socket — 'close' will fire and drive teardown */
-        }
-    }
-    destroy() {
-        const ws = this.ws;
-        if (ws !== undefined && ws.readyState <= WebSocket.OPEN) {
-            try {
-                ws.close();
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
-    onMessage(data) {
-        let frame;
-        try {
-            frame = JSON.parse(data.toString());
-        }
-        catch {
-            // A malformed frame must never crash the client — drop it (parity with
-            // the local FrameDecoder's own bad-JSON handling).
-            return;
-        }
-        this.emit('frame', frame);
-    }
-    onError(err) {
-        this.emitError(new Error(`relay transport error: ${err.message}`));
-        // 'close' follows 'error'; teardown converges there.
-    }
-    /** A 1008 invalid-id close or a 1011 whose reason starts with "no running
-     *  broker" or "no node " is a terminal unavailable-broker signal from the
-     *  crtrd attach bridge. Surface it as BrokerUnavailableError so the reconnect
-     *  supervisor applies its normal give-up path across transports. `classify`
-     *  only handles the 1008/protocol case: its 1011 classification answers
-     *  whether a close is connection-shaped, not whether the broker is gone.
-     *  Everything else (1006 abnormal, 1000 normal, or an unrecognized 1011
-     *  reason) is a transient or expected drop that the caller may redial. */
-    onClose(code, reason) {
-        if (this.closeEmitted)
-            return;
-        this.closeEmitted = true;
-        const classified = classify('viewer↔broker', { code, reason });
-        const gone = code === 1008 ||
-            classified.kind === 'protocol' ||
-            (code === 1011 && (/^no running broker/.test(reason) || /^no node /.test(reason)));
-        if (gone) {
-            this.emitError(new BrokerUnavailableError(this.nodeId));
-        }
-        this.emit('close');
-    }
-    /** Emit `error` only when a listener exists — a bare EventEmitter `error`
-     *  with no listener throws, and this transport must never throw uncaught. */
-    emitError(err) {
-        if (this.listenerCount('error') > 0)
-            this.emit('error', err);
-    }
-}
+var l=Object.defineProperty;var a=(i,t)=>l(i,"name",{value:t,configurable:!0});import{EventEmitter as d}from"node:events";import{WebSocket as h}from"ws";import{classify as m}from"../fault-classifier.js";import{BrokerUnavailableError as f}from"./transport.js";function u(i,t){const e=new URL(i.previewEndpoint);return e.protocol=e.protocol==="http:"?"ws:":"wss:",e.pathname=`/v1/nodes/${encodeURIComponent(t)}/attach`,e.search="?wakeParked=1",e.hash="",e.toString()}a(u,"relayUrl");class S extends d{static{a(this,"RelayTransport")}nodeId;target;ws;closeEmitted=!1;constructor(t,e){super(),this.nodeId=t,this.target=e}get url(){return u(this.target,this.nodeId)}dial(){const t=new h(this.url,{headers:{authorization:`Bearer ${this.target.relayToken}`},perMessageDeflate:!1});return this.ws=t,t}connect(){const t=this.dial();t.on("open",()=>{this.emit("connect")}),t.on("message",e=>this.onMessage(e)),t.on("error",e=>this.onError(e)),t.on("close",(e,s)=>this.onClose(e,s.toString()))}redial(t){return this.destroy(),this.closeEmitted=!1,new Promise((e,s)=>{const r=this.dial();let n=!1;r.on("open",()=>{n||(n=!0,this.emit("connect"),e())}),r.on("message",o=>this.onMessage(o)),r.on("error",o=>{if(n){this.onError(o);return}n=!0;try{r.terminate()}catch{}s(o)}),r.on("close",(o,c)=>{n&&this.onClose(o,c.toString())})})}send(t){const e=this.ws;if(!(e===void 0||e.readyState!==h.OPEN))try{e.send(JSON.stringify(t))}catch{}}destroy(){const t=this.ws;if(t!==void 0&&t.readyState<=h.OPEN)try{t.close()}catch{}}onMessage(t){let e;try{e=JSON.parse(t.toString())}catch{return}this.emit("frame",e)}onError(t){this.emitError(new Error(`relay transport error: ${t.message}`))}onClose(t,e){if(this.closeEmitted)return;this.closeEmitted=!0;const s=m("viewer\u2194broker",{code:t,reason:e});(t===1008||s.kind==="protocol"||t===1011&&(/^no running broker/.test(e)||/^no node /.test(e)))&&this.emitError(new f(this.nodeId)),this.emit("close")}emitError(t){this.listenerCount("error")>0&&this.emit("error",t)}}export{S as RelayTransport};

package/dist/core/broker-client/transport-socket.js

@@ -1,179 +1 @@
-// transport-socket.ts — the LOCAL unix-socket Transport. This is the ORIGINAL
-// view-socket wire logic (node:net + the bounded FrameDecoder), unchanged in
-// behavior, extracted behind the `Transport` interface so BrokerClient can
-// also ride a `RelayTransport` (transport-relay.ts).
-//
-// Connects to a node's ALREADY-running headless broker over its unix socket
-// (`nodeDir(id)/view.sock`). NEVER spawns pi, NEVER opens the session
-// `.jsonl` — if the broker is not running, connect fails with a
-// BrokerUnavailableError.
-import { EventEmitter } from 'node:events';
-import { createConnection } from 'node:net';
-import { viewSocketPath } from '../canvas/paths.js';
-import { classify } from '../fault-classifier.js';
-import { clearNodeFault, recordNodeFault } from '../runtime/broker/daemon-ops.js';
-import { emitEvent } from '../events/emit.js';
-import { CLIENT_READ_CAPS, encodeFrame, FrameDecoder, FrameOverflowError, } from '../runtime/broker-protocol.js';
-import { BrokerUnavailableError } from './transport.js';
-export class SocketTransport extends EventEmitter {
-    nodeId;
-    socket;
-    decoder = new FrameDecoder(CLIENT_READ_CAPS);
-    closeEmitted = false;
-    /** One redial fault line per reconnect EPISODE, not per attempt — see
-     *  {@link recordSocketFault}. */
-    redialFaultRecorded = false;
-    constructor(nodeId) {
-        super();
-        this.nodeId = nodeId;
-    }
-    /** The broker binds `viewSocketPath(id)` — resolve it the same way. */
-    get socketPath() {
-        return viewSocketPath(this.nodeId);
-    }
-    recordSocketFault(op, err) {
-        if (op === 'redial') {
-            if (this.redialFaultRecorded)
-                return;
-            this.redialFaultRecorded = true;
-        }
-        const classified = classify('viewer↔broker', err);
-        void recordNodeFault(this.nodeId, {
-            link: 'viewer↔broker',
-            op,
-            kind: classified.kind,
-            retry: op === 'redial'
-                ? { disposition: 'auto', by: 'client' }
-                : { disposition: 'manual' },
-            message: err instanceof Error ? err.message : String(err),
-        }).catch((error) => {
-            emitEvent({ event: 'broker.daemon.operation.failed', level: 'error', node_id: this.nodeId, error, fields: { operation: 'viewer_fault_record' } });
-        });
-    }
-    connect() {
-        const socket = createConnection(this.socketPath);
-        this.socket = socket;
-        socket.on('connect', () => {
-            this.redialFaultRecorded = false;
-            this.clearSocketFault();
-            this.emit('connect');
-        });
-        socket.on('data', (chunk) => this.onData(chunk));
-        socket.on('error', (err) => this.onError(err, 'connect'));
-        socket.on('close', () => this.onClose());
-    }
-    /** Re-establish the socket after a broker exit, on the SAME stable
-     *  `view.sock` path. Installs a FRESH FrameDecoder (a half-frame from the
-     *  dead stream must not corrupt the new one). */
-    redial(options = {}) {
-        this.destroy();
-        this.decoder = new FrameDecoder(CLIENT_READ_CAPS);
-        this.closeEmitted = false;
-        if (options.brokerUnavailableIsExpected) {
-            this.redialFaultRecorded = false;
-            this.clearSocketFault();
-        }
-        return new Promise((resolve, reject) => {
-            const socket = createConnection(this.socketPath);
-            this.socket = socket;
-            let settled = false;
-            socket.on('connect', () => {
-                if (settled)
-                    return;
-                settled = true;
-                this.redialFaultRecorded = false;
-                this.clearSocketFault();
-                this.emit('connect');
-                resolve();
-            });
-            socket.on('data', (chunk) => this.onData(chunk));
-            socket.on('error', (err) => {
-                if (settled) {
-                    this.onError(err, 'redial');
-                    return;
-                }
-                settled = true;
-                const brokerUnavailable = err.code === 'ECONNREFUSED' || err.code === 'ENOENT';
-                if (!options.brokerUnavailableIsExpected || !brokerUnavailable) {
-                    this.recordSocketFault('redial', err);
-                }
-                try {
-                    socket.destroy();
-                }
-                catch {
-                    /* ignore */
-                }
-                reject(err);
-            });
-            socket.on('close', () => this.onClose());
-        });
-    }
-    send(frame) {
-        const sock = this.socket;
-        if (sock === undefined || sock.destroyed)
-            return;
-        try {
-            sock.write(encodeFrame(frame));
-        }
-        catch {
-            /* dead socket — 'close' will fire and drive teardown */
-        }
-    }
-    destroy() {
-        const sock = this.socket;
-        if (sock !== undefined && !sock.destroyed) {
-            try {
-                sock.destroy();
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
-    clearSocketFault() {
-        void clearNodeFault(this.nodeId, { link: 'viewer↔broker' }).catch((error) => {
-            emitEvent({ event: 'broker.daemon.operation.failed', level: 'error', node_id: this.nodeId, error, fields: { operation: 'viewer_fault_clear' } });
-        });
-    }
-    onData(chunk) {
-        let frames;
-        try {
-            frames = this.decoder.push(chunk);
-        }
-        catch (err) {
-            // A broker that somehow emits an oversized frame (or a corrupt stream):
-            // clean error + drop, never a crash. The 'close' that follows destroy()
-            // is what rejects any in-flight BrokerClient requests.
-            const msg = err instanceof FrameOverflowError
-                ? `broker sent an oversized frame (${err.message}) — disconnecting`
-                : `failed to decode a broker frame: ${String(err)}`;
-            this.emitError(new Error(msg));
-            this.destroy();
-            return;
-        }
-        for (const raw of frames)
-            this.emit('frame', raw);
-    }
-    onError(err, op) {
-        this.recordSocketFault(op, err);
-        if (err.code === 'ECONNREFUSED' || err.code === 'ENOENT') {
-            this.emitError(new BrokerUnavailableError(this.nodeId));
-        }
-        else {
-            this.emitError(new Error(`view socket error: ${err.message}`));
-        }
-        // 'close' typically follows 'error'; teardown converges there.
-    }
-    onClose() {
-        if (this.closeEmitted)
-            return;
-        this.closeEmitted = true;
-        this.emit('close');
-    }
-    /** Emit `error` only when a listener exists — a bare EventEmitter `error`
-     *  with no listener throws, and this transport must never throw uncaught. */
-    emitError(err) {
-        if (this.listenerCount('error') > 0)
-            this.emit('error', err);
-    }
-}
+var f=Object.defineProperty;var a=(n,e)=>f(n,"name",{value:e,configurable:!0});import{EventEmitter as k}from"node:events";import{createConnection as d}from"node:net";import{viewSocketPath as u}from"../canvas/paths.js";import{classify as E}from"../fault-classifier.js";import{clearNodeFault as v,recordNodeFault as F}from"../runtime/broker/daemon-ops.js";import{emitEvent as c}from"../events/emit.js";import{CLIENT_READ_CAPS as l,encodeFrame as p,FrameDecoder as h,FrameOverflowError as w}from"../runtime/broker-protocol.js";import{BrokerUnavailableError as b}from"./transport.js";class P extends k{static{a(this,"SocketTransport")}nodeId;socket;decoder=new h(l);closeEmitted=!1;redialFaultRecorded=!1;constructor(e){super(),this.nodeId=e}get socketPath(){return u(this.nodeId)}recordSocketFault(e,t){if(e==="redial"){if(this.redialFaultRecorded)return;this.redialFaultRecorded=!0}const o=E("viewer\u2194broker",t);F(this.nodeId,{link:"viewer\u2194broker",op:e,kind:o.kind,retry:e==="redial"?{disposition:"auto",by:"client"}:{disposition:"manual"},message:t instanceof Error?t.message:String(t)}).catch(r=>{c({event:"broker.daemon.operation.failed",level:"error",node_id:this.nodeId,error:r,fields:{operation:"viewer_fault_record"}})})}connect(){const e=d(this.socketPath);this.socket=e,e.on("connect",()=>{this.redialFaultRecorded=!1,this.clearSocketFault(),this.emit("connect")}),e.on("data",t=>this.onData(t)),e.on("error",t=>this.onError(t,"connect")),e.on("close",()=>this.onClose())}redial(e={}){return this.destroy(),this.decoder=new h(l),this.closeEmitted=!1,e.brokerUnavailableIsExpected&&(this.redialFaultRecorded=!1,this.clearSocketFault()),new Promise((t,o)=>{const r=d(this.socketPath);this.socket=r;let s=!1;r.on("connect",()=>{s||(s=!0,this.redialFaultRecorded=!1,this.clearSocketFault(),this.emit("connect"),t())}),r.on("data",i=>this.onData(i)),r.on("error",i=>{if(s){this.onError(i,"redial");return}s=!0;const m=i.code==="ECONNREFUSED"||i.code==="ENOENT";(!e.brokerUnavailableIsExpected||!m)&&this.recordSocketFault("redial",i);try{r.destroy()}catch{}o(i)}),r.on("close",()=>this.onClose())})}send(e){const t=this.socket;if(!(t===void 0||t.destroyed))try{t.write(p(e))}catch{}}destroy(){const e=this.socket;if(e!==void 0&&!e.destroyed)try{e.destroy()}catch{}}clearSocketFault(){v(this.nodeId,{link:"viewer\u2194broker"}).catch(e=>{c({event:"broker.daemon.operation.failed",level:"error",node_id:this.nodeId,error:e,fields:{operation:"viewer_fault_clear"}})})}onData(e){let t;try{t=this.decoder.push(e)}catch(o){const r=o instanceof w?`broker sent an oversized frame (${o.message}) \u2014 disconnecting`:`failed to decode a broker frame: ${String(o)}`;this.emitError(new Error(r)),this.destroy();return}for(const o of t)this.emit("frame",o)}onError(e,t){this.recordSocketFault(t,e),e.code==="ECONNREFUSED"||e.code==="ENOENT"?this.emitError(new b(this.nodeId)):this.emitError(new Error(`view socket error: ${e.message}`))}onClose(){this.closeEmitted||(this.closeEmitted=!0,this.emit("close"))}emitError(e){this.listenerCount("error")>0&&this.emit("error",e)}}export{P as SocketTransport};

package/dist/core/broker-client/transport.js

@@ -1,26 +1 @@
-// transport.ts — the Transport seam: BrokerClient's broker I/O, abstracted
-// so the SAME correlation/pending/close logic can ride either the LOCAL unix
-// socket (SocketTransport, transport-socket.ts) or a WebSocket to crtrd's
-// remote attach endpoint (RelayTransport, transport-relay.ts). Both speak the same
-// broker-protocol JSON frames; only how bytes cross the wire differs.
-//
-// A Transport is a pure duplex frame pump — connect (dial), redial (re-dial
-// the SAME target after a drop), send (one client→broker frame), destroy
-// (tear down). It emits 'connect' once the peer is reachable, one 'frame' per
-// decoded broker→client frame, 'error' for a surfaced problem (including a
-// {@link BrokerUnavailableError} when the target has no reachable broker),
-// and 'close' exactly once when the connection is gone. Everything ABOVE this
-// seam — request correlation, the pending map, redial-vs-give-up policy — is
-// BrokerClient's job and never moves into a Transport implementation.
-/** Surfaced when a Transport's target has no reachable broker — locally, no
- *  socket file / nothing listening; remotely, a crtrd attach close signaling
- *  "no broker for this node". The command catches this to exit non-zero with a
- *  focus/revive hint — same meaning regardless of which Transport raised it. */
-export class BrokerUnavailableError extends Error {
-    nodeId;
-    constructor(nodeId) {
-        super(`node ${nodeId} has no running broker — focus or revive it first`);
-        this.nodeId = nodeId;
-        this.name = 'BrokerUnavailableError';
-    }
-}
+var n=Object.defineProperty;var o=(e,r)=>n(e,"name",{value:r,configurable:!0});class a extends Error{static{o(this,"BrokerUnavailableError")}nodeId;constructor(r){super(`node ${r} has no running broker \u2014 focus or revive it first`),this.nodeId=r,this.name="BrokerUnavailableError"}}export{a as BrokerUnavailableError};

package/dist/core/canvas/attention.js

@@ -1,47 +1 @@
-// Pending human-request counters across the canvas. The indexed request query is the authority; request directories are retained artifacts, never an inbox index.
-import { listOpenReplyBearingRequests } from '../human/requests.js';
-import { getNode, listNodes, view } from './canvas.js';
-/** Kept for callers that reset a canvas home in process. SQL has no directory-scan cache to invalidate. */
-export function invalidateTicketCounts() { }
-function ticketSubjects() {
-    const subjects = new Map();
-    for (const request of listOpenReplyBearingRequests()) {
-        const nodeId = request.requester_node_id;
-        const list = subjects.get(nodeId);
-        if (list === undefined)
-            subjects.set(nodeId, [request.title]);
-        else
-            list.push(request.title);
-    }
-    return subjects;
-}
-/** Count pending tickets asked by one node. */
-export function countTickets(nodeId) { return ticketSubjects().get(nodeId)?.length ?? 0; }
-/** Pending tickets for every reachable asking node, including the root. */
-export function pendingTicketsForView(rootId) {
-    const found = ticketSubjects();
-    const entries = [];
-    for (const id of [rootId, ...view(rootId)]) {
-        const node = getNode(id);
-        const subjects = found.get(id) ?? [];
-        if (node !== null && subjects.length > 0)
-            entries.push({ node_id: id, name: node.name, cwd: node.cwd, count: subjects.length, subjects });
-    }
-    return entries;
-}
-/** Per-node pending ticket counts for an explicit node set. */
-export function ticketCountsForNodes(ids) {
-    const found = ticketSubjects();
-    return Object.fromEntries(ids.map((id) => [id, found.get(id)?.length ?? 0]));
-}
-/** Pending tickets across the entire canvas, attributed to asking nodes. */
-export function ticketsAcrossCanvas() {
-    const found = ticketSubjects();
-    const entries = [];
-    for (const node of listNodes()) {
-        const subjects = found.get(node.node_id) ?? [];
-        if (subjects.length > 0)
-            entries.push({ node_id: node.node_id, name: node.name, cwd: node.cwd, count: subjects.length, subjects });
-    }
-    return entries;
-}
+var u=Object.defineProperty;var s=(t,n)=>u(t,"name",{value:n,configurable:!0});import{listOpenReplyBearingRequests as d}from"../human/requests.js";import{getNode as f,listNodes as l,view as p}from"./canvas.js";function h(){}s(h,"invalidateTicketCounts");function c(){const t=new Map;for(const n of d()){const e=n.requester_node_id,o=t.get(e);o===void 0?t.set(e,[n.title]):o.push(n.title)}return t}s(c,"ticketSubjects");function w(t){return c().get(t)?.length??0}s(w,"countTickets");function k(t){const n=c(),e=[];for(const o of[t,...p(t)]){const i=f(o),r=n.get(o)??[];i!==null&&r.length>0&&e.push({node_id:o,name:i.name,cwd:i.cwd,count:r.length,subjects:r})}return e}s(k,"pendingTicketsForView");function _(t){const n=c();return Object.fromEntries(t.map(e=>[e,n.get(e)?.length??0]))}s(_,"ticketCountsForNodes");function b(){const t=c(),n=[];for(const e of l()){const o=t.get(e.node_id)??[];o.length>0&&n.push({node_id:e.node_id,name:e.name,cwd:e.cwd,count:o.length,subjects:o})}return n}s(b,"ticketsAcrossCanvas");export{w as countTickets,h as invalidateTicketCounts,k as pendingTicketsForView,_ as ticketCountsForNodes,b as ticketsAcrossCanvas};

package/dist/core/canvas/boot-id.js

@@ -1,26 +1 @@
-// boot-id.ts — the PURE kernel-boot-identity reader, split out of boot.ts so the
-// low-level liveness probe (`canvas/pid.ts`) can import it WITHOUT dragging in
-// boot.ts's `openDb` persistence machinery. boot.ts's boot-change reconciler
-// persists the last-seen identity in canvas.db (hence its top-level `openDb`
-// import); `readKernelBootId` itself is a plain `/proc` read with zero db reach,
-// and `pid.ts` needs only that. Keeping it here means `pid.ts` (and everything
-// that imports it down — including the CLI's daemon-liveness front door) stays
-// canvas.db-free.
-//
-// PURITY: Node built-ins only. Never `core/canvas/db.js` or any db-touching
-// module.
-import { readFileSync } from 'node:fs';
-/** The Linux kernel's per-boot identity at `/proc/sys/kernel/random/boot_id` —
- *  a fresh random UUID minted on every kernel boot, or null when unreadable
- *  (non-Linux dev, or the file is absent). Exact when present: a microVM
- *  recreate boots a new kernel (new id); a plain daemon restart within the same
- *  boot leaves it identical. */
-export function readKernelBootId() {
-    try {
-        const id = readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim();
-        return id.length > 0 ? id : null;
-    }
-    catch {
-        return null; // non-Linux, or unreadable — fall back to the wall-clock epoch
-    }
-}
+var e=Object.defineProperty;var t=(r,n)=>e(r,"name",{value:n,configurable:!0});import{readFileSync as o}from"node:fs";function d(){try{const r=o("/proc/sys/kernel/random/boot_id","utf8").trim();return r.length>0?r:null}catch{return null}}t(d,"readKernelBootId");export{d as readKernelBootId};