@termwright/probe-runtime 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 gorce-ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# @termwright/probe-runtime
+
+Framework-neutral, fail-closed socket transport shared by zero-config
+JavaScript probes. It owns handshake validation, full-snapshot publication,
+revision commits, marker authentication, `get-tree`, limits and channel
+shutdown.
+
+It intentionally does not observe framework state or write markers. Only the
+framework probe knows when its render bytes have drained, so marker placement
+stays in `@termwright/probe-ink` and `@termwright/probe-opentui`.
+
+## Debug performance metrics
+
+`ProbeChannel.performanceMetrics()` returns immutable transport telemetry.
+Collection turns on automatically with `TERMWRIGHT_DEBUG=1`/`all` or
+`TERMWRIGHT_DEBUG_FILE`, and can be forced with `connectProbe({
+performanceMetrics: true, ... })`. Disabled sessions do not call the timer.
+
+The snapshot reports full snapshots, deltas, encoded semantic bytes, node and
+generic-node counts, failed publications, requested markers and serialization
+time, together with per-frame averages. Framework sessions also supply their
+Probe IR fact count and report publications superseded in their marker queue.
+Fields the shared transport cannot see stay `null`: parent normalization and
+whether the framework-specific sink actually drained a marker.
+
+Injected applications do not need a channel handle to inspect these values:
+set `TERMWRIGHT_DEBUG_FILE=/path/to/adapter.log`. The runtime appends a
+`termwright-probe-performance` JSONL record after each publication and
+coalescing update. Records contain counters and timings only, never semantic
+text or the authentication token. Debug-file failures are fail-open and cannot
+stop the application.

package/dist/index.d.ts

@@ -0,0 +1,121 @@
+import { Socket } from 'node:net';
+import { ProtocolId, ProtocolLimits, ProbeInfo, AdapterCapability, FrameDecoder, SemanticSnapshot } from '@termwright/protocol';
+
+/**
+ * Shared process-to-driver transport for zero-config JavaScript probes.
+ *
+ * Framework probes deliberately keep observation and marker placement in
+ * their own packages. This module owns only the framework-neutral handshake,
+ * full-snapshot publication and fail-closed socket lifecycle.
+ */
+
+/** What the driver decided for this session. */
+interface ChannelSession {
+    readonly protocol: ProtocolId;
+    readonly sessionId: string;
+    readonly limits: ProtocolLimits;
+    readonly markerEnabled: boolean;
+}
+/** Connection parameters. */
+interface ConnectOptions {
+    readonly endpoint: string;
+    readonly token: string;
+    readonly probe: ProbeInfo;
+    readonly capabilities: readonly AdapterCapability[];
+    readonly adapterName: string;
+    readonly adapterVersion: string;
+    readonly protocol?: ProtocolId;
+    /** Milliseconds for connect plus handshake. Default 1000. */
+    readonly handshakeTimeoutMs?: number;
+    /**
+     * Collect per-publication counters and timings.
+     *
+     * Defaults on when `TERMWRIGHT_DEBUG` enables driver diagnostics or an
+     * adapter debug file is configured. Explicit false keeps even the timer off.
+     */
+    readonly performanceMetrics?: boolean;
+    /**
+     * Append machine-readable performance snapshots here. Defaults to
+     * `TERMWRIGHT_DEBUG_FILE`; write failures never affect the application.
+     */
+    readonly performanceMetricsFile?: string;
+}
+/** Debug-only facts the shared transport can observe without guessing. */
+interface ProbePerformanceMetrics {
+    readonly enabled: boolean;
+    readonly fullSnapshots: number;
+    readonly deltas: number;
+    readonly semanticBytes: number;
+    readonly semanticNodes: number;
+    readonly unknownFrameworkNodes: number;
+    readonly droppedEvents: number;
+    readonly markerRequests: number;
+    readonly serializationMicroseconds: number;
+    readonly averageBytesPerFrame: number | null;
+    readonly averageSemanticNodesPerFrame: number | null;
+    readonly averageUnknownFrameworkNodesPerFrame: number | null;
+    readonly averageSerializationMicrosecondsPerFrame: number | null;
+    /** Present when the framework session supplies its pre-normalized fact count. */
+    readonly probeEventsPerFrame: number | null;
+    /** Superseded publications reported by a framework-owned marker queue. */
+    readonly coalescedEvents: number;
+    /** Only the framework-specific sink knows whether a returned marker drained. */
+    readonly renderCorrelationRate: null;
+    /** Normalization currently happens before the shared transport is called. */
+    readonly parentNormalizationMicrosecondsPerFrame: null;
+}
+interface ProbePublicationMetrics {
+    /** Probe IR objects plus render/layout operations observed for this frame. */
+    readonly probeEvents?: number;
+}
+/** One JSONL record written by an injected probe in debug-file mode. */
+interface ProbePerformanceRecord {
+    readonly kind: 'termwright-probe-performance';
+    readonly adapter: string;
+    readonly framework: string;
+    readonly sessionId: string;
+    readonly metrics: ProbePerformanceMetrics;
+}
+/**
+ * A connected channel.
+ *
+ * `publish` returns the marker rather than writing it. Only a framework probe
+ * knows when its frame bytes have drained, and emitting earlier silently pairs
+ * the tree with the wrong screen.
+ */
+declare class ProbeChannel {
+    #private;
+    readonly session: ChannelSession;
+    /** @internal Built by {@link connectProbe} once the handshake succeeded. */
+    constructor(socket: Socket, session: ChannelSession, token: string, decoder: FrameDecoder, pending?: readonly unknown[], performanceMetrics?: boolean, performanceSink?: (metrics: ProbePerformanceMetrics) => void);
+    get isOpen(): boolean;
+    /** Revisions published so far. */
+    get revision(): number;
+    /**
+     * A stable, immutable debug snapshot. Disabled collection reports no
+     * fabricated zeros for averages that were never observed.
+     */
+    performanceMetrics(): ProbePerformanceMetrics;
+    /**
+     * Send a full tree and commit its revision.
+     *
+     * Full snapshots satisfy the producer side of dropped-frame recovery by
+     * construction. Diff subscription can be added later without weakening this
+     * initial correctness floor.
+     */
+    publish(snapshot: SemanticSnapshot, publication?: ProbePublicationMetrics): string | undefined;
+    /** Report a framework publication superseded before its marker could drain. */
+    recordCoalescedEvent(): void;
+    /** Disable the channel and release the socket. Idempotent. */
+    close(): void;
+}
+/**
+ * Connect and complete the handshake.
+ *
+ * Any failure resolves to `null`. A refused socket, malformed acknowledgement
+ * or disappearing driver must be indistinguishable from disabled semantics to
+ * the application.
+ */
+declare function connectProbe(options: ConnectOptions): Promise<ProbeChannel | null>;
+
+export { type ChannelSession, type ConnectOptions, ProbeChannel, type ProbePerformanceMetrics, type ProbePerformanceRecord, type ProbePublicationMetrics, connectProbe };

package/dist/index.js

@@ -0,0 +1,363 @@
+// src/index.ts
+import { createConnection } from "net";
+import { appendFileSync } from "fs";
+import { performance } from "perf_hooks";
+import {
+  createFrameDecoder,
+  encodeFrame,
+  encodeMarker,
+  parseDriverMessage,
+  DEFAULT_LIMITS,
+  PROTOCOL_ID
+} from "@termwright/protocol";
+var DEFAULT_HANDSHAKE_TIMEOUT_MS = 1e3;
+var ProbeChannel = class {
+  #socket;
+  session;
+  #token;
+  #open = true;
+  #revision = 0;
+  #latest;
+  #performance;
+  #performanceSink;
+  /** @internal Built by {@link connectProbe} once the handshake succeeded. */
+  constructor(socket, session, token, decoder, pending = [], performanceMetrics = false, performanceSink) {
+    this.#socket = socket;
+    this.session = session;
+    this.#token = token;
+    this.#performance = performanceMetrics ? {
+      fullSnapshots: 0,
+      semanticBytes: 0,
+      semanticNodes: 0,
+      unknownFrameworkNodes: 0,
+      droppedEvents: 0,
+      markerRequests: 0,
+      serializationMicroseconds: 0,
+      probeEvents: 0,
+      framesWithProbeEvents: 0,
+      coalescedEvents: 0
+    } : null;
+    this.#performanceSink = performanceSink === void 0 ? null : () => performanceSink(this.performanceMetrics());
+    socket.on("data", (chunk) => {
+      if (!this.#open) return;
+      try {
+        for (const value of decoder.push(chunk)) this.#dispatch(value);
+      } catch {
+        this.close();
+      }
+    });
+    socket.on("error", () => this.close());
+    socket.on("close", () => this.close());
+    for (const value of pending) this.#dispatch(value);
+  }
+  get isOpen() {
+    return this.#open;
+  }
+  /** Revisions published so far. */
+  get revision() {
+    return this.#revision;
+  }
+  /**
+   * A stable, immutable debug snapshot. Disabled collection reports no
+   * fabricated zeros for averages that were never observed.
+   */
+  performanceMetrics() {
+    const metrics = this.#performance;
+    if (metrics === null) {
+      return Object.freeze({
+        enabled: false,
+        fullSnapshots: 0,
+        deltas: 0,
+        semanticBytes: 0,
+        semanticNodes: 0,
+        unknownFrameworkNodes: 0,
+        droppedEvents: 0,
+        markerRequests: 0,
+        serializationMicroseconds: 0,
+        averageBytesPerFrame: null,
+        averageSemanticNodesPerFrame: null,
+        averageUnknownFrameworkNodesPerFrame: null,
+        averageSerializationMicrosecondsPerFrame: null,
+        probeEventsPerFrame: null,
+        coalescedEvents: 0,
+        renderCorrelationRate: null,
+        parentNormalizationMicrosecondsPerFrame: null
+      });
+    }
+    const frames = metrics.fullSnapshots;
+    return Object.freeze({
+      enabled: true,
+      fullSnapshots: frames,
+      // ProbeChannel deliberately does not advertise tree-diffs.
+      deltas: 0,
+      semanticBytes: metrics.semanticBytes,
+      semanticNodes: metrics.semanticNodes,
+      unknownFrameworkNodes: metrics.unknownFrameworkNodes,
+      droppedEvents: metrics.droppedEvents,
+      markerRequests: metrics.markerRequests,
+      serializationMicroseconds: metrics.serializationMicroseconds,
+      averageBytesPerFrame: average(metrics.semanticBytes, frames),
+      averageSemanticNodesPerFrame: average(metrics.semanticNodes, frames),
+      averageUnknownFrameworkNodesPerFrame: average(metrics.unknownFrameworkNodes, frames),
+      averageSerializationMicrosecondsPerFrame: average(
+        metrics.serializationMicroseconds,
+        frames
+      ),
+      probeEventsPerFrame: average(metrics.probeEvents, metrics.framesWithProbeEvents),
+      coalescedEvents: metrics.coalescedEvents,
+      renderCorrelationRate: null,
+      parentNormalizationMicrosecondsPerFrame: null
+    });
+  }
+  /**
+   * Send a full tree and commit its revision.
+   *
+   * Full snapshots satisfy the producer side of dropped-frame recovery by
+   * construction. Diff subscription can be added later without weakening this
+   * initial correctness floor.
+   */
+  publish(snapshot, publication = {}) {
+    if (!this.#open) {
+      if (this.#performance !== null) this.#performance.droppedEvents += 1;
+      return void 0;
+    }
+    const sent = this.#send(
+      { type: "snapshot", snapshot },
+      this.#performance !== null
+    );
+    if (sent === void 0) {
+      if (this.#performance !== null) this.#performance.droppedEvents += 1;
+      this.#emitPerformance();
+      return void 0;
+    }
+    this.#revision = snapshot.revision;
+    this.#latest = snapshot;
+    if (this.#performance !== null) {
+      this.#performance.fullSnapshots += 1;
+      this.#performance.semanticBytes += sent.bytes;
+      this.#performance.semanticNodes += snapshot.nodes.length;
+      this.#performance.unknownFrameworkNodes += snapshot.nodes.filter(
+        (node) => node.role === "generic"
+      ).length;
+      this.#performance.serializationMicroseconds += sent.serializationMicroseconds;
+      if (publication.probeEvents !== void 0 && Number.isSafeInteger(publication.probeEvents) && publication.probeEvents >= 0) {
+        this.#performance.probeEvents += publication.probeEvents;
+        this.#performance.framesWithProbeEvents += 1;
+      }
+    }
+    if (this.#send({ type: "revision-commit", revision: snapshot.revision }) === void 0) {
+      if (this.#performance !== null) this.#performance.droppedEvents += 1;
+      this.#emitPerformance();
+      return void 0;
+    }
+    if (!this.session.markerEnabled) {
+      this.#emitPerformance();
+      return void 0;
+    }
+    try {
+      const marker = encodeMarker(this.#token, this.session.sessionId, snapshot.revision);
+      if (this.#performance !== null) this.#performance.markerRequests += 1;
+      this.#emitPerformance();
+      return marker;
+    } catch {
+      this.#emitPerformance();
+      return void 0;
+    }
+  }
+  /** Report a framework publication superseded before its marker could drain. */
+  recordCoalescedEvent() {
+    if (this.#performance !== null) {
+      this.#performance.coalescedEvents += 1;
+      this.#emitPerformance();
+    }
+  }
+  /** Disable the channel and release the socket. Idempotent. */
+  close() {
+    if (!this.#open) return;
+    this.#open = false;
+    this.#latest = void 0;
+    this.#socket.removeAllListeners("data");
+    this.#socket.destroy();
+  }
+  #dispatch(value) {
+    const parsed = parseDriverMessage(value, this.session.limits);
+    if (!parsed.ok) {
+      this.close();
+      return;
+    }
+    const message = parsed.message;
+    if (message.type === "error") {
+      this.close();
+      return;
+    }
+    if (message.type !== "get-tree") return;
+    const held = this.#latest;
+    const usable = held !== void 0 && (message.revision === void 0 || message.revision === held.revision);
+    this.#send(
+      usable ? { type: "get-tree-result", requestId: message.requestId, snapshot: held } : { type: "get-tree-result", requestId: message.requestId, error: "revision not retained" }
+    );
+  }
+  #send(message, measureSerialization = false) {
+    if (!this.#open) return void 0;
+    let frame;
+    let serializationMicroseconds;
+    try {
+      const started = measureSerialization ? performance.now() : 0;
+      frame = encodeFrame(message, this.session.limits.maxFrameBytes);
+      serializationMicroseconds = measureSerialization ? (performance.now() - started) * 1e3 : 0;
+    } catch {
+      return void 0;
+    }
+    try {
+      this.#socket.write(frame);
+      return { bytes: frame.byteLength, serializationMicroseconds };
+    } catch {
+      this.close();
+      return void 0;
+    }
+  }
+  #emitPerformance() {
+    try {
+      this.#performanceSink?.();
+    } catch {
+    }
+  }
+};
+function average(total, count) {
+  return count === 0 ? null : total / count;
+}
+function debugMetricsEnabled(env) {
+  if ((env["TERMWRIGHT_DEBUG_FILE"] ?? "").trim().length > 0) return true;
+  const value = (env["TERMWRIGHT_DEBUG"] ?? "").trim().toLowerCase();
+  return value === "1" || value === "true" || value === "api" || value === "all" || value === "on";
+}
+function performanceFile(env) {
+  const path = (env["TERMWRIGHT_DEBUG_FILE"] ?? "").trim();
+  return path.length === 0 ? void 0 : path;
+}
+function filePerformanceSink(path, context) {
+  if (path === void 0) return void 0;
+  return (metrics) => {
+    const record = {
+      kind: "termwright-probe-performance",
+      adapter: context.adapter,
+      framework: context.framework,
+      sessionId: context.sessionId,
+      metrics
+    };
+    appendFileSync(path, `${JSON.stringify(record)}
+`, "utf8");
+  };
+}
+async function connectProbe(options) {
+  const timeoutMs = options.handshakeTimeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT_MS;
+  return new Promise((resolve) => {
+    let settled = false;
+    let socket;
+    const decoder = createFrameDecoder(DEFAULT_LIMITS.maxFrameBytes);
+    const timer = setTimeout(() => abandon(), timeoutMs);
+    timer.unref();
+    const detach = () => {
+      clearTimeout(timer);
+      for (const event of ["connect", "data", "error", "close"]) socket.removeAllListeners(event);
+    };
+    const abandon = () => {
+      if (settled) return;
+      settled = true;
+      detach();
+      socket.destroy();
+      resolve(null);
+    };
+    const accept = (session, pending) => {
+      if (settled) return;
+      settled = true;
+      detach();
+      const metricsPath = options.performanceMetricsFile ?? performanceFile(process.env);
+      resolve(new ProbeChannel(
+        socket,
+        session,
+        options.token,
+        decoder,
+        pending,
+        options.performanceMetrics ?? (metricsPath !== void 0 || debugMetricsEnabled(process.env)),
+        filePerformanceSink(metricsPath, {
+          adapter: options.adapterName,
+          framework: options.probe.framework,
+          sessionId: session.sessionId
+        })
+      ));
+    };
+    try {
+      socket = createConnection(options.endpoint);
+      socket.unref();
+    } catch {
+      clearTimeout(timer);
+      resolve(null);
+      return;
+    }
+    socket.on("error", abandon);
+    socket.on("close", abandon);
+    socket.on("connect", () => {
+      try {
+        socket.write(
+          encodeFrame(
+            {
+              type: "hello",
+              protocol: options.protocol ?? PROTOCOL_ID,
+              token: options.token,
+              adapter: { name: options.adapterName, version: options.adapterVersion },
+              capabilities: options.capabilities,
+              probe: options.probe
+            },
+            DEFAULT_LIMITS.maxFrameBytes
+          )
+        );
+      } catch {
+        abandon();
+      }
+    });
+    socket.on("data", (chunk) => {
+      if (settled) return;
+      let messages;
+      try {
+        messages = decoder.push(chunk);
+      } catch {
+        abandon();
+        return;
+      }
+      if (messages.length === 0) return;
+      const parsed = parseDriverMessage(messages[0], DEFAULT_LIMITS);
+      if (!parsed.ok || parsed.message.type !== "hello-ack") {
+        abandon();
+        return;
+      }
+      const ack = parsed.message;
+      if (ack.protocol !== (options.protocol ?? PROTOCOL_ID)) {
+        abandon();
+        return;
+      }
+      accept(
+        {
+          protocol: ack.protocol,
+          sessionId: ack.sessionId,
+          limits: narrowLimits(ack.limits),
+          markerEnabled: ack.marker.enabled
+        },
+        messages.slice(1)
+      );
+    });
+  });
+}
+function narrowLimits(offered) {
+  const entries = Object.entries(DEFAULT_LIMITS).map(([key, fallback]) => {
+    const value = offered[key];
+    const usable = typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+    return [key, usable ? Math.min(value, fallback) : fallback];
+  });
+  return Object.freeze(Object.fromEntries(entries));
+}
+export {
+  ProbeChannel,
+  connectProbe
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * Shared process-to-driver transport for zero-config JavaScript probes.\n *\n * Framework probes deliberately keep observation and marker placement in\n * their own packages. This module owns only the framework-neutral handshake,\n * full-snapshot publication and fail-closed socket lifecycle.\n */\n\nimport { createConnection, type Socket } from 'node:net';\nimport { appendFileSync } from 'node:fs';\nimport { performance } from 'node:perf_hooks';\nimport {\n  createFrameDecoder,\n  encodeFrame,\n  encodeMarker,\n  parseDriverMessage,\n  DEFAULT_LIMITS,\n  PROTOCOL_ID,\n  type ProtocolId,\n  type AdapterCapability,\n  type AdapterToDriverMessage,\n  type FrameDecoder,\n  type ProbeInfo,\n  type ProtocolLimits,\n  type SemanticSnapshot,\n} from '@termwright/protocol';\n\n/** What the driver decided for this session. */\nexport interface ChannelSession {\n  readonly protocol: ProtocolId;\n  readonly sessionId: string;\n  readonly limits: ProtocolLimits;\n  readonly markerEnabled: boolean;\n}\n\n/** Connection parameters. */\nexport interface ConnectOptions {\n  readonly endpoint: string;\n  readonly token: string;\n  readonly probe: ProbeInfo;\n  readonly capabilities: readonly AdapterCapability[];\n  readonly adapterName: string;\n  readonly adapterVersion: string;\n  readonly protocol?: ProtocolId;\n  /** Milliseconds for connect plus handshake. Default 1000. */\n  readonly handshakeTimeoutMs?: number;\n  /**\n   * Collect per-publication counters and timings.\n   *\n   * Defaults on when `TERMWRIGHT_DEBUG` enables driver diagnostics or an\n   * adapter debug file is configured. Explicit false keeps even the timer off.\n   */\n  readonly performanceMetrics?: boolean;\n  /**\n   * Append machine-readable performance snapshots here. Defaults to\n   * `TERMWRIGHT_DEBUG_FILE`; write failures never affect the application.\n   */\n  readonly performanceMetricsFile?: string;\n}\n\n/** Debug-only facts the shared transport can observe without guessing. */\nexport interface ProbePerformanceMetrics {\n  readonly enabled: boolean;\n  readonly fullSnapshots: number;\n  readonly deltas: number;\n  readonly semanticBytes: number;\n  readonly semanticNodes: number;\n  readonly unknownFrameworkNodes: number;\n  readonly droppedEvents: number;\n  readonly markerRequests: number;\n  readonly serializationMicroseconds: number;\n  readonly averageBytesPerFrame: number | null;\n  readonly averageSemanticNodesPerFrame: number | null;\n  readonly averageUnknownFrameworkNodesPerFrame: number | null;\n  readonly averageSerializationMicrosecondsPerFrame: number | null;\n  /** Present when the framework session supplies its pre-normalized fact count. */\n  readonly probeEventsPerFrame: number | null;\n  /** Superseded publications reported by a framework-owned marker queue. */\n  readonly coalescedEvents: number;\n  /** Only the framework-specific sink knows whether a returned marker drained. */\n  readonly renderCorrelationRate: null;\n  /** Normalization currently happens before the shared transport is called. */\n  readonly parentNormalizationMicrosecondsPerFrame: null;\n}\n\ninterface MutableProbePerformanceMetrics {\n  fullSnapshots: number;\n  semanticBytes: number;\n  semanticNodes: number;\n  unknownFrameworkNodes: number;\n  droppedEvents: number;\n  markerRequests: number;\n  serializationMicroseconds: number;\n  probeEvents: number;\n  framesWithProbeEvents: number;\n  coalescedEvents: number;\n}\n\nexport interface ProbePublicationMetrics {\n  /** Probe IR objects plus render/layout operations observed for this frame. */\n  readonly probeEvents?: number;\n}\n\n/** One JSONL record written by an injected probe in debug-file mode. */\nexport interface ProbePerformanceRecord {\n  readonly kind: 'termwright-probe-performance';\n  readonly adapter: string;\n  readonly framework: string;\n  readonly sessionId: string;\n  readonly metrics: ProbePerformanceMetrics;\n}\n\ninterface SendResult {\n  readonly bytes: number;\n  readonly serializationMicroseconds: number;\n}\n\nconst DEFAULT_HANDSHAKE_TIMEOUT_MS = 1_000;\n\n/**\n * A connected channel.\n *\n * `publish` returns the marker rather than writing it. Only a framework probe\n * knows when its frame bytes have drained, and emitting earlier silently pairs\n * the tree with the wrong screen.\n */\nexport class ProbeChannel {\n  readonly #socket: Socket;\n  readonly session: ChannelSession;\n  readonly #token: string;\n  #open = true;\n  #revision = 0;\n  #latest: SemanticSnapshot | undefined;\n  readonly #performance: MutableProbePerformanceMetrics | null;\n  readonly #performanceSink: (() => void) | null;\n\n  /** @internal Built by {@link connectProbe} once the handshake succeeded. */\n  constructor(\n    socket: Socket,\n    session: ChannelSession,\n    token: string,\n    decoder: FrameDecoder,\n    pending: readonly unknown[] = [],\n    performanceMetrics = false,\n    performanceSink?: (metrics: ProbePerformanceMetrics) => void,\n  ) {\n    this.#socket = socket;\n    this.session = session;\n    this.#token = token;\n    this.#performance = performanceMetrics\n      ? {\n          fullSnapshots: 0,\n          semanticBytes: 0,\n          semanticNodes: 0,\n          unknownFrameworkNodes: 0,\n          droppedEvents: 0,\n          markerRequests: 0,\n          serializationMicroseconds: 0,\n          probeEvents: 0,\n          framesWithProbeEvents: 0,\n          coalescedEvents: 0,\n        }\n      : null;\n    this.#performanceSink = performanceSink === undefined\n      ? null\n      : () => performanceSink(this.performanceMetrics());\n\n    socket.on('data', (chunk: Buffer) => {\n      if (!this.#open) return;\n      try {\n        for (const value of decoder.push(chunk)) this.#dispatch(value);\n      } catch {\n        this.close();\n      }\n    });\n    socket.on('error', () => this.close());\n    socket.on('close', () => this.close());\n\n    // The ACK and the driver's first request may share one pipe/TCP chunk. The\n    // handshake decoder already removed every complete frame from its buffer,\n    // so values after the ACK must be handed over explicitly or they vanish.\n    for (const value of pending) this.#dispatch(value);\n  }\n\n  get isOpen(): boolean {\n    return this.#open;\n  }\n\n  /** Revisions published so far. */\n  get revision(): number {\n    return this.#revision;\n  }\n\n  /**\n   * A stable, immutable debug snapshot. Disabled collection reports no\n   * fabricated zeros for averages that were never observed.\n   */\n  performanceMetrics(): ProbePerformanceMetrics {\n    const metrics = this.#performance;\n    if (metrics === null) {\n      return Object.freeze({\n        enabled: false,\n        fullSnapshots: 0,\n        deltas: 0,\n        semanticBytes: 0,\n        semanticNodes: 0,\n        unknownFrameworkNodes: 0,\n        droppedEvents: 0,\n        markerRequests: 0,\n        serializationMicroseconds: 0,\n        averageBytesPerFrame: null,\n        averageSemanticNodesPerFrame: null,\n        averageUnknownFrameworkNodesPerFrame: null,\n        averageSerializationMicrosecondsPerFrame: null,\n        probeEventsPerFrame: null,\n        coalescedEvents: 0,\n        renderCorrelationRate: null,\n        parentNormalizationMicrosecondsPerFrame: null,\n      });\n    }\n    const frames = metrics.fullSnapshots;\n    return Object.freeze({\n      enabled: true,\n      fullSnapshots: frames,\n      // ProbeChannel deliberately does not advertise tree-diffs.\n      deltas: 0,\n      semanticBytes: metrics.semanticBytes,\n      semanticNodes: metrics.semanticNodes,\n      unknownFrameworkNodes: metrics.unknownFrameworkNodes,\n      droppedEvents: metrics.droppedEvents,\n      markerRequests: metrics.markerRequests,\n      serializationMicroseconds: metrics.serializationMicroseconds,\n      averageBytesPerFrame: average(metrics.semanticBytes, frames),\n      averageSemanticNodesPerFrame: average(metrics.semanticNodes, frames),\n      averageUnknownFrameworkNodesPerFrame: average(metrics.unknownFrameworkNodes, frames),\n      averageSerializationMicrosecondsPerFrame: average(\n        metrics.serializationMicroseconds,\n        frames,\n      ),\n      probeEventsPerFrame: average(metrics.probeEvents, metrics.framesWithProbeEvents),\n      coalescedEvents: metrics.coalescedEvents,\n      renderCorrelationRate: null,\n      parentNormalizationMicrosecondsPerFrame: null,\n    });\n  }\n\n  /**\n   * Send a full tree and commit its revision.\n   *\n   * Full snapshots satisfy the producer side of dropped-frame recovery by\n   * construction. Diff subscription can be added later without weakening this\n   * initial correctness floor.\n   */\n  publish(\n    snapshot: SemanticSnapshot,\n    publication: ProbePublicationMetrics = {},\n  ): string | undefined {\n    if (!this.#open) {\n      if (this.#performance !== null) this.#performance.droppedEvents += 1;\n      return undefined;\n    }\n    const sent = this.#send(\n      { type: 'snapshot', snapshot },\n      this.#performance !== null,\n    );\n    if (sent === undefined) {\n      if (this.#performance !== null) this.#performance.droppedEvents += 1;\n      this.#emitPerformance();\n      return undefined;\n    }\n    this.#revision = snapshot.revision;\n    this.#latest = snapshot;\n    if (this.#performance !== null) {\n      this.#performance.fullSnapshots += 1;\n      this.#performance.semanticBytes += sent.bytes;\n      this.#performance.semanticNodes += snapshot.nodes.length;\n      this.#performance.unknownFrameworkNodes += snapshot.nodes.filter(\n        (node) => node.role === 'generic',\n      ).length;\n      this.#performance.serializationMicroseconds += sent.serializationMicroseconds;\n      if (\n        publication.probeEvents !== undefined\n        && Number.isSafeInteger(publication.probeEvents)\n        && publication.probeEvents >= 0\n      ) {\n        this.#performance.probeEvents += publication.probeEvents;\n        this.#performance.framesWithProbeEvents += 1;\n      }\n    }\n    if (this.#send({ type: 'revision-commit', revision: snapshot.revision }) === undefined) {\n      if (this.#performance !== null) this.#performance.droppedEvents += 1;\n      this.#emitPerformance();\n      return undefined;\n    }\n\n    if (!this.session.markerEnabled) {\n      this.#emitPerformance();\n      return undefined;\n    }\n    try {\n      const marker = encodeMarker(this.#token, this.session.sessionId, snapshot.revision);\n      if (this.#performance !== null) this.#performance.markerRequests += 1;\n      this.#emitPerformance();\n      return marker;\n    } catch {\n      this.#emitPerformance();\n      return undefined;\n    }\n  }\n\n  /** Report a framework publication superseded before its marker could drain. */\n  recordCoalescedEvent(): void {\n    if (this.#performance !== null) {\n      this.#performance.coalescedEvents += 1;\n      this.#emitPerformance();\n    }\n  }\n\n  /** Disable the channel and release the socket. Idempotent. */\n  close(): void {\n    if (!this.#open) return;\n    this.#open = false;\n    this.#latest = undefined;\n    this.#socket.removeAllListeners('data');\n    this.#socket.destroy();\n  }\n\n  #dispatch(value: unknown): void {\n    const parsed = parseDriverMessage(value, this.session.limits);\n    if (!parsed.ok) {\n      this.close();\n      return;\n    }\n    const message = parsed.message;\n    if (message.type === 'error') {\n      this.close();\n      return;\n    }\n    if (message.type !== 'get-tree') return;\n\n    const held = this.#latest;\n    const usable = held !== undefined\n      && (message.revision === undefined || message.revision === held.revision);\n    this.#send(\n      usable\n        ? { type: 'get-tree-result', requestId: message.requestId, snapshot: held }\n        : { type: 'get-tree-result', requestId: message.requestId, error: 'revision not retained' },\n    );\n  }\n\n  #send(message: AdapterToDriverMessage, measureSerialization = false): SendResult | undefined {\n    if (!this.#open) return undefined;\n    let frame: Uint8Array;\n    let serializationMicroseconds: number;\n    try {\n      const started = measureSerialization ? performance.now() : 0;\n      frame = encodeFrame(message, this.session.limits.maxFrameBytes);\n      serializationMicroseconds = measureSerialization\n        ? (performance.now() - started) * 1_000\n        : 0;\n    } catch {\n      // This is locally produced data and encodeFrame writes nothing before it\n      // rejects. Drop only this publication: a later, smaller framework frame\n      // can still be valid and must not lose the already negotiated channel.\n      return undefined;\n    }\n    try {\n      this.#socket.write(frame);\n      return { bytes: frame.byteLength, serializationMicroseconds };\n    } catch {\n      this.close();\n      return undefined;\n    }\n  }\n\n  #emitPerformance(): void {\n    try {\n      this.#performanceSink?.();\n    } catch {\n      // Debug output is strictly fail-open: a bad path cannot break rendering.\n    }\n  }\n}\n\nfunction average(total: number, count: number): number | null {\n  return count === 0 ? null : total / count;\n}\n\nfunction debugMetricsEnabled(env: NodeJS.ProcessEnv): boolean {\n  if ((env['TERMWRIGHT_DEBUG_FILE'] ?? '').trim().length > 0) return true;\n  const value = (env['TERMWRIGHT_DEBUG'] ?? '').trim().toLowerCase();\n  return value === '1' || value === 'true' || value === 'api' || value === 'all' || value === 'on';\n}\n\nfunction performanceFile(env: NodeJS.ProcessEnv): string | undefined {\n  const path = (env['TERMWRIGHT_DEBUG_FILE'] ?? '').trim();\n  return path.length === 0 ? undefined : path;\n}\n\nfunction filePerformanceSink(\n  path: string | undefined,\n  context: { readonly adapter: string; readonly framework: string; readonly sessionId: string },\n): ((metrics: ProbePerformanceMetrics) => void) | undefined {\n  if (path === undefined) return undefined;\n  return (metrics) => {\n    const record: ProbePerformanceRecord = {\n      kind: 'termwright-probe-performance',\n      adapter: context.adapter,\n      framework: context.framework,\n      sessionId: context.sessionId,\n      metrics,\n    };\n    appendFileSync(path, `${JSON.stringify(record)}\\n`, 'utf8');\n  };\n}\n\n/**\n * Connect and complete the handshake.\n *\n * Any failure resolves to `null`. A refused socket, malformed acknowledgement\n * or disappearing driver must be indistinguishable from disabled semantics to\n * the application.\n */\nexport async function connectProbe(options: ConnectOptions): Promise<ProbeChannel | null> {\n  const timeoutMs = options.handshakeTimeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT_MS;\n\n  return new Promise<ProbeChannel | null>((resolve) => {\n    let settled = false;\n    let socket: Socket;\n    const decoder = createFrameDecoder(DEFAULT_LIMITS.maxFrameBytes);\n    const timer = setTimeout(() => abandon(), timeoutMs);\n    timer.unref();\n\n    const detach = (): void => {\n      clearTimeout(timer);\n      for (const event of ['connect', 'data', 'error', 'close']) socket.removeAllListeners(event);\n    };\n    const abandon = (): void => {\n      if (settled) return;\n      settled = true;\n      detach();\n      socket.destroy();\n      resolve(null);\n    };\n    const accept = (session: ChannelSession, pending: readonly unknown[]): void => {\n      if (settled) return;\n      settled = true;\n      detach();\n      const metricsPath = options.performanceMetricsFile ?? performanceFile(process.env);\n      resolve(new ProbeChannel(\n        socket,\n        session,\n        options.token,\n        decoder,\n        pending,\n        options.performanceMetrics ?? (metricsPath !== undefined || debugMetricsEnabled(process.env)),\n        filePerformanceSink(metricsPath, {\n          adapter: options.adapterName,\n          framework: options.probe.framework,\n          sessionId: session.sessionId,\n        }),\n      ));\n    };\n\n    try {\n      socket = createConnection(options.endpoint);\n      socket.unref();\n    } catch {\n      clearTimeout(timer);\n      resolve(null);\n      return;\n    }\n\n    socket.on('error', abandon);\n    socket.on('close', abandon);\n    socket.on('connect', () => {\n      try {\n        socket.write(\n          encodeFrame(\n            {\n              type: 'hello',\n              protocol: options.protocol ?? PROTOCOL_ID,\n              token: options.token,\n              adapter: { name: options.adapterName, version: options.adapterVersion },\n              capabilities: options.capabilities,\n              probe: options.probe,\n            },\n            DEFAULT_LIMITS.maxFrameBytes,\n          ),\n        );\n      } catch {\n        abandon();\n      }\n    });\n\n    socket.on('data', (chunk: Buffer) => {\n      if (settled) return;\n      let messages: readonly unknown[];\n      try {\n        messages = decoder.push(chunk);\n      } catch {\n        abandon();\n        return;\n      }\n      if (messages.length === 0) return;\n\n      const parsed = parseDriverMessage(messages[0], DEFAULT_LIMITS);\n      if (!parsed.ok || parsed.message.type !== 'hello-ack') {\n        abandon();\n        return;\n      }\n      const ack = parsed.message;\n      if (ack.protocol !== (options.protocol ?? PROTOCOL_ID)) {\n        abandon();\n        return;\n      }\n      accept(\n        {\n          protocol: ack.protocol,\n          sessionId: ack.sessionId,\n          limits: narrowLimits(ack.limits),\n          markerEnabled: ack.marker.enabled,\n        },\n        messages.slice(1),\n      );\n    });\n  });\n}\n\n/** Adopt the driver's limits, never above our own: it may tighten, not widen. */\nfunction narrowLimits(offered: ProtocolLimits): ProtocolLimits {\n  const entries = Object.entries(DEFAULT_LIMITS).map(([key, fallback]) => {\n    const value = (offered as unknown as Record<string, unknown>)[key];\n    const usable = typeof value === 'number' && Number.isSafeInteger(value) && value > 0;\n    return [key, usable ? Math.min(value, fallback as number) : fallback];\n  });\n  return Object.freeze(Object.fromEntries(entries)) as ProtocolLimits;\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@termwright/probe-runtime",
+  "version": "0.2.0",
+  "description": "shared fail-closed transport for zero-config JavaScript probes",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Gorce-AI/termwright.git",
+    "directory": "packages/probe-runtime"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@termwright/protocol": "0.2.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --sourcemap --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}