stitchkit 0.104.2 → 0.105.1

package/dist/{index-hbd32c6a.js → index-w8etpm8j.js}

@@ -2,22 +2,29 @@ import {
   ManagedFilePathSchema2,
   ManagedFileRefSchema2
 } from "./index-xqhede6x.js";
+import {
+  raceAbort
+} from "./index-b0kddvzw.js";
 import {
   BoundedFileReadError,
   readBoundedFile
-} from "./index-jd470k6q.js";
+} from "./index-m616f0yz.js";
 import {
   isWithinDir2
 } from "./index-5cc6r990.js";
 import {
-  AtomicFilePublicationError2,
-  publishAtomicFile
-} from "./index-8a9ksm91.js";
+  writeAllBytes,
+  writeAtomicFileStaged
+} from "./index-cazts87s.js";
+import {
+  AtomicFilePublicationError2
+} from "./index-b56nnscm.js";
+import {
+  assertPositiveSafeInteger
+} from "./index-0s4xebbg.js";
 
 // src/files/boundary.ts
-import { randomUUID } from "node:crypto";
-import { constants } from "node:fs";
-import { mkdir, open as open2, realpath, stat, unlink } from "node:fs/promises";
+import { mkdir, realpath, stat } from "node:fs/promises";
 import { basename as basename2, dirname, resolve } from "node:path";
 
 // src/files/file-io.ts
@@ -25,27 +32,6 @@ var ManagedFileInspectionSchema = ManagedFileRefSchema2.pick({
   mediaType: true,
   name: true
 });
-function abortReason(signal) {
-  return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
-}
-function raceWithSignal(operation, signal) {
-  signal.throwIfAborted();
-  return new Promise((resolvePromise, rejectPromise) => {
-    let settled = false;
-    const settle = (complete) => {
-      if (settled)
-        return;
-      settled = true;
-      signal.removeEventListener("abort", onAbort);
-      complete();
-    };
-    const onAbort = () => settle(() => rejectPromise(abortReason(signal)));
-    signal.addEventListener("abort", onAbort, { once: true });
-    if (signal.aborted)
-      onAbort();
-    operation.then((value) => settle(() => resolvePromise(value)), (error) => settle(() => rejectPromise(error)));
-  });
-}
 async function inspectFile(inspector, input, timeoutMs, outerSignal) {
   if (!inspector)
     return {};
@@ -53,11 +39,11 @@ async function inspectFile(inspector, input, timeoutMs, outerSignal) {
   const timeoutSignal = AbortSignal.timeout(timeoutMs);
   const signal = outerSignal ? AbortSignal.any([outerSignal, timeoutSignal]) : timeoutSignal;
   try {
-    const inspected = await raceWithSignal(Promise.resolve().then(() => inspector({ ...input, signal })), signal);
+    const inspected = await raceAbort(Promise.resolve().then(() => inspector({ ...input, signal })), signal);
     return ManagedFileInspectionSchema.parse(inspected);
   } catch (error) {
     if (outerSignal?.aborted)
-      throw abortReason(outerSignal);
+      throw outerSignal.reason;
     throw new ManagedFileError2("FILE_INSPECTION_REJECTED", "managed file rejected by inspection", { cause: error });
   }
 }
@@ -75,16 +61,7 @@ function inspectedRef(path, size, inspection, fallback = {}) {
   }
   return parsed.data;
 }
-async function writeChunk(handle, chunk) {
-  let offset = 0;
-  while (offset < chunk.byteLength) {
-    const { bytesWritten } = await handle.write(chunk, offset, chunk.byteLength - offset);
-    if (bytesWritten === 0)
-      throw new Error("zero-byte managed-file write");
-    offset += bytesWritten;
-  }
-}
-async function writeSource(handle, source, maxBytes, inspectionBytes, signal) {
+async function writeSource(file, source, maxBytes, inspectionBytes, signal) {
   let size = 0;
   const prefixChunks = [];
   let prefixSize = 0;
@@ -99,7 +76,7 @@ async function writeSource(handle, source, maxBytes, inspectionBytes, signal) {
       prefixChunks.push(kept);
       prefixSize += kept.byteLength;
     }
-    await writeChunk(handle, chunk);
+    await writeAllBytes(file, chunk);
   };
   if (source instanceof Uint8Array) {
     await consume(source);
@@ -157,11 +134,6 @@ async function readManagedDescriptor(target, path, maxBytes, options, inspection
 var DEFAULT_MAX_BYTES = 100 * 1024 * 1024;
 var DEFAULT_INSPECTION_BYTES = 64 * 1024;
 var DEFAULT_INSPECTION_TIMEOUT_MS = 15000;
-var nofollowFlag;
-var noFollow = () => {
-  nofollowFlag ??= constants.O_NOFOLLOW ?? 0;
-  return nofollowFlag;
-};
 
 class ManagedFileError2 extends Error {
   code;
@@ -173,9 +145,7 @@ class ManagedFileError2 extends Error {
 }
 function positiveLimit(value, fallback, name) {
   const resolved = value ?? fallback;
-  if (!Number.isSafeInteger(resolved) || resolved <= 0) {
-    throw new TypeError(`${name} must be a positive safe integer`);
-  }
+  assertPositiveSafeInteger(name, resolved);
   return resolved;
 }
 function filePath(path) {
@@ -311,37 +281,24 @@ async function createManagedFileBoundary2(config) {
       const resolved = targetFor(path);
       const parent = await existingParent(root, resolved.target);
       const maxBytes = positiveLimit(options.maxBytes, maxWriteBytes, "maxBytes");
-      const temporary = resolve(parent, `.stitchkit-${randomUUID()}.tmp`);
-      let handle;
-      let committed = false;
-      let size = 0;
       try {
-        handle = await open2(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | noFollow(), 384);
-        const written = await writeSource(handle, source, maxBytes, inspectionBytes, options.signal);
-        size = written.size;
-        if (options.durable)
-          await handle.sync();
-        await handle.close();
-        handle = undefined;
-        const inspection = await inspectFile(config.inspect, {
-          prefix: written.prefix,
-          ...options.mediaType ? { declaredMediaType: options.mediaType } : {},
-          name: options.name ?? basename2(resolved.path)
-        }, inspectionTimeoutMs, options.signal);
-        options.signal?.throwIfAborted();
-        try {
-          await publishAtomicFile(temporary, resolved.target, options.replace ?? false, options.durable ?? false);
-          committed = true;
-        } catch (error) {
-          if (error instanceof AtomicFilePublicationError2) {
-            committed = true;
-            throw error;
-          }
-          if (errorCode(error) === "EEXIST")
-            throw new ManagedFileError2("FILE_EXISTS", "managed file already exists");
-          throw error;
-        }
-        return inspectedRef(resolved.path, size, inspection, {
+        const staged = await writeAtomicFileStaged(resolve(parent, basename2(resolved.target)), {
+          async fill(file) {
+            const written = await writeSource(file, source, maxBytes, inspectionBytes, options.signal);
+            const inspection = await inspectFile(config.inspect, {
+              prefix: written.prefix,
+              ...options.mediaType ? { declaredMediaType: options.mediaType } : {},
+              name: options.name ?? basename2(resolved.path)
+            }, inspectionTimeoutMs, options.signal);
+            options.signal?.throwIfAborted();
+            return { size: written.size, inspection };
+          },
+          onCleanupError: config.onCleanupError
+        }, {
+          replace: options.replace ?? false,
+          durability: options.durable ? "directory" : "none"
+        });
+        return inspectedRef(resolved.path, staged.size, staged.inspection, {
           mediaType: options.mediaType,
           name: options.name
         });
@@ -350,17 +307,9 @@ async function createManagedFileBoundary2(config) {
           throw error;
         if (options.signal?.aborted && error === options.signal.reason)
           throw error;
+        if (errorCode(error) === "EEXIST")
+          throw new ManagedFileError2("FILE_EXISTS", "managed file already exists");
         throw ioError("failed to write managed file", error);
-      } finally {
-        await handle?.close().catch(() => {
-          return;
-        });
-        if (!options.replace || !committed) {
-          await unlink(temporary).catch((error) => {
-            if (errorCode(error) !== "ENOENT")
-              config.onCleanupError?.(error);
-          });
-        }
       }
     }
   };

package/dist/{index-2hyavjjj.js → index-wbhdzxar.js}

@@ -1,16 +1,16 @@
 import {
   isRetryableStatus2
-} from "./index-x928baz2.js";
+} from "./index-j9gxbztg.js";
 import {
   rebuildObject,
   mergeSchemas,
   assertToolExtensionCompatible,
   projectToolSurface
-} from "./index-77nxk6ay.js";
+} from "./index-r393tnfp.js";
 import {
   toolErrorFromResult,
   executeToolMethod
-} from "./index-2vnh05w4.js";
+} from "./index-2k91mewf.js";
 
 // src/tools/mount.ts
 import { z } from "zod";

package/dist/{index-4e0ah203.js → index-wdy68sh6.js}

@@ -2,7 +2,7 @@ import {
   AppError2,
   badRequest2,
   forbidden2
-} from "./index-x928baz2.js";
+} from "./index-j9gxbztg.js";
 import {
   isStreamCancellation,
   ownHttpStream,
@@ -14,7 +14,7 @@ import {
   recordedErrorMessage,
   normalizeError2,
   validateDeclaredOutput
-} from "./index-kb8styz3.js";
+} from "./index-rpzewktb.js";
 import {
   resolveTraceContext2
 } from "./index-yex7eg1v.js";
@@ -34,7 +34,10 @@ import {
 import {
   bindContract,
   mediaTypeEssence
-} from "./index-g2j7pnak.js";
+} from "./index-cmzvhhtd.js";
+import {
+  assertPositiveSafeInteger
+} from "./index-0s4xebbg.js";
 import {
   assertCorsConfig,
   isOriginAllowed,
@@ -900,16 +903,11 @@ function throwIfRequestAborted(req) {
   if (req.signal.aborted)
     throw requestAbortReason(req);
 }
-function assertJsonBodyLimit(maxBytes, owner) {
-  if (maxBytes !== undefined && (!Number.isSafeInteger(maxBytes) || maxBytes <= 0)) {
-    throw new Error(`${owner} must be a positive safe integer, received ${maxBytes}`);
-  }
-}
 async function readRequestText(req, maxBytes) {
   throwIfRequestAborted(req);
   if (maxBytes === undefined)
     return req.text();
-  assertJsonBodyLimit(maxBytes, "maxJsonBodyBytes");
+  assertPositiveSafeInteger("maxJsonBodyBytes", maxBytes, Error);
   const reader = req.body?.getReader();
   if (!reader)
     return "";
@@ -1117,7 +1115,10 @@ function contractStreamResponse(request, context, source, descriptor, operationA
         const parsed = descriptor.item.safeParse(next.value);
         if (!parsed.success) {
           console.error("[stitchkit] contract stream item failed validation:", parsed.error);
-          throw new AppError2("STREAM_ITEM_INVALID", "Stream item did not match its contract", 500);
+          throw new AppError2("STREAM_ITEM_INVALID", {
+            message: "Stream item did not match its contract",
+            status: 500
+          });
         }
         const item = parsed.data;
         const terminal = descriptor.terminal?.safeParse(item).success ?? false;
@@ -1126,14 +1127,20 @@ function contractStreamResponse(request, context, source, descriptor, operationA
         const frame = descriptor.framing === "item" ? item : { type: "data", data: item };
         if (encodedBytes(frame, format) > maxFrameBytes) {
           console.error(`[stitchkit] contract stream frame exceeded its ${maxFrameBytes} byte limit`);
-          throw new AppError2("STREAM_FRAME_TOO_LARGE", "Stream item exceeded its declared frame limit", 500);
+          throw new AppError2("STREAM_FRAME_TOO_LARGE", {
+            message: "Stream item exceeded its declared frame limit",
+            status: 500
+          });
         }
         yield frame;
         if (terminal && descriptor.completion === "terminal")
           return;
       }
       if (!terminalSeen) {
-        throw new AppError2("STREAM_TERMINAL_MISSING", "Stream completed before its declared terminal item", 500);
+        throw new AppError2("STREAM_TERMINAL_MISSING", {
+          message: "Stream completed before its declared terminal item",
+          status: 500
+        });
       }
       if (descriptor.framing !== "item")
         yield { type: "end" };
@@ -1145,7 +1152,10 @@ function contractStreamResponse(request, context, source, descriptor, operationA
           return;
         yield {
           type: "error",
-          error: new AppError2("STREAM_LIFETIME_EXCEEDED", "Stream exceeded its declared lifetime", 408).toJSON().error
+          error: new AppError2("STREAM_LIFETIME_EXCEEDED", {
+            message: "Stream exceeded its declared lifetime",
+            status: 408
+          }).toJSON().error
         };
         return;
       }
@@ -1221,7 +1231,10 @@ async function endpointResponse(state, request, outcome) {
 }
 function rawEndpointResponse(state, request, { match: { method }, result }) {
   if (!(result instanceof Response)) {
-    throw new AppError2("INTERNAL_SERVER_ERROR", `Raw endpoint ${method.serviceName}.${method.key} must return a Response`, 500);
+    throw new AppError2("INTERNAL_SERVER_ERROR", {
+      message: `Raw endpoint ${method.serviceName}.${method.key} must return a Response`,
+      status: 500
+    });
   }
   const response = method.method === "HEAD" ? new Response(null, {
     status: result.status,
@@ -1236,7 +1249,10 @@ async function streamEndpointResponse(state, request, { match: { method, pathPar
   const { req, server, clientIp } = request;
   if (!method.stream || !streamAbort || !isAsyncIterable(result)) {
     streamAbort?.abort();
-    throw new AppError2("INTERNAL_SERVER_ERROR", `Streaming endpoint ${method.serviceName}.${method.key} must return an AsyncIterable`, 500);
+    throw new AppError2("INTERNAL_SERVER_ERROR", {
+      message: `Streaming endpoint ${method.serviceName}.${method.key} must return an AsyncIterable`,
+      status: 500
+    });
   }
   const response = await contractStreamResponse(req, { params: pathParams, server, ipAddress: clientIp.socketIp }, result, method.stream, streamAbort);
   const withCors = applyCors(response, state.cors, req);
@@ -1263,18 +1279,24 @@ async function dataEndpointResponse(state, request, {
       result = transformed;
   }
   if (result instanceof Response) {
-    throw new AppError2("INTERNAL_SERVER_ERROR", `${method.serviceName}.${method.key} produced a Response on the data path — only a \`rawResponse: true\` endpoint may return one (an afterHandle hook must return data)`, 500);
+    throw new AppError2("INTERNAL_SERVER_ERROR", {
+      message: `${method.serviceName}.${method.key} produced a Response on the data path — only a \`rawResponse: true\` endpoint may return one (an afterHandle hook must return data)`,
+      status: 500
+    });
   }
   const checked = validateDeclaredOutput(method.outputSchema, result, config.warnOnOutputStrip && method.outputSchema ? (paths) => {
     warn(`[stitchkit] output strip ${method.serviceName}.${method.key}: ${paths.join(", ")}`);
   } : undefined);
   if (!checked.ok) {
-    throw new AppError2("INTERNAL_SERVER_ERROR", checked.message, 500);
+    throw new AppError2("INTERNAL_SERVER_ERROR", { message: checked.message, status: 500 });
   }
   result = checked.data;
   const responseStatus = method.responseMeta?.status ?? (method.outputSchema ? 200 : 204);
   if (method.outputSchema && (responseStatus === 204 || responseStatus === 205)) {
-    throw new AppError2("INTERNAL_SERVER_ERROR", `${method.serviceName}.${method.key} cannot combine output with bodyless status ${responseStatus}`, 500);
+    throw new AppError2("INTERNAL_SERVER_ERROR", {
+      message: `${method.serviceName}.${method.key} cannot combine output with bodyless status ${responseStatus}`,
+      status: 500
+    });
   }
   const responseHeaders = new Headers(requestCorsHeaders(cors, req));
   applyResponseMetadata(responseHeaders, responseMetadata, `${method.serviceName}.${method.key}`);
@@ -1784,7 +1806,7 @@ function createHandlerState(config) {
   const { cors, hooks, logging = false, observability } = config;
   if (cors)
     assertCorsConfig(cors);
-  assertJsonBodyLimit(config.maxJsonBodyBytes, "HandlerConfig.maxJsonBodyBytes");
+  assertPositiveSafeInteger("HandlerConfig.maxJsonBodyBytes", config.maxJsonBodyBytes, Error);
   const logConfig = resolveLoggingConfig(logging);
   const customLogger = logConfig?.logger ?? null;
   const useDefaultLog = logConfig !== null && !logConfig.logger;
@@ -2151,11 +2173,14 @@ async function dispatch(state, req, url, traceId, server, clientIp, startedAt) {
   if (!match) {
     const allow = allowedMethods(routeMap, url.pathname);
     if (allow.length > 0) {
-      const res = await respondError(new AppError2("METHOD_NOT_ALLOWED", `Method ${req.method} not allowed`, 405));
+      const res = await respondError(new AppError2("METHOD_NOT_ALLOWED", {
+        message: `Method ${req.method} not allowed`,
+        status: 405
+      }));
       res.headers.set("Allow", allow.join(", "));
       return res;
     }
-    return respondError(new AppError2("NOT_FOUND", "Not found", 404));
+    return respondError(new AppError2("NOT_FOUND", { message: "Not found", status: 404 }));
   }
   return dispatchEndpoint(state, request, match);
 }
@@ -3175,9 +3200,7 @@ var DEFAULT_MAX_REDIRECTS = 5;
 var DEFAULT_MAX_HEADER_BYTES2 = 64 * 1024;
 function positiveInteger(value, fallback, name) {
   const resolved = value ?? fallback;
-  if (!Number.isSafeInteger(resolved) || resolved <= 0) {
-    throw new TypeError(`${name} must be a positive safe integer`);
-  }
+  assertPositiveSafeInteger(name, resolved);
   return resolved;
 }
 function nonNegativeInteger(value, fallback, name) {

package/dist/{index-hp9d77wk.js → index-x7w1z6pf.js}

@@ -1,11 +1,11 @@
 import {
   defineContract2
-} from "./index-ck71tbcf.js";
+} from "./index-fsw1ybf3.js";
 import {
   AppError2,
   STITCH_ERROR_STATUS2,
   isStitchErrorCode2
-} from "./index-x928baz2.js";
+} from "./index-j9gxbztg.js";
 import {
   bytesToBase64Url,
   base64UrlToBytes
@@ -46,10 +46,21 @@ function defineErrors2(source, mapping) {
         if ("details" in options) {
           throw new Error(`[stitchkit] Error "${name}" does not declare details`);
         }
-        return new AppError2(name, message, definition.status, undefined, options.hint, undefined, definition.retryable);
+        return new AppError2(name, {
+          message,
+          status: definition.status,
+          hint: options.hint,
+          retryable: definition.retryable
+        });
       }
       const details = definition.details.parse(options.details);
-      return new AppError2(name, message, definition.status, details, options.hint, undefined, definition.retryable);
+      return new AppError2(name, {
+        message,
+        status: definition.status,
+        details,
+        hint: options.hint,
+        retryable: definition.retryable
+      });
     };
   });
   Object.freeze(errors);

package/dist/{index-ptn0g0gj.js → index-y7k2cdgv.js}

@@ -1,23 +1,25 @@
 import {
   forbidden2,
   conflict2
-} from "./index-x928baz2.js";
+} from "./index-j9gxbztg.js";
 import {
   loadDarwinBinding
 } from "./index-v5ee8ath.js";
+import {
+  stagingName
+} from "./index-j4zh647a.js";
 import {
   NativeCommandError2,
-  stopCommandGroup,
-  ownsCommandGroup,
+  CommandStopped,
   startNativeCommand
-} from "./index-f330qqyg.js";
+} from "./index-5c26631f.js";
 import {
-  probeAgentProcessSandbox2,
+  probeAgentProcessSandboxOutcome,
   missingSandboxRestrictions2,
   codingRefusal,
   codingPathRefusal,
   refuseMissingCodingPath
-} from "./index-6d9xaxw1.js";
+} from "./index-8ks9b85e.js";
 import {
   NumericFileHandle,
   descriptorPath,
@@ -34,7 +36,7 @@ import {
 } from "./index-gxm9rc97.js";
 import {
   defineRuntimeTool2
-} from "./index-cvda079a.js";
+} from "./index-yvfk3y36.js";
 
 // src/agent-runtime/coding-tool-contract.ts
 import { z } from "zod";
@@ -390,7 +392,7 @@ async function writeContainedFile(input) {
     await writeFile(path2.join(descriptorPath(input.parent.handle), input.parent.basename), input.content, { flag: "wx", mode });
     return;
   }
-  const temporary = `.${input.parent.basename}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  const temporary = stagingName();
   if (process.platform === "darwin") {
     const binding = loadDarwinBinding();
     let created = false;
@@ -1067,15 +1069,14 @@ async function runCodingShell(input) {
     env: { ...input.environment },
     envPolicy: "declared-only",
     signal: input.signal ?? new AbortController().signal,
-    killGraceMs: 0,
+    stop: { target: "group", graceMs: 0 },
+    descendants: "terminate-after-leader",
     onOutput: (bytes, channel) => retain(channel === "stdout" ? stdout : stderr, channel === "stdout" ? artifactStdout : artifactStderr, bytes),
-    onLeaderSettled: async (event) => {
+    onLeaderSettled: (event) => {
       if (event.kind !== "exit")
         return;
       exitCode = event.exitCode;
       signal = event.signal;
-      if (process.platform !== "win32" && child && ownsCommandGroup(child))
-        await stopCommandGroup(child?.pid, 0, input.terminationGraceMs, true);
     }
   }, (started) => {
     child = started;
@@ -1104,7 +1105,7 @@ async function runCodingShell(input) {
       outcome = "cancelled";
     else if (error instanceof NativeCommandError2 && error.code === "COMMAND_LIMIT" && (error.reason === "deadline" || error.reason === "output-budget"))
       outcome = error.reason === "deadline" ? "timeout" : "output-limit";
-    else if (error instanceof DOMException && error.name === "AbortError" && error.message === "Command stopped")
+    else if (error instanceof CommandStopped)
       outcome = "cancelled";
     else
       throw error;
@@ -1182,10 +1183,12 @@ function createShellCodingTool(config, limits) {
       let executableArgs = input.args;
       let environment = config.environment ?? {};
       if (config.sandbox) {
-        const grade = await probeAgentProcessSandbox2(config.sandbox.adapter);
+        const probed = await probeAgentProcessSandboxOutcome(config.sandbox.adapter);
+        const grade = probed.grade;
         if (grade.grade === "unavailable") {
           codingRefusal("SANDBOX_UNAVAILABLE", "The configured process sandbox is unavailable", {
-            details: { reason: grade.reason }
+            details: { reason: grade.reason },
+            ...probed.cause !== undefined && { cause: probed.cause }
           });
         }
         const missing = missingSandboxRestrictions2(grade, config.sandbox.required);
@@ -1206,14 +1209,12 @@ function createShellCodingTool(config, limits) {
           executableArgs = [...prepared.args];
           environment = prepared.environment ?? environment;
         } catch (error) {
-          const refreshed = await probeAgentProcessSandbox2(config.sandbox.adapter, {
+          const refreshed = await probeAgentProcessSandboxOutcome(config.sandbox.adapter, {
             refresh: true
           });
           codingRefusal("SANDBOX_UNAVAILABLE", "The process sandbox failed while preparing a command", {
-            details: {
-              grade: refreshed.grade,
-              reason: error instanceof Error ? error.message : "unknown sandbox error"
-            }
+            details: { grade: refreshed.grade.grade, reason: "sandbox prepare failed" },
+            cause: refreshed.cause === undefined ? error : new AggregateError([error, refreshed.cause], "Sandbox prepare failed and probing it again failed")
           });
         }
       }

package/dist/{index-20yvtn9a.js → index-yt7gyg5x.js}

@@ -9,7 +9,7 @@ import {
   AgentControlRequestSchema2,
   AgentControlResponseSchema2,
   AgentControlDeliverySchema2
-} from "./index-n5yqxd3d.js";
+} from "./index-b0w7rbpt.js";
 
 // src/agent-runtime/browser-control-contract.ts
 import { z } from "zod";

package/dist/{index-cvda079a.js → index-yvfk3y36.js}

@@ -1,6 +1,9 @@
 import {
   projectRuntimeTool
-} from "./index-77nxk6ay.js";
+} from "./index-r393tnfp.js";
+import {
+  isRecord
+} from "./index-9jfdm5tg.js";
 
 // src/tools/runtime-tool.ts
 function defineRuntimeTool2(definition) {
@@ -52,6 +55,13 @@ function createRuntimeToolFactory2(config) {
   }
   return { define };
 }
+function isAgentPresenter(value) {
+  return typeof value === "function";
+}
+function agentPresenterOf(definition) {
+  const { present } = definition;
+  return isRecord(present) && isAgentPresenter(present.agent) ? present.agent : undefined;
+}
 function runtimeToolIdentity(definition) {
   return {
     method: definition.identity.method,
@@ -97,4 +107,4 @@ function executableAgentRuntimeTools(tools) {
   return tools;
 }
 
-export { defineRuntimeTool2, createRuntimeToolFactory2, runtimeToolMountable, executableAgentRuntimeTools };
+export { defineRuntimeTool2, createRuntimeToolFactory2, agentPresenterOf, runtimeToolMountable, executableAgentRuntimeTools };

package/dist/{index-5z6jn897.js → index-z23rfxhj.js}

@@ -1,6 +1,6 @@
 import {
   createValidatedRealtimeSocket
-} from "./index-43p08g7t.js";
+} from "./index-pzb63z66.js";
 
 // src/server/realtime.ts
 function bindRealtimeServer2(contract, handle, options = {}) {

package/dist/internal/abort-race.d.ts

@@ -1,3 +1,9 @@
-/** Releases an await on cancellation without assuming a callback cooperates with its signal. */
-export declare function raceAbort<T>(operation: Promise<T>, signal: AbortSignal): Promise<T>;
+/**
+ * Releases an await on cancellation without assuming a callback cooperates with its signal.
+ *
+ * When the signal wins and the operation settles later, a fulfilled value is handed to
+ * `disposeLate` so an owner can release what it would otherwise leak (a stream, a
+ * handle); a late rejection is swallowed because the caller already has the reason.
+ */
+export declare function raceAbort<T>(operation: Promise<T>, signal: AbortSignal, disposeLate?: (value: T) => void): Promise<T>;
 //# sourceMappingURL=abort-race.d.ts.map

package/dist/internal/abort-race.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abort-race.d.ts","sourceRoot":"","sources":["../../src/internal/abort-race.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAChG,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAsBnF"}
+{"version":3,"file":"abort-race.d.ts","sourceRoot":"","sources":["../../src/internal/abort-race.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,EACrB,MAAM,EAAE,WAAW,EACnB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAC/B,OAAO,CAAC,CAAC,CAAC,CA+BZ"}