stitchkit 0.69.0 → 0.70.0

package/dist/agent-runtime-coding-tools.js

@@ -1,16 +1,26 @@
 import {
-  readContainedUtf8File,
+  assertContainedFileCurrent,
+  assertContainedParentCurrent,
+  openContainedFile,
+  openContainedParent,
+  readContainedUtf8Handle,
   scanContainedFiles
-} from "./index-v3dpzpjw.js";
+} from "./index-xbtcszs7.js";
 import {
   defineRuntimeTool
 } from "./index-wwst0td5.js";
 import"./index-22by16v6.js";
 import"./index-cby4ar3v.js";
+import"./index-vj3vvpaa.js";
+import {
+  conflict,
+  forbidden
+} from "./index-0w9abg87.js";
 import"./index-qyrqwr4c.js";
+import"./index-6k1937bx.js";
 
 // src/agent-runtime/coding-tools.ts
-import path3 from "node:path";
+import path4 from "node:path";
 import { z as z3 } from "zod";
 
 // src/agent-runtime/coding-tool-contract.ts
@@ -26,7 +36,8 @@ var AgentCodingToolLimitsSchema = z.object({
   maxSearchResults: z.int().positive(),
   maxSearchFiles: z.int().positive(),
   maxSearchDepth: z.int().nonnegative(),
-  shellTimeoutMs: z.int().positive()
+  shellTimeoutMs: z.int().positive(),
+  shellTerminationGraceMs: z.int().positive()
 }).strict();
 var AgentCodingToolAuthorizationSchema = z.discriminatedUnion("operation", [
   z.object({ operation: z.literal("read"), path: z.string().min(1) }).strict(),
@@ -121,7 +132,8 @@ var DEFAULT_LIMITS = {
   maxSearchResults: 100,
   maxSearchFiles: 1e4,
   maxSearchDepth: 32,
-  shellTimeoutMs: 30000
+  shellTimeoutMs: 30000,
+  shellTerminationGraceMs: 250
 };
 function resolveCodingToolLimits(input) {
   return AgentCodingToolLimitsSchema.parse({ ...DEFAULT_LIMITS, ...input });
@@ -129,8 +141,8 @@ function resolveCodingToolLimits(input) {
 
 // src/agent-runtime/coding-tool-files.ts
 import { createHash } from "node:crypto";
-import { constants } from "node:fs";
-import { open, realpath as realpath2, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { lstat as lstat2, realpath as realpath2, writeFile as writeFile2 } from "node:fs/promises";
+import path2 from "node:path";
 
 // src/agent-runtime/coding-tool-paths.ts
 import { lstat, realpath, rename, unlink, writeFile } from "node:fs/promises";
@@ -150,41 +162,20 @@ function inputPath(root, requested, maxPathBytes) {
     throw new Error("Coding tool path escapes its root");
   return resolved;
 }
+function boundedCodingRelativePath(requested, maxPathBytes) {
+  inputPath(path.parse(process.cwd()).root, requested, maxPathBytes);
+  return requested;
+}
 async function existingCodingPath(root, requested, maxPathBytes) {
   const resolved = await realpath(inputPath(root, requested, maxPathBytes));
   if (!within(root, resolved))
     throw new Error("Coding tool path resolves outside its root");
   return { absolute: resolved, relative: path.relative(root, resolved) || "." };
 }
-async function writableCodingPath(root, requested, maxPathBytes) {
-  const candidate = inputPath(root, requested, maxPathBytes);
-  const parent = await realpath(path.dirname(candidate));
-  if (!within(root, parent))
-    throw new Error("Coding tool parent resolves outside its root");
-  const target = path.join(parent, path.basename(candidate));
-  const metadata = await lstat(target).catch((error) => {
-    if (error.code === "ENOENT")
-      return null;
-    throw error;
-  });
-  if (metadata?.isSymbolicLink())
-    throw new Error("Coding tools do not write through symlinks");
-  return { absolute: target, relative: path.relative(root, target) || "." };
-}
-async function editableCodingPath(root, requested, maxPathBytes) {
-  const candidate = inputPath(root, requested, maxPathBytes);
-  const metadata = await lstat(candidate);
-  if (metadata.isSymbolicLink())
-    throw new Error("Coding tools do not edit symlinks");
-  const resolved = await realpath(candidate);
-  if (!within(root, resolved))
-    throw new Error("Coding tool path resolves outside its root");
-  return { absolute: resolved, relative: path.relative(root, resolved) || "." };
-}
 async function authorizeCodingTool(config, request) {
   const parsed = AgentCodingToolAuthorizationSchema.parse(request);
   if (!await config.authorize(parsed))
-    throw new Error("Coding tool permission denied");
+    forbidden("Coding tool permission denied");
 }
 async function atomicCodingReplace(target, content, mode) {
   const temporary = path.join(path.dirname(target), `.${path.basename(target)}.${process.pid}.${crypto.randomUUID()}.tmp`);
@@ -255,14 +246,15 @@ function createFileCodingTools(config, limits) {
     transports: ["AGENT"],
     handler: async ({ input }) => {
       const root = await realpath2(config.root);
-      const target = await existingCodingPath(root, input.path, limits.maxPathBytes);
-      await authorizeCodingTool(config, { operation: "read", path: target.relative });
+      const relative = boundedCodingRelativePath(input.path, limits.maxPathBytes);
+      const handle = await openContainedFile(root, relative);
       const maximum = Math.min(input.maxBytes ?? limits.maxReadBytes, limits.maxReadBytes);
-      const handle = await open(target.absolute, constants.O_RDONLY | constants.O_NOFOLLOW);
       let selected;
       let size;
       let sha256;
       try {
+        await authorizeCodingTool(config, { operation: "read", path: relative });
+        await assertContainedFileCurrent(root, relative, handle);
         const metadata = await handle.stat();
         if (!metadata.isFile())
           throw new Error("Coding read path is not a regular file");
@@ -279,7 +271,7 @@ function createFileCodingTools(config, limits) {
       const end = input.offset + selected.byteLength;
       const truncated = end < size;
       return {
-        path: target.relative,
+        path: relative,
         text,
         bytes: selected.byteLength,
         sha256,
@@ -297,23 +289,32 @@ function createFileCodingTools(config, limits) {
     transports: ["AGENT"],
     handler: async ({ input }) => {
       const root = await realpath2(config.root);
-      const target = await writableCodingPath(root, input.path, limits.maxPathBytes);
+      const relative = boundedCodingRelativePath(input.path, limits.maxPathBytes);
       const bytes = Buffer.byteLength(input.content);
       if (bytes > limits.maxWriteBytes)
         throw new Error("Coding tool write exceeds maxWriteBytes");
-      await authorizeCodingTool(config, {
-        operation: "write",
-        path: target.relative,
-        bytes,
-        overwrite: input.overwrite
-      });
-      if (input.overwrite) {
-        const current = await stat(target.absolute).catch(() => null);
-        await atomicCodingReplace(target.absolute, input.content, current?.mode);
-      } else {
-        await writeFile2(target.absolute, input.content, { flag: "wx" });
+      const parent = await openContainedParent(root, relative);
+      const target = path2.join(parent.path, parent.basename);
+      try {
+        await authorizeCodingTool(config, {
+          operation: "write",
+          path: relative,
+          bytes,
+          overwrite: input.overwrite
+        });
+        await assertContainedParentCurrent(root, relative, parent.handle);
+        if (input.overwrite) {
+          const current = await lstat2(target).catch(() => null);
+          if (current?.isSymbolicLink())
+            throw new Error("Coding tools do not overwrite symlinks");
+          await atomicCodingReplace(target, input.content, current?.mode);
+        } else {
+          await writeFile2(target, input.content, { flag: "wx" });
+        }
+      } finally {
+        await parent.handle.close();
       }
-      return { path: target.relative, bytes };
+      return { path: relative, bytes };
     }
   });
   return [read, write];
@@ -321,8 +322,9 @@ function createFileCodingTools(config, limits) {
 
 // src/agent-runtime/coding-tool-search-patch.ts
 import { createHash as createHash2 } from "node:crypto";
-import { realpath as realpath3 } from "node:fs/promises";
-import path2 from "node:path";
+import { constants } from "node:fs";
+import { open, realpath as realpath3 } from "node:fs/promises";
+import path3 from "node:path";
 import { z as z2 } from "zod";
 var DEFAULT_EXCLUDED_DIRECTORIES = [
   ".git",
@@ -381,7 +383,11 @@ function createSearchAndPatchCodingTools(config, limits) {
         maxDepth: limits.maxSearchDepth,
         maxFiles: limits.maxSearchFiles,
         symlinks: "skip",
-        excludeDirectory: (relative) => relative.split(path2.sep).some((segment) => excluded.has(segment))
+        ...input.mode === "content" && {
+          readMaxBytes: limits.maxReadBytes,
+          skipUnreadable: true
+        },
+        excludeDirectory: (relative) => relative.split(path3.sep).some((segment) => excluded.has(segment))
       });
       const matches = [];
       let truncated = false;
@@ -390,12 +396,9 @@ function createSearchAndPatchCodingTools(config, limits) {
           if (file.relative.includes(input.query))
             matches.push({ path: file.relative });
         } else {
-          let text;
-          try {
-            text = (await readContainedUtf8File(file.absolute, limits.maxReadBytes)).text;
-          } catch {
+          const text = file.content?.text;
+          if (text === undefined)
             continue;
-          }
           const lines = text.split(`
 `);
           for (let index = 0;index < lines.length; index += 1) {
@@ -429,48 +432,57 @@ function createSearchAndPatchCodingTools(config, limits) {
     transports: ["AGENT"],
     handler: async ({ input }) => {
       const root = await realpath3(config.root);
-      const target = await editableCodingPath(root, input.path, limits.maxPathBytes);
-      const read = await readContainedUtf8File(target.absolute, limits.maxWriteBytes);
-      const source = read.text;
-      const baseSha256 = sha256(source);
-      if (baseSha256 !== input.baseSha256)
-        throw new Error("Coding patch base digest is stale");
-      const count = textOccurrences(source, input.oldText);
-      if (count === 0)
-        throw new Error("Coding patch text was not found");
-      if (!input.replaceAll && count !== 1)
-        throw new Error("Coding patch text is not unique");
-      const replacements = input.replaceAll ? count : 1;
-      const changed = input.replaceAll ? source.replaceAll(input.oldText, input.newText) : source.replace(input.oldText, input.newText);
-      const bytes = Buffer.byteLength(changed);
-      const resultSha256 = sha256(changed);
-      if (bytes > limits.maxWriteBytes)
-        throw new Error("Coding patch exceeds maxWriteBytes");
-      await authorizeCodingTool(config, {
-        operation: "patch",
-        path: target.relative,
-        baseSha256,
-        resultSha256,
-        resultBytes: bytes,
-        replacements,
-        dryRun: input.dryRun
-      });
-      if (!input.dryRun) {
-        await withCodingPathLock(target.absolute, async () => {
-          const current = await readContainedUtf8File(target.absolute, limits.maxWriteBytes);
-          if (sha256(current.text) !== baseSha256)
-            throw new Error("Coding patch base digest became stale before apply");
-          await atomicCodingReplace(target.absolute, changed, current.mode);
+      const relative = boundedCodingRelativePath(input.path, limits.maxPathBytes);
+      const parent = await openContainedParent(root, relative);
+      try {
+        const target = path3.join(parent.path, parent.basename);
+        const initial = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW);
+        const read = await readContainedUtf8Handle(initial, limits.maxWriteBytes).finally(() => initial.close());
+        const source = read.text;
+        const baseSha256 = sha256(source);
+        if (baseSha256 !== input.baseSha256)
+          conflict("Coding patch base digest is stale");
+        const count = textOccurrences(source, input.oldText);
+        if (count === 0)
+          throw new Error("Coding patch text was not found");
+        if (!input.replaceAll && count !== 1)
+          throw new Error("Coding patch text is not unique");
+        const replacements = input.replaceAll ? count : 1;
+        const changed = input.replaceAll ? source.replaceAll(input.oldText, input.newText) : source.replace(input.oldText, input.newText);
+        const bytes = Buffer.byteLength(changed);
+        const resultSha256 = sha256(changed);
+        if (bytes > limits.maxWriteBytes)
+          throw new Error("Coding patch exceeds maxWriteBytes");
+        await authorizeCodingTool(config, {
+          operation: "patch",
+          path: relative,
+          baseSha256,
+          resultSha256,
+          resultBytes: bytes,
+          replacements,
+          dryRun: input.dryRun
         });
+        await assertContainedParentCurrent(root, relative, parent.handle);
+        if (!input.dryRun) {
+          await withCodingPathLock(`${root}:${relative}`, async () => {
+            const currentHandle = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW);
+            const current = await readContainedUtf8Handle(currentHandle, limits.maxWriteBytes).finally(() => currentHandle.close());
+            if (sha256(current.text) !== baseSha256)
+              conflict("Coding patch base digest became stale before apply");
+            await atomicCodingReplace(target, changed, current.mode);
+          });
+        }
+        return {
+          path: relative,
+          baseSha256,
+          resultSha256,
+          replacements,
+          bytes,
+          applied: !input.dryRun
+        };
+      } finally {
+        await parent.handle.close();
       }
-      return {
-        path: target.relative,
-        baseSha256,
-        resultSha256,
-        replacements,
-        bytes,
-        applied: !input.dryRun
-      };
     }
   });
   return [search, patch];
@@ -478,7 +490,7 @@ function createSearchAndPatchCodingTools(config, limits) {
 
 // src/agent-runtime/coding-tool-shell.ts
 import { spawn } from "node:child_process";
-import { realpath as realpath4, stat as stat2 } from "node:fs/promises";
+import { realpath as realpath4, stat } from "node:fs/promises";
 async function runShell(input) {
   const stdoutHeader = Buffer.from(`--- stdout ---
 `);
@@ -488,11 +500,23 @@ async function runShell(input) {
   const artifactPayloadLimit = input.maxArtifactBytes - stdoutHeader.byteLength - stderrHeader.byteLength;
   if (input.artifacts && artifactPayloadLimit < 0)
     throw new Error("maxArtifactBytes is smaller than the shell artifact envelope");
+  if (input.signal?.aborted) {
+    return ShellOutputSchema.parse({
+      executable: input.executableName,
+      exitCode: null,
+      signal: null,
+      stdout: "",
+      stderr: "",
+      outcome: "cancelled"
+    });
+  }
   return await new Promise((resolve, reject) => {
+    const ownsProcessGroup = process.platform !== "win32";
     const child = spawn(input.executable, input.args, {
       cwd: input.cwd,
       env: input.environment,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: ownsProcessGroup
     });
     const stdout = [];
     const stderr = [];
@@ -502,15 +526,74 @@ async function runShell(input) {
     let artifactBytes = 0;
     let outcome = "exited";
     let settled = false;
+    let settlementTimer;
+    const cancel = () => terminate("cancelled");
+    const cleanup = () => {
+      clearTimeout(timer);
+      if (settlementTimer)
+        clearTimeout(settlementTimer);
+      input.signal?.removeEventListener("abort", cancel);
+    };
+    const persistAndResolve = async (exitCode, signal) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      try {
+        const hasArtifact = input.artifacts && artifactBytes > input.maxOutputBytes;
+        const artifactData = hasArtifact ? Buffer.concat([stdoutHeader, ...artifactStdout, stderrHeader, ...artifactStderr]) : undefined;
+        const persisted = hasArtifact ? await input.artifacts?.write({
+          mediaType: "text/plain; charset=utf-8",
+          data: artifactData ?? new Uint8Array
+        }) : undefined;
+        resolve(ShellOutputSchema.parse({
+          executable: input.executableName,
+          exitCode,
+          signal,
+          stdout: Buffer.concat(stdout).toString("utf8"),
+          stderr: Buffer.concat(stderr).toString("utf8"),
+          outcome,
+          ...persisted && {
+            artifact: {
+              reference: persisted.reference,
+              bytes: artifactData?.byteLength ?? 0,
+              truncated: outcome === "output-limit"
+            }
+          }
+        }));
+      } catch (error) {
+        reject(error);
+      }
+    };
+    const killOwnedProcessGroup = () => {
+      if (!ownsProcessGroup || child.pid === undefined)
+        return false;
+      try {
+        process.kill(-child.pid, "SIGKILL");
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    const boundStreamSettlement = () => {
+      if (settlementTimer)
+        return;
+      settlementTimer = setTimeout(() => {
+        child.stdout.destroy();
+        child.stderr.destroy();
+        persistAndResolve(child.exitCode, child.signalCode);
+      }, input.terminationGraceMs);
+    };
     const terminate = (reason) => {
       if (settled || outcome !== "exited")
         return;
       outcome = reason;
-      child.kill("SIGKILL");
+      if (!killOwnedProcessGroup())
+        child.kill("SIGKILL");
+      boundStreamSettlement();
     };
     const timer = setTimeout(() => terminate("timeout"), input.timeoutMs);
     timer.unref();
-    const cancel = () => terminate("cancelled");
     const retain = (target, artifactTarget, chunk) => {
       const remaining = Math.max(0, input.maxOutputBytes - retained);
       if (remaining > 0) {
@@ -536,42 +619,18 @@ async function runShell(input) {
       if (settled)
         return;
       settled = true;
-      clearTimeout(timer);
-      input.signal?.removeEventListener("abort", cancel);
+      cleanup();
       reject(error);
     });
-    child.on("close", async (exitCode, signal) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      input.signal?.removeEventListener("abort", cancel);
-      try {
-        const hasArtifact = input.artifacts && artifactBytes > input.maxOutputBytes;
-        const artifactData = hasArtifact ? Buffer.concat([stdoutHeader, ...artifactStdout, stderrHeader, ...artifactStderr]) : undefined;
-        const persisted = hasArtifact ? await input.artifacts?.write({
-          mediaType: "text/plain; charset=utf-8",
-          data: artifactData ?? new Uint8Array
-        }) : undefined;
-        resolve(ShellOutputSchema.parse({
-          executable: input.executableName,
-          exitCode,
-          signal,
-          stdout: Buffer.concat(stdout).toString("utf8"),
-          stderr: Buffer.concat(stderr).toString("utf8"),
-          outcome,
-          ...persisted && {
-            artifact: {
-              reference: persisted.reference,
-              bytes: artifactData?.byteLength ?? 0,
-              truncated: outcome === "output-limit"
-            }
-          }
-        }));
-      } catch (error) {
-        reject(error);
+    child.on("exit", (exitCode, signal) => {
+      if (outcome === "exited")
+        killOwnedProcessGroup();
+      boundStreamSettlement();
+      if (child.stdout.destroyed && child.stderr.destroyed) {
+        persistAndResolve(exitCode, signal);
       }
     });
+    child.on("close", (exitCode, signal) => void persistAndResolve(exitCode, signal));
     input.signal?.addEventListener("abort", cancel, { once: true });
     if (input.signal?.aborted)
       cancel();
@@ -600,7 +659,7 @@ function createShellCodingTool(config, limits) {
         throw new Error("Coding tool executable is not declared");
       const root = await realpath4(config.root);
       const cwd = await existingCodingPath(root, input.cwd, limits.maxPathBytes);
-      if (!(await stat2(cwd.absolute)).isDirectory()) {
+      if (!(await stat(cwd.absolute)).isDirectory()) {
         throw new Error("Coding tool cwd is not a directory");
       }
       await authorizeCodingTool(config, {
@@ -617,6 +676,7 @@ function createShellCodingTool(config, limits) {
         environment: config.environment ?? {},
         ...signal && { signal },
         timeoutMs: limits.shellTimeoutMs,
+        terminationGraceMs: limits.shellTerminationGraceMs,
         maxOutputBytes: limits.maxShellOutputBytes,
         maxArtifactBytes: limits.maxArtifactBytes,
         ...config.artifacts && { artifacts: config.artifacts }
@@ -635,10 +695,10 @@ var AGENT_CODING_TOOL_NAMES = {
   writeFile: "write_file"
 };
 function createAgentCodingTools(config) {
-  if (!path3.isAbsolute(config.root))
+  if (!path4.isAbsolute(config.root))
     throw new Error("Coding tool root must be absolute");
   for (const executable of Object.values(config.executables ?? {})) {
-    if (!path3.isAbsolute(executable)) {
+    if (!path4.isAbsolute(executable)) {
       throw new Error("Coding tool executables must be absolute paths");
     }
   }

package/dist/agent-runtime-harness.js

@@ -3,28 +3,29 @@ import {
   composeAgentPrompt,
   createAgentRuntime,
   createAgentRuntimeEventSink
-} from "./index-3eqrkqhg.js";
+} from "./index-vy5bjy07.js";
 import {
-  readContainedUtf8File,
   walkContainedFiles
-} from "./index-v3dpzpjw.js";
+} from "./index-xbtcszs7.js";
 import {
   AgentModelDescriptorSchema
 } from "./index-tg3m2ec5.js";
 import"./index-es0h4w26.js";
 import"./index-a59da114.js";
+import"./index-3xnq72rz.js";
 import {
   defineRuntimeTool
 } from "./index-wwst0td5.js";
-import"./index-h8vn1jcr.js";
-import"./index-p1be103g.js";
+import"./index-qzbg46b6.js";
+import"./index-ktsps64f.js";
 import {
   AgentMessagePartSchema,
   AgentSnapshotSchema
 } from "./index-x1th9s8c.js";
 import"./index-22by16v6.js";
 import"./index-cby4ar3v.js";
-import"./index-x18ndp4p.js";
+import"./index-bd17ytae.js";
+import"./index-vj3vvpaa.js";
 import"./index-0w9abg87.js";
 import"./index-qyrqwr4c.js";
 import"./index-6k1937bx.js";
@@ -202,13 +203,16 @@ function createAgentHarnessFileResources(config) {
       const files = await walkContainedFiles({
         root: resolvedRoot,
         maxDepth: limits.maxDepth,
-        maxFiles: limits.maxFiles - fileCount
+        maxFiles: limits.maxFiles - fileCount,
+        readMaxBytes: limits.maxFileBytes
       });
       fileCount += files.length;
       for (const file of files) {
         if (root.kind === "skill" && path.basename(file.absolute) !== "SKILL.md")
           continue;
-        const read = await readContainedUtf8File(file.absolute, limits.maxFileBytes);
+        const read = file.content;
+        if (!read)
+          throw new Error("Agent harness resource content is unavailable");
         totalBytes += read.bytes;
         if (totalBytes > limits.maxTotalBytes) {
           throw new Error("Agent harness resources exceed maxTotalBytes");

package/dist/agent-runtime.js

@@ -27,7 +27,7 @@ import {
   registerDeferredToolRepair,
   repairedSearchCall,
   selectAgentHistory
-} from "./index-3eqrkqhg.js";
+} from "./index-vy5bjy07.js";
 import {
   AgentModelCapabilitySchema,
   AgentModelCatalogEntrySchema,
@@ -82,14 +82,15 @@ import {
 import {
   buildToolManifest,
   mountAgent
-} from "./index-h7ctj1kp.js";
-import"./index-xxsq3ca1.js";
+} from "./index-s8nt8c22.js";
+import"./index-3xnq72rz.js";
+import"./index-vc498pst.js";
 import {
   defineRuntimeTool
 } from "./index-wwst0td5.js";
-import"./index-kg9xx84n.js";
-import"./index-h8vn1jcr.js";
-import"./index-p1be103g.js";
+import"./index-7rey2b8s.js";
+import"./index-qzbg46b6.js";
+import"./index-ktsps64f.js";
 import {
   AgentAssistantPlaceholderSchema,
   AgentControlPartSchema,
@@ -128,7 +129,8 @@ import"./index-cby4ar3v.js";
 import {
   childSpan,
   createTraceContext
-} from "./index-x18ndp4p.js";
+} from "./index-bd17ytae.js";
+import"./index-vj3vvpaa.js";
 import"./index-0w9abg87.js";
 import {
   executableAgentRuntimeTools

package/dist/cli.js

@@ -5,16 +5,17 @@ import {
   emitResult,
   parseCliArgs,
   pollUntilDone
-} from "./index-mbxds404.js";
-import"./index-xxsq3ca1.js";
+} from "./index-mjx0wt4c.js";
+import"./index-vc498pst.js";
 import"./index-wwst0td5.js";
-import"./index-kg9xx84n.js";
-import"./index-h8vn1jcr.js";
-import"./index-p1be103g.js";
+import"./index-7rey2b8s.js";
+import"./index-qzbg46b6.js";
+import"./index-ktsps64f.js";
 import"./index-sbdmyz75.js";
 import"./index-22by16v6.js";
 import"./index-cby4ar3v.js";
-import"./index-x18ndp4p.js";
+import"./index-bd17ytae.js";
+import"./index-vj3vvpaa.js";
 import"./index-0w9abg87.js";
 import"./index-qyrqwr4c.js";
 import"./index-6k1937bx.js";

package/dist/{index-t4dpby6e.js → index-0yphgata.js}

@@ -1,6 +1,6 @@
 import {
   normalizeError
-} from "./index-x18ndp4p.js";
+} from "./index-bd17ytae.js";
 
 // src/internal/bounded-lines.ts
 var DEFAULT_STREAM_LINE_BYTES = 1024 * 1024;