@iowarp/clio-coder 0.4.7 → 0.4.9

package/dist/chunk-XNZWWDC3.js

@@ -0,0 +1,686 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  buildSafeToolEnv
+} from "./chunk-XTQ7MEJG.js";
+import {
+  gitCommitAttributionEnabled,
+  reportCommitAttributionDiagnostic,
+  withManagedGitCommitAttributionEnvironment
+} from "./chunk-LTR5QCLS.js";
+import {
+  MAX_TIMER_DELAY_MS
+} from "./chunk-6EXUUOSN.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/engine/acp/transport.ts
+init_esm_shims();
+import { spawn } from "node:child_process";
+import { performance } from "node:perf_hooks";
+
+// src/engine/acp/errors.ts
+init_esm_shims();
+var AcpError = class extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.name = "AcpError";
+    this.code = code;
+    this.data = data;
+  }
+};
+var AcpProtocolError = class extends AcpError {
+  constructor(message, data) {
+    super("acp_protocol_error", message, data);
+    this.name = "AcpProtocolError";
+  }
+};
+var AcpTimeoutError = class extends AcpError {
+  constructor(message, data) {
+    super("acp_timeout", message, data);
+    this.name = "AcpTimeoutError";
+  }
+};
+var AcpProcessError = class extends AcpError {
+  constructor(message, data) {
+    super("acp_process_error", message, data);
+    this.name = "AcpProcessError";
+  }
+};
+var ACP_MAX_ERROR_MESSAGE_CHARS = 256;
+var ACP_TURN_FAILED_MESSAGE = "the prompt turn failed";
+var ACP_INTERNAL_ERROR_MESSAGE = "internal error";
+var ACP_METHOD_NOT_FOUND_MESSAGE = "method not found";
+var ACP_ERROR_META_KEY = "clio-coder/error";
+var ACP_ERROR_META_VERSION = 1;
+var AcpRequestError = class extends Error {
+  constructor(rpcCode, message, detail) {
+    super(message);
+    this.rpcCode = rpcCode;
+    this.detail = detail;
+    this.name = "AcpRequestError";
+  }
+  rpcCode;
+  detail;
+};
+function acpErrorData(detail) {
+  return {
+    _meta: {
+      [ACP_ERROR_META_KEY]: {
+        version: ACP_ERROR_META_VERSION,
+        code: detail.code,
+        ...detail.reason !== void 0 ? { reason: detail.reason } : {},
+        ...detail.supported !== void 0 ? { supported: [...detail.supported] } : {}
+      }
+    }
+  };
+}
+function acpErrorMessage(value) {
+  const raw = value instanceof Error ? value.message : String(value);
+  const collapsed = raw.replace(/\s+/g, " ").trim();
+  if (collapsed.length <= ACP_MAX_ERROR_MESSAGE_CHARS) return collapsed;
+  return `${collapsed.slice(0, ACP_MAX_ERROR_MESSAGE_CHARS - 1)}\u2026`;
+}
+
+// src/engine/acp/transport.ts
+var ACP_MAX_INPUT_LINE_BYTES = 1024 * 1024;
+function exceedsInputLineBytes(value) {
+  if (value.length <= ACP_MAX_INPUT_LINE_BYTES / 3) return false;
+  return Buffer.byteLength(value, "utf8") > ACP_MAX_INPUT_LINE_BYTES;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSuccess(value) {
+  return "id" in value && "result" in value;
+}
+function isFailure(value) {
+  return "id" in value && isRecord(value.error);
+}
+function errorMessage(value) {
+  return value instanceof Error ? value.message : String(value);
+}
+function errorCode(value) {
+  return isRecord(value) && typeof value.code === "string" ? value.code : void 0;
+}
+function boundedMilliseconds(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function validateRequestTimeout(method, timeoutMs) {
+  if (timeoutMs === void 0) return void 0;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_TIMER_DELAY_MS) {
+    throw new AcpTimeoutError(`ACP request timeout must be between 1 and ${MAX_TIMER_DELAY_MS} ms: ${method}`);
+  }
+  return timeoutMs;
+}
+function jsonRpcError(id, code, message, data) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: data === void 0 ? { code, message } : { code, message, data }
+  };
+}
+function handlerErrorFrame(id, err, diagnostics) {
+  if (err instanceof AcpRequestError) {
+    const message = err.detail.code === "internal_error" ? ACP_INTERNAL_ERROR_MESSAGE : acpErrorMessage(err.message);
+    return jsonRpcError(id, err.rpcCode, message, acpErrorData(err.detail));
+  }
+  diagnostics?.(`internal error: ${acpErrorMessage(err)}`);
+  return jsonRpcError(id, -32e3, ACP_INTERNAL_ERROR_MESSAGE, acpErrorData({ code: "internal_error" }));
+}
+var StdioJsonRpcTransport = class {
+  child;
+  terminationScope = process.platform === "win32" ? "child" : "process-group";
+  nextId = 1;
+  buffer = "";
+  isClosed = false;
+  inputEnded = false;
+  childHandlesClosed = false;
+  forceTermination = null;
+  terminationGraceMs;
+  terminationWaitMs;
+  childClosePromise;
+  resolveChildClose = null;
+  pending = /* @__PURE__ */ new Map();
+  notificationHandlers = /* @__PURE__ */ new Map();
+  requestHandlers = /* @__PURE__ */ new Map();
+  stderrHandlers = /* @__PURE__ */ new Set();
+  constructor(command, args, options = {}) {
+    this.terminationGraceMs = boundedMilliseconds(options.terminationGraceMs, 500);
+    this.terminationWaitMs = boundedMilliseconds(options.terminationWaitMs, 2e3);
+    this.childClosePromise = new Promise((resolve) => {
+      this.resolveChildClose = resolve;
+    });
+    const childEnvironment = buildSafeToolEnv(options.env);
+    const attribution = withManagedGitCommitAttributionEnvironment(childEnvironment, {
+      cwd: options.cwd ?? process.cwd(),
+      enabled: gitCommitAttributionEnabled(process.env),
+      evidence: { materiallyAssisted: true }
+    });
+    reportCommitAttributionDiagnostic(attribution.diagnostic);
+    this.child = spawn(command, args, {
+      cwd: options.cwd,
+      env: attribution.env,
+      stdio: ["pipe", "pipe", "pipe"],
+      // POSIX detached children lead a new session/process group whose id is
+      // the child pid. That makes negative-pid signaling safe for this owned
+      // group. Windows detached semantics do not provide an equivalent
+      // killable tree, so the explicit fallback there is the direct child.
+      detached: process.platform !== "win32"
+    });
+    this.child.stdout.setEncoding("utf8");
+    this.child.stderr.setEncoding("utf8");
+    this.child.stdout.on("data", (chunk) => this.consumeStdout(chunk));
+    this.child.stderr.on("data", (chunk) => {
+      for (const handler of this.stderrHandlers) handler(chunk);
+    });
+    this.child.on("error", (err) => {
+      this.closeChannel(new AcpProcessError(`ACP process error: ${errorMessage(err)}`));
+    });
+    this.child.on("exit", (code, signal) => {
+      this.isClosed = true;
+      if (this.pending.size === 0) return;
+      const reason = new AcpProcessError(
+        `ACP process exited before replying (code=${code ?? "null"}, signal=${signal ?? "null"})`
+      );
+      this.failAll(reason);
+    });
+    this.child.on("close", () => {
+      this.childHandlesClosed = true;
+      this.isClosed = true;
+      this.resolveChildClose?.();
+      this.resolveChildClose = null;
+    });
+    this.child.stdin.on("error", (err) => {
+      if (!this.isClosed) this.closeChannel(new AcpProcessError(`ACP stdin error: ${errorMessage(err)}`));
+    });
+  }
+  get closed() {
+    return this.isClosed || this.child.exitCode !== null || this.child.signalCode !== null;
+  }
+  get pid() {
+    return this.child.pid ?? null;
+  }
+  request(method, params, timeoutMs) {
+    if (this.closed) throw new AcpProcessError(`ACP process is closed; cannot request ${method}`);
+    const requestTimeoutMs = validateRequestTimeout(method, timeoutMs);
+    const id = this.nextId++;
+    const message = { jsonrpc: "2.0", id, method, params };
+    const promise = new Promise((resolve, reject) => {
+      const pending = {
+        method,
+        resolve: (value) => resolve(value),
+        reject
+      };
+      if (requestTimeoutMs !== void 0) {
+        pending.timer = setTimeout(() => {
+          this.pending.delete(id);
+          reject(new AcpTimeoutError(`ACP request timed out after ${requestTimeoutMs}ms: ${method}`));
+        }, requestTimeoutMs);
+      }
+      this.pending.set(id, pending);
+    });
+    this.write(message);
+    return promise;
+  }
+  notify(method, params) {
+    if (this.closed) return;
+    this.write({ jsonrpc: "2.0", method, params });
+  }
+  onNotification(method, handler) {
+    const handlers = this.notificationHandlers.get(method) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.notificationHandlers.set(method, handlers);
+    return () => {
+      handlers.delete(handler);
+    };
+  }
+  onRequest(method, handler) {
+    this.requestHandlers.set(method, handler);
+    return () => {
+      if (this.requestHandlers.get(method) === handler) this.requestHandlers.delete(method);
+    };
+  }
+  onStderr(handler) {
+    this.stderrHandlers.add(handler);
+    return () => {
+      this.stderrHandlers.delete(handler);
+    };
+  }
+  close() {
+    this.closeChannel(new AcpProcessError("ACP transport closed"));
+  }
+  terminate() {
+    this.closeChannel(new AcpProcessError("ACP transport terminated"));
+    this.signalOwnedScope("SIGTERM");
+  }
+  forceTerminate() {
+    if (this.forceTermination !== null) return this.forceTermination;
+    this.forceTermination = this.runForceTermination();
+    return this.forceTermination;
+  }
+  waitForExit(timeoutMs) {
+    return this.waitForTermination(boundedMilliseconds(timeoutMs, 0));
+  }
+  write(message) {
+    if (this.closed || !this.child.stdin.writable || this.child.stdin.destroyed) return;
+    try {
+      this.child.stdin.write(`${JSON.stringify(message)}
+`);
+    } catch (err) {
+      this.closeChannel(new AcpProcessError(`ACP stdin write failed: ${errorMessage(err)}`));
+    }
+  }
+  consumeStdout(chunk) {
+    this.buffer += chunk;
+    for (; ; ) {
+      const idx = this.buffer.indexOf("\n");
+      if (idx === -1) break;
+      const line = this.buffer.slice(0, idx).trimEnd();
+      this.buffer = this.buffer.slice(idx + 1);
+      if (line.length === 0) continue;
+      this.handleLine(line);
+    }
+  }
+  handleLine(line) {
+    const trimmed = line.trimStart();
+    if (!trimmed.startsWith("{")) {
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch (err) {
+      this.failAll(new AcpProtocolError(`ACP stdout contained invalid JSON: ${errorMessage(err)}`, { line }));
+      return;
+    }
+    if (!isRecord(parsed) || parsed.jsonrpc !== "2.0") {
+      return;
+    }
+    if (isSuccess(parsed) || isFailure(parsed)) {
+      this.handleResponse(parsed);
+      return;
+    }
+    const method = typeof parsed.method === "string" ? parsed.method : "";
+    if (!method) {
+      this.failAll(new AcpProtocolError("ACP request/notification missing method", parsed));
+      return;
+    }
+    if ("id" in parsed) {
+      void this.handleIncomingRequest(parsed.id, method, parsed.params);
+      return;
+    }
+    const handlers = this.notificationHandlers.get(method);
+    if (!handlers) return;
+    for (const handler of handlers) handler(parsed.params);
+  }
+  handleResponse(message) {
+    const pending = this.pending.get(message.id ?? "");
+    if (!pending) return;
+    this.pending.delete(message.id ?? "");
+    if (pending.timer) clearTimeout(pending.timer);
+    if ("error" in message) {
+      pending.reject(new AcpProtocolError(`ACP ${pending.method} failed: ${message.error.message}`, message.error));
+      return;
+    }
+    pending.resolve(message.result);
+  }
+  async handleIncomingRequest(id, method, params) {
+    const handler = this.requestHandlers.get(method);
+    if (!handler) {
+      this.write({
+        jsonrpc: "2.0",
+        id,
+        error: { code: -32601, message: `method not found: ${method}` }
+      });
+      return;
+    }
+    try {
+      const result = await handler(params);
+      this.write({ jsonrpc: "2.0", id, result });
+    } catch (err) {
+      this.write(handlerErrorFrame(id, err));
+    }
+  }
+  closeChannel(reason) {
+    if (!this.isClosed) {
+      this.isClosed = true;
+      this.failAll(reason);
+    }
+    if (this.inputEnded) return;
+    this.inputEnded = true;
+    try {
+      this.child.stdin.end();
+    } catch {
+    }
+  }
+  directChildAlive() {
+    return !this.childHandlesClosed && this.child.exitCode === null && this.child.signalCode === null;
+  }
+  processGroupAlive() {
+    if (this.terminationScope !== "process-group") return this.directChildAlive();
+    const pid = this.pid;
+    if (pid === null) return this.directChildAlive();
+    try {
+      process.kill(-pid, 0);
+      return true;
+    } catch (err) {
+      const code = errorCode(err);
+      if (code === "ESRCH") return false;
+      return true;
+    }
+  }
+  terminationObserved() {
+    return this.childHandlesClosed && !this.processGroupAlive();
+  }
+  signalOwnedScope(signal) {
+    const pid = this.pid;
+    if (this.terminationScope === "process-group" && pid !== null) {
+      try {
+        process.kill(-pid, signal);
+        return true;
+      } catch {
+      }
+    }
+    if (!this.directChildAlive()) return false;
+    try {
+      return this.child.kill(signal);
+    } catch {
+      return false;
+    }
+  }
+  async waitForTermination(timeoutMs) {
+    const deadline = performance.now() + timeoutMs;
+    while (!this.terminationObserved()) {
+      const remaining = deadline - performance.now();
+      if (remaining <= 0) return this.terminationObserved();
+      const interval = Math.min(10, remaining);
+      if (this.childHandlesClosed) {
+        await new Promise((resolve) => setTimeout(resolve, interval));
+      } else {
+        await Promise.race([this.childClosePromise, new Promise((resolve) => setTimeout(resolve, interval))]);
+      }
+    }
+    return true;
+  }
+  async runForceTermination() {
+    this.closeChannel(new AcpProcessError("ACP transport force-terminated"));
+    if (this.terminationObserved()) {
+      return { exited: true, escalated: false, scope: this.terminationScope };
+    }
+    this.signalOwnedScope("SIGTERM");
+    if (await this.waitForExit(this.terminationGraceMs)) {
+      return { exited: true, escalated: false, scope: this.terminationScope };
+    }
+    const escalated = this.signalOwnedScope("SIGKILL");
+    const exited = await this.waitForExit(this.terminationWaitMs);
+    return { exited, escalated, scope: this.terminationScope };
+  }
+  failAll(reason) {
+    for (const [id, pending] of this.pending.entries()) {
+      if (pending.timer) clearTimeout(pending.timer);
+      pending.reject(reason);
+      this.pending.delete(id);
+    }
+  }
+};
+function createStdioTransport(command, args = [], options = {}) {
+  if (command.trim().length === 0) {
+    throw new AcpProcessError("ACP stdio command must not be empty");
+  }
+  return new StdioJsonRpcTransport(command, args, options);
+}
+var StreamJsonRpcPeerTransport = class {
+  outputPaused = false;
+  queuedOutputBytes = 0;
+  sinkOutputBytes = 0;
+  outputQueue = [];
+  nextId = 1;
+  buffer = "";
+  /** True while the bytes of an oversized line are being dropped up to its terminating newline. */
+  discardingLine = false;
+  isClosed = false;
+  pending = /* @__PURE__ */ new Map();
+  notificationHandlers = /* @__PURE__ */ new Map();
+  requestHandlers = /* @__PURE__ */ new Map();
+  closeHandlers = /* @__PURE__ */ new Set();
+  input;
+  output;
+  writeOverride;
+  diagnostics;
+  constructor(options = {}) {
+    this.input = options.input ?? process.stdin;
+    this.output = options.output ?? process.stdout;
+    if (options.write !== void 0) this.writeOverride = options.write;
+    if (options.diagnostics !== void 0) this.diagnostics = options.diagnostics;
+    this.input.setEncoding("utf8");
+    this.input.on("data", (chunk) => this.consume(chunk));
+    this.input.on("end", () => this.markClosed(new AcpProcessError("ACP input closed")));
+    this.input.on("error", (err) => this.markClosed(new AcpProcessError(`ACP input error: ${errorMessage(err)}`)));
+    this.output.on?.("error", (err) => this.markClosed(new AcpProcessError(`ACP output error: ${errorMessage(err)}`)));
+  }
+  get closed() {
+    return this.isClosed;
+  }
+  request(method, params, timeoutMs) {
+    if (this.closed) throw new AcpProcessError(`ACP transport is closed; cannot request ${method}`);
+    const requestTimeoutMs = validateRequestTimeout(method, timeoutMs);
+    const id = this.nextId++;
+    const message = { jsonrpc: "2.0", id, method, params };
+    const promise = new Promise((resolve, reject) => {
+      const pending = {
+        method,
+        resolve: (value) => resolve(value),
+        reject
+      };
+      if (requestTimeoutMs !== void 0) {
+        pending.timer = setTimeout(() => {
+          this.pending.delete(id);
+          reject(new AcpTimeoutError(`ACP request timed out after ${requestTimeoutMs}ms: ${method}`));
+        }, requestTimeoutMs);
+      }
+      this.pending.set(id, pending);
+    });
+    this.write(message);
+    return promise;
+  }
+  notify(method, params) {
+    if (this.closed) return;
+    this.write({ jsonrpc: "2.0", method, params });
+  }
+  onNotification(method, handler) {
+    const handlers = this.notificationHandlers.get(method) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.notificationHandlers.set(method, handlers);
+    return () => {
+      handlers.delete(handler);
+    };
+  }
+  onRequest(method, handler) {
+    this.requestHandlers.set(method, handler);
+    return () => {
+      if (this.requestHandlers.get(method) === handler) this.requestHandlers.delete(method);
+    };
+  }
+  onClose(handler) {
+    this.closeHandlers.add(handler);
+    return () => {
+      this.closeHandlers.delete(handler);
+    };
+  }
+  close() {
+    this.markClosed(new AcpProcessError("ACP transport closed"));
+  }
+  write(message) {
+    if (this.closed) return;
+    const line = `${JSON.stringify(message)}
+`;
+    if (this.outputPaused) {
+      const bytes = Buffer.byteLength(line, "utf8");
+      if (this.queuedOutputBytes + this.sinkOutputBytes + bytes > ACP_MAX_INPUT_LINE_BYTES) {
+        this.markClosed(new AcpProcessError("ACP output buffer exceeded byte limit"));
+        return;
+      }
+    }
+    this.outputQueue.push(line);
+    this.queuedOutputBytes += Buffer.byteLength(line, "utf8");
+    if (!this.outputPaused) this.flushOutput();
+  }
+  flushOutput = () => {
+    this.outputPaused = false;
+    while (!this.closed && !this.outputPaused && this.outputQueue.length > 0) {
+      const line = this.outputQueue.shift();
+      if (line === void 0) break;
+      this.queuedOutputBytes -= Buffer.byteLength(line, "utf8");
+      try {
+        this.sinkOutputBytes = Math.min(this.sinkOutputBytes, this.output.writableLength * 3);
+        let ready;
+        if (this.writeOverride) {
+          this.writeOverride(line);
+          ready = !this.output.writableNeedDrain;
+        } else {
+          ready = this.output.write(line);
+        }
+        this.sinkOutputBytes = this.output.writableLength === 0 ? 0 : this.sinkOutputBytes + Buffer.byteLength(line, "utf8");
+        if (!ready && !this.closed) {
+          if (this.queuedOutputBytes + this.sinkOutputBytes > ACP_MAX_INPUT_LINE_BYTES) {
+            this.markClosed(new AcpProcessError("ACP output buffer exceeded byte limit"));
+            return;
+          }
+          this.outputPaused = true;
+          this.output.once("drain", this.flushOutput);
+        }
+      } catch (err) {
+        this.markClosed(new AcpProcessError(`ACP output write failed: ${errorMessage(err)}`));
+      }
+    }
+  };
+  consume(chunk) {
+    this.buffer += chunk;
+    for (; ; ) {
+      const idx = this.buffer.indexOf("\n");
+      if (idx === -1) break;
+      const line = this.buffer.slice(0, idx).trimEnd();
+      this.buffer = this.buffer.slice(idx + 1);
+      if (this.discardingLine) {
+        this.discardingLine = false;
+        continue;
+      }
+      if (line.length === 0) continue;
+      if (exceedsInputLineBytes(line)) {
+        this.reportOversizedLine();
+        continue;
+      }
+      this.handleLine(line);
+    }
+    if (this.discardingLine) {
+      this.buffer = "";
+      return;
+    }
+    if (exceedsInputLineBytes(this.buffer)) {
+      this.buffer = "";
+      this.discardingLine = true;
+      this.reportOversizedLine();
+    }
+  }
+  /** One error frame per oversized line. The transport stays open and parseable. */
+  reportOversizedLine() {
+    this.write(
+      jsonRpcError(null, -32600, "input line exceeds the maximum size", acpErrorData({ code: "input_line_too_large" }))
+    );
+  }
+  handleLine(line) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      this.write(jsonRpcError(null, -32700, "parse error", acpErrorData({ code: "parse_error" })));
+      return;
+    }
+    if (!isRecord(parsed) || parsed.jsonrpc !== "2.0") {
+      this.write(jsonRpcError(null, -32600, "invalid JSON-RPC message", acpErrorData({ code: "invalid_request" })));
+      return;
+    }
+    if (isSuccess(parsed) || isFailure(parsed)) {
+      this.handleResponse(parsed);
+      return;
+    }
+    const method = typeof parsed.method === "string" ? parsed.method : "";
+    const id = "id" in parsed ? parsed.id : void 0;
+    if (!method) {
+      if (id !== void 0) {
+        this.write(
+          jsonRpcError(id, -32600, "request/notification missing method", acpErrorData({ code: "invalid_request" }))
+        );
+      }
+      return;
+    }
+    if (id !== void 0) {
+      void this.handleRequest(id, method, parsed.params);
+      return;
+    }
+    const handlers = this.notificationHandlers.get(method);
+    if (!handlers) return;
+    for (const handler of handlers) handler(parsed.params);
+  }
+  handleResponse(message) {
+    const pending = this.pending.get(message.id ?? "");
+    if (!pending) return;
+    this.pending.delete(message.id ?? "");
+    if (pending.timer) clearTimeout(pending.timer);
+    if ("error" in message) {
+      pending.reject(new AcpProtocolError(`ACP ${pending.method} failed: ${message.error.message}`, message.error));
+      return;
+    }
+    pending.resolve(message.result);
+  }
+  async handleRequest(id, method, params) {
+    if (id === null) {
+      this.write(jsonRpcError(null, -32600, "request id must not be null", acpErrorData({ code: "invalid_request_id" })));
+      return;
+    }
+    const handler = this.requestHandlers.get(method);
+    if (!handler) {
+      this.write(jsonRpcError(id, -32601, ACP_METHOD_NOT_FOUND_MESSAGE, acpErrorData({ code: "method_not_found" })));
+      return;
+    }
+    try {
+      const result = await handler(params);
+      this.write({ jsonrpc: "2.0", id, result });
+    } catch (err) {
+      this.write(handlerErrorFrame(id, err, this.diagnostics));
+    }
+  }
+  markClosed(reason) {
+    if (this.isClosed) return;
+    this.isClosed = true;
+    this.output.removeListener("drain", this.flushOutput);
+    this.outputQueue.length = 0;
+    this.queuedOutputBytes = 0;
+    this.failAll(reason);
+    for (const handler of this.closeHandlers) handler();
+  }
+  failAll(reason) {
+    for (const [id, pending] of this.pending.entries()) {
+      if (pending.timer) clearTimeout(pending.timer);
+      pending.reject(reason);
+      this.pending.delete(id);
+    }
+  }
+};
+function createStdioServerTransport(options = {}) {
+  return new StreamJsonRpcPeerTransport(options);
+}
+
+export {
+  AcpProtocolError,
+  AcpTimeoutError,
+  ACP_TURN_FAILED_MESSAGE,
+  AcpRequestError,
+  acpErrorMessage,
+  createStdioTransport,
+  createStdioServerTransport
+};
+//# sourceMappingURL=chunk-XNZWWDC3.js.map

package/dist/{chunk-WBVKKTUT.js → chunk-XRECG65F.js}

@@ -4,7 +4,7 @@ import {
   settingsPath,
   validateSettings,
   withSettingsLock
-} from "./chunk-4QKAITQT.js";
+} from "./chunk-FPS4R2RN.js";
 import {
   require_dist
 } from "./chunk-B5GGDIHT.js";
@@ -305,4 +305,4 @@ export {
   migrateSettingsV1Document,
   settings_v2_default
 };
-//# sourceMappingURL=chunk-WBVKKTUT.js.map
+//# sourceMappingURL=chunk-XRECG65F.js.map