@iowarp/clio-coder 0.4.0 → 0.4.2

package/dist/chunk-KPXDY6QF.js

@@ -0,0 +1,47 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  atomicWrite
+} from "./chunk-MQXIVJ35.js";
+import {
+  clioStateDir
+} from "./chunk-BYP5D4HI.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/dispatch/code-step-store.ts
+init_esm_shims();
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function codeStepDir(rootId) {
+  return join(clioStateDir(), "code-steps", rootId);
+}
+function codeStepRecordPath(rootId, runId) {
+  return join(codeStepDir(rootId), `${runId}.json`);
+}
+async function writeCodeStepRecord(rootId, record) {
+  const path = codeStepRecordPath(rootId, record.runId);
+  await atomicWrite(path, `${JSON.stringify(record, null, 2)}
+`);
+  return path;
+}
+function readCodeStepRecords(rootId) {
+  const dir = codeStepDir(rootId);
+  if (!existsSync(dir)) return [];
+  const records = [];
+  for (const file of readdirSync(dir).filter((name) => name.endsWith(".json")).sort()) {
+    try {
+      const parsed = JSON.parse(readFileSync(join(dir, file), "utf8"));
+      if (parsed.version === 1) records.push(parsed);
+    } catch {
+    }
+  }
+  return records.sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+}
+
+export {
+  codeStepDir,
+  writeCodeStepRecord,
+  readCodeStepRecords
+};
+//# sourceMappingURL=chunk-KPXDY6QF.js.map

package/dist/{chunk-LQ3DZAMX.js → chunk-LJID3DYZ.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-K6BSR66V.js";
 import {
   StringEnum
-} from "./chunk-UOSL25KY.js";
+} from "./chunk-VXMFAE2W.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -21,6 +21,12 @@ var codeNavToolSurface = {
   name: ToolNames.CodeNav,
   description: "Navigate the indexed codewiki: mode=symbol finds files by symbol, path finds files by glob/regex/substring, entries lists likely entry points, outline lists file symbols, deps lists imports, and dependents lists importers. mode=wiki without query lists generated Markdown wiki pages; with query it resolves a page id/title and returns its summary plus a path to open with read. For Clio's bundled product docs use context scope=docs.",
   parameters: typebox_exports.Object({
+    source: typebox_exports.Optional(
+      StringEnum(["workspace", "clio"], {
+        description: "Code map source (default workspace).",
+        default: "workspace"
+      })
+    ),
     mode: StringEnum(["symbol", "path", "entries", "outline", "deps", "dependents", "wiki"], {
       description: "Lookup mode."
     }),
@@ -43,4 +49,4 @@ export {
   CODE_NAV_MAX_LIMIT,
   codeNavToolSurface
 };
-//# sourceMappingURL=chunk-LQ3DZAMX.js.map
+//# sourceMappingURL=chunk-LJID3DYZ.js.map

package/dist/{chunk-7MCTRUCE.js → chunk-M2DAX4F6.js}

@@ -5,7 +5,7 @@ import {
   settingsPath,
   updateSavedSettingsDocument,
   validateSettings
-} from "./chunk-VFA6GDY5.js";
+} from "./chunk-34BHNEE3.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -226,4 +226,4 @@ export {
   updateLayeredSettings,
   settingsSourceFor
 };
-//# sourceMappingURL=chunk-7MCTRUCE.js.map
+//# sourceMappingURL=chunk-M2DAX4F6.js.map

package/dist/{chunk-VEO4AP2K.js → chunk-M2WXEHER.js}

@@ -14,7 +14,7 @@ import {
   toolResultPayload,
   toolResultText,
   withoutThinkingBlocks
-} from "./chunk-TZSKNMZG.js";
+} from "./chunk-GTUD2WMY.js";
 import {
   filterEntriesToActivePath
 } from "./chunk-W6GROXXM.js";
@@ -25,7 +25,7 @@ import {
   ceilChars,
   contentChars,
   estimateAgentMessageTokens
-} from "./chunk-UM7N4G5A.js";
+} from "./chunk-CWVRRIEI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -42,6 +42,7 @@ function estimateMessage(entry) {
   return estimateAgentMessageTokens({ ...entry, payload: promptPayload });
 }
 function estimateBashExecution(entry) {
+  if (entry.excludeFromContext === true) return 0;
   return ceilChars(entry.command.length + entry.output.length);
 }
 function estimateCustom(entry) {
@@ -674,4 +675,4 @@ export {
   compactionCut,
   selectVisibleEntries
 };
-//# sourceMappingURL=chunk-VEO4AP2K.js.map
+//# sourceMappingURL=chunk-M2WXEHER.js.map

package/dist/{chunk-YPI3QQCF.js → chunk-MCEPRMZW.js}

@@ -22,9 +22,7 @@ var webFetchToolSurface = {
     timeout_ms: typebox_exports.Optional(typebox_exports.Number({ description: "Timeout ms (default 30000)." })),
     max_bytes: typebox_exports.Optional(typebox_exports.Number({ description: "Max bytes returned (default 600000)." })),
     format: typebox_exports.Optional(
-      typebox_exports.String({
-        description: "auto (default: HTML is cleaned to Markdown, other content passes through) or raw (no conversion)."
-      })
+      typebox_exports.String({ description: "auto (default) converts HTML to Markdown; raw returns the body unconverted." })
     )
   }),
   baseActionClass: "read",
@@ -34,4 +32,4 @@ var webFetchToolSurface = {
 export {
   webFetchToolSurface
 };
-//# sourceMappingURL=chunk-YPI3QQCF.js.map
+//# sourceMappingURL=chunk-MCEPRMZW.js.map

package/dist/{chunk-YDFRH54B.js → chunk-MCMZMDAC.js}

@@ -1,19 +1,19 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   runVectorTool
-} from "./chunk-HWHKMHUA.js";
+} from "./chunk-7BHIY2MW.js";
 import {
   PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
   loadProjectVerifierCatalog,
   packageDeclaredCheck,
   resolveProjectVerifierExecutionCwd
-} from "./chunk-5LXZXPKX.js";
+} from "./chunk-VN3SHNBN.js";
 import {
   declaredVerificationScripts
 } from "./chunk-UL3WSD3F.js";
 import {
   resolveSafeCwd
-} from "./chunk-BBVJUZHB.js";
+} from "./chunk-HJWWJ6IL.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -239,4 +239,4 @@ export {
   runProjectCheck,
   runScriptCheck
 };
-//# sourceMappingURL=chunk-YDFRH54B.js.map
+//# sourceMappingURL=chunk-MCMZMDAC.js.map

package/dist/{chunk-J5Q24KAG.js → chunk-MNJGS2IN.js}

@@ -1,16 +1,15 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  GUARDRAIL_ENV_VARS,
   resolveGuardrail
-} from "./chunk-4ZG3XFUR.js";
+} from "./chunk-S66XZJOF.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
 // src/cli/internal-dispatch.ts
 init_esm_shims();
-function armInternalDispatchDeadline(dispatch, runId, label, env = process.env, maxTimeoutMs) {
-  const configuredTimeoutMs = resolveGuardrail("internalDispatchTimeoutMs", env);
+function armInternalDispatchDeadline(dispatch, runId, label, maxTimeoutMs) {
+  const configuredTimeoutMs = resolveGuardrail("internalDispatchTimeoutMs");
   const timeoutMs = maxTimeoutMs === void 0 ? configuredTimeoutMs : Math.min(configuredTimeoutMs, Math.max(1, maxTimeoutMs));
   const productCapped = timeoutMs < configuredTimeoutMs;
   let fired = false;
@@ -24,11 +23,11 @@ function armInternalDispatchDeadline(dispatch, runId, label, env = process.env,
   return {
     timedOut: () => fired,
     clear: () => clearTimeout(timer),
-    message: () => productCapped ? `${label} exceeded its ${Math.round(timeoutMs / 1e3)}s latency ceiling and was aborted.` : `${label} timed out after ${Math.round(timeoutMs / 1e3)}s and was aborted. Raise guardrails.internalDispatchTimeoutMs (env ${GUARDRAIL_ENV_VARS.internalDispatchTimeoutMs}) for slower targets.`
+    message: () => productCapped ? `${label} exceeded its ${Math.round(timeoutMs / 1e3)}s latency ceiling and was aborted.` : `${label} timed out after ${Math.round(timeoutMs / 1e3)}s and was aborted. Raise fleet.limits.internalRunTimeoutMs for slower targets.`
   };
 }
 
 export {
   armInternalDispatchDeadline
 };
-//# sourceMappingURL=chunk-J5Q24KAG.js.map
+//# sourceMappingURL=chunk-MNJGS2IN.js.map

package/dist/{chunk-76ONBSIA.js → chunk-MQXIVJ35.js}

@@ -2,6 +2,9 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   assertSafeId
 } from "./chunk-R346GLFC.js";
+import {
+  normalizeClioCoderEventTree
+} from "./chunk-BTK3SSSK.js";
 import {
   readClioVersion,
   readPiMonoVersion
@@ -62,7 +65,7 @@ function defaultSessionJsonlWarning(warning) {
   if (reportedSessionJsonlWarnings.has(key)) return;
   if (reportedSessionJsonlWarnings.size >= REPORTED_SESSION_JSONL_WARNING_LIMIT) reportedSessionJsonlWarnings.clear();
   reportedSessionJsonlWarnings.add(key);
-  process.stderr.write(`[clio:session] ${warning.path}:${warning.line}: ${warning.message}
+  process.stderr.write(`[clio-coder:session] ${warning.path}:${warning.line}: ${warning.message}
 `);
 }
 function serializeJsonl(entries) {
@@ -109,7 +112,7 @@ var SESSION_JSONL_READ_CHUNK_BYTES = 64 * 1024;
 function parseSessionJsonlLine(line, lineNumber, readPath, entries, warn) {
   if (line.trim().length === 0) return;
   try {
-    entries.push(JSON.parse(line));
+    entries.push(normalizeClioCoderEventTree(JSON.parse(line)));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     warn({ path: readPath, line: lineNumber, message: `invalid JSON skipped: ${message}` });
@@ -261,7 +264,7 @@ function buildMeta(input) {
     endedAt: null,
     model: input.model ?? null,
     target: input.target ?? null,
-    clioVersion: readClioVersion(),
+    clioCoderVersion: readClioVersion(),
     piMonoVersion: readPiMonoVersion(),
     platform: process.platform,
     nodeVersion: process.version,
@@ -270,7 +273,13 @@ function buildMeta(input) {
 }
 function readMetaFile(path) {
   const raw = readFileSync(path, "utf8");
-  return JSON.parse(raw);
+  const parsed = JSON.parse(raw);
+  const clioCoderVersion = parsed.clioCoderVersion ?? parsed.clioVersion;
+  if (typeof clioCoderVersion !== "string" || clioCoderVersion.length === 0) {
+    throw new Error(`session metadata has no Clio Coder version: ${path}`);
+  }
+  const { clioVersion: _legacyVersion, ...canonical } = parsed;
+  return { ...canonical, clioCoderVersion };
 }
 var TURN_KINDS = [
   "user",
@@ -567,4 +576,4 @@ export {
   openSession,
   resumeSession
 };
-//# sourceMappingURL=chunk-76ONBSIA.js.map
+//# sourceMappingURL=chunk-MQXIVJ35.js.map

package/dist/chunk-NDDGJUXD.js

@@ -0,0 +1,81 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/resources/skills/content-hash.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+var PROVENANCE_KEYS = /* @__PURE__ */ new Set([
+  "source-url",
+  "sourceUrl",
+  "install-url",
+  "installed-at",
+  "installedAt",
+  "updated-at",
+  "updatedAt",
+  "installed-hash",
+  "installedHash",
+  "audit",
+  "installed-by",
+  "installedBy"
+]);
+function frontmatterRegion(rawText) {
+  const opening = rawText.match(/^---\r?\n/);
+  if (!opening) return null;
+  const closeRegex = /\r?\n---(?:\r?\n|$)/g;
+  closeRegex.lastIndex = opening[0].length;
+  const closing = closeRegex.exec(rawText);
+  if (!closing) return null;
+  const frontmatterText = rawText.slice(opening[0].length, closing.index);
+  return {
+    head: opening[0],
+    lines: frontmatterText.split(/\r?\n/),
+    tail: rawText.slice(closing.index)
+  };
+}
+function stripProvenanceLines(lines) {
+  const kept = [];
+  let dropIndent = null;
+  let inProductBlock = false;
+  for (const line of lines) {
+    const indent = line.length - line.trimStart().length;
+    if (dropIndent !== null && line.trim().length > 0 && indent > dropIndent) continue;
+    dropIndent = null;
+    const keyMatch = line.match(/^([ \t]*)([A-Za-z][A-Za-z0-9-]*):/);
+    const key = keyMatch?.[2];
+    if (key !== void 0) {
+      if (indent === 0) inProductBlock = key === "clio-coder" || key === "clio";
+      if (PROVENANCE_KEYS.has(key) && (indent === 0 || inProductBlock)) {
+        dropIndent = indent;
+        continue;
+      }
+    }
+    kept.push(line);
+  }
+  return kept.filter((line, index) => {
+    if (!/^(?:clio-coder|clio):\s*$/.test(line)) return true;
+    for (let next = index + 1; next < kept.length; next += 1) {
+      const candidate = kept[next];
+      if (candidate.trim().length === 0) continue;
+      return /^[ \t]/.test(candidate);
+    }
+    return false;
+  });
+}
+function stripProvenanceFrontmatter(rawText) {
+  const region = frontmatterRegion(rawText);
+  if (!region) return rawText;
+  return `${region.head}${stripProvenanceLines(region.lines).join("\n")}${region.tail}`;
+}
+function normalizedSkillHash(rawText) {
+  return createHash("sha256").update(stripProvenanceFrontmatter(rawText), "utf8").digest("hex");
+}
+
+export {
+  frontmatterRegion,
+  stripProvenanceLines,
+  stripProvenanceFrontmatter,
+  normalizedSkillHash
+};
+//# sourceMappingURL=chunk-NDDGJUXD.js.map

package/dist/{chunk-TVHHYFHE.js → chunk-NEDJ26B5.js}

@@ -134,7 +134,7 @@ var CALL_TARGET_FIELDS = {
   grep: ["pattern", "path", "mode", "glob", "ignore_case", "literal", "context", "limit", "include_ignored"],
   find: ["pattern", "path", "order", "limit", "include_ignored"],
   ls: ["path", "limit"],
-  code_nav: ["mode", "query", "limit"],
+  code_nav: ["source", "mode", "query", "limit"],
   context: ["scope", "query", "name", "limit", "ref", "include_tree"],
   credential_present: ["name", "source", "file"],
   write: ["path"],
@@ -252,4 +252,4 @@ export {
   describeCallAction,
   describeCallTarget
 };
-//# sourceMappingURL=chunk-TVHHYFHE.js.map
+//# sourceMappingURL=chunk-NEDJ26B5.js.map

package/dist/chunk-NMJXSHBJ.js

@@ -0,0 +1,283 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  gitCommitAttributionEnabled,
+  reportCommitAttributionDiagnostic,
+  withManagedGitCommitAttributionEnvironment
+} from "./chunk-JIEGK6UF.js";
+import {
+  clampTimerDelayMs
+} from "./chunk-EBY63B7G.js";
+import {
+  AI_AGENT_NAME
+} from "./chunk-6EJMN2Y3.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/bash-exec.ts
+init_esm_shims();
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+var BASH_HARD_CAP_BYTES = 16 * 1024 * 1024;
+var CLIO_CONTROL_ENV_KEYS = ["CLIO_CODER_INTERACTIVE"];
+var BASH_UPDATE_THROTTLE_MS = 100;
+var SYSTEM_PROGRESS_SCHEDULER = {
+  now: Date.now,
+  setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+  clearTimeout: (timer) => clearTimeout(timer)
+};
+function createBashOutputProgressController(onUpdate, scheduler = SYSTEM_PROGRESS_SCHEDULER) {
+  let phase = "active";
+  let stdout = "";
+  let stderr = "";
+  const stdoutDecoder = new StringDecoder("utf8");
+  const stderrDecoder = new StringDecoder("utf8");
+  let decodersFinished = false;
+  let outputBytes = 0;
+  let outputCapped = false;
+  let updateTimer = null;
+  let updateDirty = false;
+  let lastUpdateAt = 0;
+  const snapshot = () => ({ stdout, stderr, outputBytes });
+  const finishDecoders = () => {
+    if (decodersFinished) return;
+    decodersFinished = true;
+    if (outputCapped) return;
+    stdout += stdoutDecoder.end();
+    stderr += stderrDecoder.end();
+  };
+  const emitUpdate = (final = false) => {
+    if (onUpdate === void 0 || !updateDirty) return;
+    if (phase !== "active" && !(final && phase === "settling")) return;
+    updateDirty = false;
+    lastUpdateAt = scheduler.now();
+    try {
+      onUpdate(snapshot());
+    } catch {
+    }
+  };
+  const clearUpdateTimer = () => {
+    if (updateTimer === null) return;
+    scheduler.clearTimeout(updateTimer);
+    updateTimer = null;
+  };
+  const scheduleUpdate = () => {
+    if (onUpdate === void 0 || phase !== "active") return;
+    updateDirty = true;
+    const delay = BASH_UPDATE_THROTTLE_MS - (scheduler.now() - lastUpdateAt);
+    if (delay <= 0) {
+      clearUpdateTimer();
+      emitUpdate();
+      return;
+    }
+    updateTimer ??= scheduler.setTimeout(() => {
+      updateTimer = null;
+      emitUpdate();
+    }, delay);
+  };
+  return {
+    start() {
+      if (phase !== "active" || onUpdate === void 0) return;
+      updateDirty = true;
+      emitUpdate();
+    },
+    append(target, chunk) {
+      if (phase !== "active" || outputCapped) return false;
+      const remaining = BASH_HARD_CAP_BYTES - outputBytes;
+      const accepted = chunk.byteLength <= remaining ? chunk : chunk.subarray(0, Math.max(0, remaining));
+      outputBytes += accepted.byteLength;
+      if (accepted.byteLength > 0) {
+        const decoded = target === "stdout" ? stdoutDecoder.write(accepted) : stderrDecoder.write(accepted);
+        if (target === "stdout") stdout += decoded;
+        else stderr += decoded;
+      }
+      if (accepted.byteLength < chunk.byteLength) outputCapped = true;
+      scheduleUpdate();
+      return outputCapped;
+    },
+    settle() {
+      if (phase === "settled") return { ...snapshot(), outputCapped };
+      if (phase === "settling") return { ...snapshot(), outputCapped };
+      phase = "settling";
+      clearUpdateTimer();
+      finishDecoders();
+      emitUpdate(true);
+      phase = "settled";
+      return { ...snapshot(), outputCapped };
+    }
+  };
+}
+function buildToolEnv() {
+  const env = { ...process.env };
+  env.AI_AGENT = AI_AGENT_NAME;
+  for (const key of CLIO_CONTROL_ENV_KEYS) {
+    Reflect.deleteProperty(env, key);
+  }
+  return env;
+}
+var LOGIN_ENV_CAPTURE_TIMEOUT_MS = 1e4;
+var loginEnvCapture = null;
+function parseNullDelimitedEnv(raw) {
+  const env = {};
+  for (const entry of raw.split("\0")) {
+    if (entry.length === 0) continue;
+    const eq = entry.indexOf("=");
+    if (eq <= 0) continue;
+    env[entry.slice(0, eq)] = entry.slice(eq + 1);
+  }
+  return typeof env.PATH === "string" && env.PATH.length > 0 ? env : null;
+}
+function captureLoginEnv() {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const child = spawn("/bin/bash", ["-lc", "env -0"], {
+      env: buildToolEnv(),
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish(null);
+    }, LOGIN_ENV_CAPTURE_TIMEOUT_MS);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.on("error", () => finish(null));
+    child.on("close", (code) => finish(code === 0 ? parseNullDelimitedEnv(stdout) : null));
+  });
+}
+async function bashSpawnPlan() {
+  loginEnvCapture ??= captureLoginEnv();
+  const captured = await loginEnvCapture;
+  if (captured === null) return { mode: "-lc", env: buildToolEnv() };
+  const env = { ...process.env, ...captured };
+  env.AI_AGENT = AI_AGENT_NAME;
+  for (const key of CLIO_CONTROL_ENV_KEYS) {
+    Reflect.deleteProperty(env, key);
+  }
+  return { mode: "-c", env };
+}
+function combineBashOutput(result) {
+  const { stdout, stderr } = result;
+  return stderr.length > 0 ? `${stdout}${stdout.endsWith("\n") || stdout.length === 0 ? "" : "\n"}${stderr}` : stdout;
+}
+async function runBashCommand(command, options = {}) {
+  const plan = await bashSpawnPlan();
+  const attribution = withManagedGitCommitAttributionEnvironment(plan.env, {
+    cwd: options.cwd ?? process.cwd(),
+    enabled: gitCommitAttributionEnabled(process.env)
+  });
+  reportCommitAttributionDiagnostic(attribution.diagnostic);
+  return new Promise((resolve) => {
+    const timeout = clampTimerDelayMs(options.timeoutMs ?? 3e5);
+    let aborted = false;
+    let timedOut = false;
+    let settled = false;
+    let timeoutId = null;
+    let killGraceTimer = null;
+    let killSent = false;
+    const output = createBashOutputProgressController(options.onUpdate);
+    const child = spawn("/bin/bash", [plan.mode, command], {
+      ...options.cwd === void 0 ? {} : { cwd: options.cwd },
+      env: attribution.env,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    output.start();
+    const clearKillGraceTimer = () => {
+      if (!killGraceTimer) return;
+      clearTimeout(killGraceTimer);
+      killGraceTimer = null;
+    };
+    const sendSignal = (signalName) => {
+      const pid = child.pid;
+      if (pid && process.platform !== "win32") {
+        try {
+          process.kill(-pid, signalName);
+          return;
+        } catch {
+        }
+      }
+      child.kill(signalName);
+    };
+    const killChild = () => {
+      if (killSent) return;
+      killSent = true;
+      sendSignal("SIGTERM");
+      killGraceTimer = setTimeout(() => {
+        sendSignal("SIGKILL");
+      }, 5e3);
+    };
+    function onAbort() {
+      aborted = true;
+      killChild();
+    }
+    if (timeout > 0) {
+      timeoutId = setTimeout(() => {
+        timedOut = true;
+        killChild();
+      }, timeout);
+    }
+    if (options.signal?.aborted) {
+      onAbort();
+    } else {
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+    }
+    const appendChunk = (target, chunk) => {
+      if (output.append(target, chunk)) killChild();
+    };
+    child.stdout?.on("data", (chunk) => appendChunk("stdout", chunk));
+    child.stderr?.on("data", (chunk) => appendChunk("stderr", chunk));
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      clearKillGraceTimer();
+      const finalOutput = output.settle();
+      options.signal?.removeEventListener("abort", onAbort);
+      resolve({
+        error,
+        ...finalOutput,
+        exitCode: null,
+        signal: null,
+        aborted,
+        timedOut
+      });
+    });
+    child.on("close", (code, signalName) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      clearKillGraceTimer();
+      const finalOutput = output.settle();
+      options.signal?.removeEventListener("abort", onAbort);
+      const error = code === 0 && signalName === null ? null : {
+        name: "Error",
+        message: signalName ? `command terminated by ${signalName}` : `command exited with code ${code ?? "?"}`,
+        code: code ?? void 0,
+        signal: signalName ?? void 0
+      };
+      resolve({
+        error,
+        ...finalOutput,
+        exitCode: code,
+        signal: signalName,
+        aborted,
+        timedOut
+      });
+    });
+  });
+}
+
+export {
+  BASH_HARD_CAP_BYTES,
+  combineBashOutput,
+  runBashCommand
+};
+//# sourceMappingURL=chunk-NMJXSHBJ.js.map