stitchkit 0.118.1 → 0.120.0

package/dist/{index-p0rf7sq9.js → index-bgcwxhxh.js}

@@ -16,28 +16,30 @@ import {
   ownHttpStream,
   settleStreamCleanup,
   ShutdownOptionsSchema2
-} from "./index-q0th8q0z.js";
+} from "./index-9mjrnqxs.js";
 import {
   RELEASE_HEADER2
 } from "./index-n15jny5b.js";
+import {
+  DEFAULT_PROCESS_SIGNALS,
+  defaultSignalSource,
+  reportSignalError,
+  guardSignalCallback
+} from "./index-3prvb42w.js";
 import {
   isModuleNotFound
 } from "./index-srs8hj9c.js";
 import {
   bindContract,
   mediaTypeEssence
-} from "./index-cqmqyjax.js";
+} from "./index-sa99p98w.js";
 import {
   assertCorsConfig,
   isOriginAllowed,
   corsPreflightResponse2,
   requestCorsHeaders,
-  applyCors,
-  DEFAULT_PROCESS_SIGNALS,
-  defaultSignalSource,
-  reportSignalError,
-  guardSignalCallback
-} from "./index-yk4g8805.js";
+  applyCors
+} from "./index-pq7rkwkk.js";
 import {
   runWithRequestContext2,
   getRequestContext2,
@@ -51,22 +53,22 @@ import {
   getClientInfo2,
   parseQueryParams
 } from "./index-kw1ws0cs.js";
+import {
+  isUnsafeKey,
+  safeJsonParse
+} from "./index-zsarb5xp.js";
 import {
   readBoundedChunks,
   concatChunks,
   readBoundedBody2
-} from "./index-qndsr7f0.js";
+} from "./index-5efrpfmj.js";
+import {
+  assertPositiveSafeInteger
+} from "./index-0s4xebbg.js";
 import {
   abortReason,
   untilAborted
 } from "./index-a5qr2rj6.js";
-import {
-  isUnsafeKey,
-  safeJsonParse
-} from "./index-zsarb5xp.js";
-import {
-  assertPositiveSafeInteger
-} from "./index-0s4xebbg.js";
 import {
   AppError2,
   badRequest2,
@@ -80,6 +82,101 @@ import {
   transportResult
 } from "./index-9jfdm5tg.js";
 
+// src/server/context-contribution.ts
+var RUNTIME_CONTEXT_RESERVED_KEYS = new Set([
+  "params",
+  "input",
+  "files",
+  "rawBody",
+  "source",
+  "req",
+  "url",
+  "headers",
+  "traceId",
+  "spanId",
+  "ipAddress",
+  "userAgent",
+  "signal",
+  "mcp",
+  "reportProgress"
+]);
+function contributionError(scope, reason) {
+  return new TypeError(`[stitchkit] auth: invalid context contribution for scope ${JSON.stringify(scope)}: ${reason}`);
+}
+function descriptorsEqual(left, right) {
+  if (!left || !right)
+    return left === right;
+  if (left.enumerable !== right.enumerable || left.configurable !== right.configurable || left.writable !== right.writable) {
+    return false;
+  }
+  if ("value" in left || "value" in right) {
+    return "value" in left && "value" in right && Object.is(left.value, right.value);
+  }
+  return left.get === right.get && left.set === right.set;
+}
+function contextContributionDelta(original, shadow, scope) {
+  if (Object.getPrototypeOf(shadow) !== Object.getPrototypeOf(original)) {
+    throw contributionError(scope, "context prototype changes are not supported");
+  }
+  const originalKeys = Reflect.ownKeys(original);
+  const shadowKeys = Reflect.ownKeys(shadow);
+  const shadowKeySet = new Set(shadowKeys);
+  for (const key of originalKeys) {
+    if (!shadowKeySet.has(key)) {
+      const printable = typeof key === "string" ? JSON.stringify(key) : "a symbol key";
+      throw contributionError(scope, `context key ${printable} may not be deleted`);
+    }
+  }
+  const contribution = Object.create(null);
+  for (const key of shadowKeys) {
+    const originalDescriptor = Object.getOwnPropertyDescriptor(original, key);
+    const shadowDescriptor = Object.getOwnPropertyDescriptor(shadow, key);
+    if (!shadowDescriptor || descriptorsEqual(originalDescriptor, shadowDescriptor))
+      continue;
+    Object.defineProperty(contribution, key, shadowDescriptor);
+  }
+  return contribution;
+}
+function prepareContextContribution(value, scope) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw contributionError(scope, "expected a plain record");
+  }
+  let prototype;
+  let descriptors;
+  let keys;
+  try {
+    prototype = Object.getPrototypeOf(value);
+    descriptors = Object.getOwnPropertyDescriptors(value);
+    keys = Reflect.ownKeys(value);
+  } catch {
+    throw contributionError(scope, "record inspection failed");
+  }
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw contributionError(scope, "expected Object.prototype or null prototype");
+  }
+  const prepared = Object.create(null);
+  for (const key of keys) {
+    if (typeof key !== "string") {
+      throw contributionError(scope, "symbol keys are not supported");
+    }
+    if (isUnsafeKey(key)) {
+      throw contributionError(scope, `unsafe key ${JSON.stringify(key)}`);
+    }
+    if (RUNTIME_CONTEXT_RESERVED_KEYS.has(key)) {
+      throw contributionError(scope, `reserved key ${JSON.stringify(key)}`);
+    }
+    const descriptor = descriptors[key];
+    if (!descriptor?.enumerable || !("value" in descriptor)) {
+      throw contributionError(scope, `key ${JSON.stringify(key)} must be enumerable data`);
+    }
+    prepared[key] = descriptor.value;
+  }
+  return prepared;
+}
+function mergeContextContribution(ctx, value, scope) {
+  Object.assign(ctx, prepareContextContribution(value, scope));
+}
+
 // src/server/multipart-reader.ts
 var DEFAULT_MAX_HEADER_BYTES = 64 * 1024;
 var CRLF = new Uint8Array([13, 10]);
@@ -552,6 +649,110 @@ async function parseMultipart2(req, descriptor, fieldsSchema, receivers) {
   }
 }
 
+// src/server/request-body.ts
+async function readRequestText(req, maxBytes) {
+  if (req.signal.aborted)
+    throw abortReason(req.signal);
+  if (maxBytes === undefined)
+    return req.text();
+  assertPositiveSafeInteger("maxJsonBodyBytes", maxBytes, Error);
+  const result = await readBoundedChunks(req.body, { maxBytes, signal: req.signal });
+  if (result.kind === "over-limit")
+    badRequest2(`JSON body exceeds the ${maxBytes}-byte limit`);
+  return new TextDecoder().decode(concatChunks(result.chunks, result.total));
+}
+
+// src/server/context.ts
+function parseJsonBody(req, text, method, cors) {
+  if (text.trim() === "")
+    return {};
+  const essence = mediaTypeEssence(req.headers.get("content-type"));
+  if (essence !== "application/json") {
+    if (!method.safelistedBody || essence !== "text/plain") {
+      badRequest2("Request body must be application/json");
+    }
+    const origin = req.headers.get("origin");
+    if (!cors || cors.origin === undefined || cors.origin === "*") {
+      forbidden2("A text/plain body requires an explicit cors.origin allow-list on the server");
+    }
+    if (!origin)
+      forbidden2("A text/plain body requires an Origin header");
+    if (!isOriginAllowed(cors, origin)) {
+      forbidden2("A text/plain body is accepted only from an allowed origin");
+    }
+  }
+  try {
+    return safeJsonParse(text);
+  } catch {
+    badRequest2("Invalid JSON body");
+  }
+}
+function buildBaseContext(req, url, pathParams, traceId, clientIp) {
+  const safePathParams = {};
+  for (const [k, v] of Object.entries(pathParams)) {
+    if (!RUNTIME_CONTEXT_RESERVED_KEYS.has(k) && !isUnsafeKey(k))
+      safePathParams[k] = v;
+  }
+  return {
+    params: pathParams,
+    input: undefined,
+    source: "http",
+    req,
+    url,
+    headers: req.headers,
+    signal: req.signal,
+    ...safePathParams,
+    traceId,
+    ...getClientInfo2(req, clientIp)
+  };
+}
+function parsePathParamsInto(ctx, method) {
+  if (method.paramsSchema) {
+    ctx.params = method.paramsSchema.parse(ctx.params);
+  }
+}
+async function parseRequestPayloadInto(ctx, req, url, method, maxJsonBodyBytes, cors) {
+  if (method.multipart) {
+    const multipart = await parseMultipart2(req, method.multipart, method.inputSchema, method.multipartReceivers);
+    ctx.input = multipart.fields;
+    ctx.files = multipart.files;
+    return multipart;
+  }
+  if (method.inputSchema) {
+    if (req.method === "GET") {
+      ctx.input = method.inputSchema.parse(parseQueryParams(url));
+    } else if (req.method === "DELETE") {
+      if (mediaTypeEssence(req.headers.get("content-type")) === "application/json") {
+        const text = await readRequestText(req, method.maxJsonBodyBytes ?? maxJsonBodyBytes);
+        if (method.rawBody)
+          ctx.rawBody = text;
+        ctx.input = method.inputSchema.parse(parseJsonBody(req, text, method, cors));
+      } else {
+        ctx.input = method.inputSchema.parse(parseQueryParams(url));
+      }
+    } else {
+      const text = await readRequestText(req, method.maxJsonBodyBytes ?? maxJsonBodyBytes);
+      if (method.rawBody)
+        ctx.rawBody = text;
+      ctx.input = method.inputSchema.parse(parseJsonBody(req, text, method, cors));
+    }
+  }
+  return;
+}
+function buildErrorContext(req, url, traceId, clientIp) {
+  return {
+    params: undefined,
+    input: undefined,
+    source: "http",
+    req,
+    url,
+    headers: req.headers,
+    signal: req.signal,
+    traceId,
+    ...getClientInfo2(req, clientIp)
+  };
+}
+
 // src/server/streaming-pump.ts
 async function pumpFrames(p) {
   let sinceYield = 0;
@@ -792,205 +993,6 @@ function sseRoute2(options) {
   return streamingRoute2({ ...options, format: "sse" });
 }
 
-// src/server/context-contribution.ts
-var RUNTIME_CONTEXT_RESERVED_KEYS = new Set([
-  "params",
-  "input",
-  "files",
-  "rawBody",
-  "source",
-  "req",
-  "url",
-  "headers",
-  "traceId",
-  "spanId",
-  "ipAddress",
-  "userAgent",
-  "signal",
-  "mcp",
-  "reportProgress"
-]);
-function contributionError(scope, reason) {
-  return new TypeError(`[stitchkit] auth: invalid context contribution for scope ${JSON.stringify(scope)}: ${reason}`);
-}
-function descriptorsEqual(left, right) {
-  if (!left || !right)
-    return left === right;
-  if (left.enumerable !== right.enumerable || left.configurable !== right.configurable || left.writable !== right.writable) {
-    return false;
-  }
-  if ("value" in left || "value" in right) {
-    return "value" in left && "value" in right && Object.is(left.value, right.value);
-  }
-  return left.get === right.get && left.set === right.set;
-}
-function contextContributionDelta(original, shadow, scope) {
-  if (Object.getPrototypeOf(shadow) !== Object.getPrototypeOf(original)) {
-    throw contributionError(scope, "context prototype changes are not supported");
-  }
-  const originalKeys = Reflect.ownKeys(original);
-  const shadowKeys = Reflect.ownKeys(shadow);
-  const shadowKeySet = new Set(shadowKeys);
-  for (const key of originalKeys) {
-    if (!shadowKeySet.has(key)) {
-      const printable = typeof key === "string" ? JSON.stringify(key) : "a symbol key";
-      throw contributionError(scope, `context key ${printable} may not be deleted`);
-    }
-  }
-  const contribution = Object.create(null);
-  for (const key of shadowKeys) {
-    const originalDescriptor = Object.getOwnPropertyDescriptor(original, key);
-    const shadowDescriptor = Object.getOwnPropertyDescriptor(shadow, key);
-    if (!shadowDescriptor || descriptorsEqual(originalDescriptor, shadowDescriptor))
-      continue;
-    Object.defineProperty(contribution, key, shadowDescriptor);
-  }
-  return contribution;
-}
-function prepareContextContribution(value, scope) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw contributionError(scope, "expected a plain record");
-  }
-  let prototype;
-  let descriptors;
-  let keys;
-  try {
-    prototype = Object.getPrototypeOf(value);
-    descriptors = Object.getOwnPropertyDescriptors(value);
-    keys = Reflect.ownKeys(value);
-  } catch {
-    throw contributionError(scope, "record inspection failed");
-  }
-  if (prototype !== Object.prototype && prototype !== null) {
-    throw contributionError(scope, "expected Object.prototype or null prototype");
-  }
-  const prepared = Object.create(null);
-  for (const key of keys) {
-    if (typeof key !== "string") {
-      throw contributionError(scope, "symbol keys are not supported");
-    }
-    if (isUnsafeKey(key)) {
-      throw contributionError(scope, `unsafe key ${JSON.stringify(key)}`);
-    }
-    if (RUNTIME_CONTEXT_RESERVED_KEYS.has(key)) {
-      throw contributionError(scope, `reserved key ${JSON.stringify(key)}`);
-    }
-    const descriptor = descriptors[key];
-    if (!descriptor?.enumerable || !("value" in descriptor)) {
-      throw contributionError(scope, `key ${JSON.stringify(key)} must be enumerable data`);
-    }
-    prepared[key] = descriptor.value;
-  }
-  return prepared;
-}
-function mergeContextContribution(ctx, value, scope) {
-  Object.assign(ctx, prepareContextContribution(value, scope));
-}
-
-// src/server/request-body.ts
-async function readRequestText(req, maxBytes) {
-  if (req.signal.aborted)
-    throw abortReason(req.signal);
-  if (maxBytes === undefined)
-    return req.text();
-  assertPositiveSafeInteger("maxJsonBodyBytes", maxBytes, Error);
-  const result = await readBoundedChunks(req.body, { maxBytes, signal: req.signal });
-  if (result.kind === "over-limit")
-    badRequest2(`JSON body exceeds the ${maxBytes}-byte limit`);
-  return new TextDecoder().decode(concatChunks(result.chunks, result.total));
-}
-
-// src/server/context.ts
-function parseJsonBody(req, text, method, cors) {
-  if (text.trim() === "")
-    return {};
-  const essence = mediaTypeEssence(req.headers.get("content-type"));
-  if (essence !== "application/json") {
-    if (!method.safelistedBody || essence !== "text/plain") {
-      badRequest2("Request body must be application/json");
-    }
-    const origin = req.headers.get("origin");
-    if (!cors || cors.origin === undefined || cors.origin === "*") {
-      forbidden2("A text/plain body requires an explicit cors.origin allow-list on the server");
-    }
-    if (!origin)
-      forbidden2("A text/plain body requires an Origin header");
-    if (!isOriginAllowed(cors, origin)) {
-      forbidden2("A text/plain body is accepted only from an allowed origin");
-    }
-  }
-  try {
-    return safeJsonParse(text);
-  } catch {
-    badRequest2("Invalid JSON body");
-  }
-}
-function buildBaseContext(req, url, pathParams, traceId, clientIp) {
-  const safePathParams = {};
-  for (const [k, v] of Object.entries(pathParams)) {
-    if (!RUNTIME_CONTEXT_RESERVED_KEYS.has(k) && !isUnsafeKey(k))
-      safePathParams[k] = v;
-  }
-  return {
-    params: pathParams,
-    input: undefined,
-    source: "http",
-    req,
-    url,
-    headers: req.headers,
-    signal: req.signal,
-    ...safePathParams,
-    traceId,
-    ...getClientInfo2(req, clientIp)
-  };
-}
-function parsePathParamsInto(ctx, method) {
-  if (method.paramsSchema) {
-    ctx.params = method.paramsSchema.parse(ctx.params);
-  }
-}
-async function parseRequestPayloadInto(ctx, req, url, method, maxJsonBodyBytes, cors) {
-  if (method.multipart) {
-    const multipart = await parseMultipart2(req, method.multipart, method.inputSchema, method.multipartReceivers);
-    ctx.input = multipart.fields;
-    ctx.files = multipart.files;
-    return multipart;
-  }
-  if (method.inputSchema) {
-    if (req.method === "GET") {
-      ctx.input = method.inputSchema.parse(parseQueryParams(url));
-    } else if (req.method === "DELETE") {
-      if (mediaTypeEssence(req.headers.get("content-type")) === "application/json") {
-        const text = await readRequestText(req, method.maxJsonBodyBytes ?? maxJsonBodyBytes);
-        if (method.rawBody)
-          ctx.rawBody = text;
-        ctx.input = method.inputSchema.parse(parseJsonBody(req, text, method, cors));
-      } else {
-        ctx.input = method.inputSchema.parse(parseQueryParams(url));
-      }
-    } else {
-      const text = await readRequestText(req, method.maxJsonBodyBytes ?? maxJsonBodyBytes);
-      if (method.rawBody)
-        ctx.rawBody = text;
-      ctx.input = method.inputSchema.parse(parseJsonBody(req, text, method, cors));
-    }
-  }
-  return;
-}
-function buildErrorContext(req, url, traceId, clientIp) {
-  return {
-    params: undefined,
-    input: undefined,
-    source: "http",
-    req,
-    url,
-    headers: req.headers,
-    signal: req.signal,
-    traceId,
-    ...getClientInfo2(req, clientIp)
-  };
-}
-
 // src/server/contract-stream.ts
 function encodedBytes(value, format) {
   const json = JSON.stringify(value);
@@ -2342,7 +2344,7 @@ function webSocketLane2(lane) {
     handlers: {
       message(ws, message) {
         if (match(ws))
-          handlers.message(ws, message);
+          handlers.message?.(ws, message);
       },
       open(ws) {
         if (match(ws))
@@ -2372,7 +2374,7 @@ function composeWebSocketHandlers2(lanes, config) {
   return {
     ...config,
     message(ws, message) {
-      pick(ws)?.handlers.message(ws, message);
+      pick(ws)?.handlers.message?.(ws, message);
     },
     open(ws) {
       pick(ws)?.handlers.open?.(ws);
@@ -2577,6 +2579,12 @@ function socketIoLane2(websocket) {
   });
 }
 
+// src/server/unix-client.ts
+import {
+  Agent,
+  request as httpRequest
+} from "node:http";
+
 // src/server/unix-client-error.ts
 class UnixClientTransportError2 extends Error {
   code;
@@ -2589,12 +2597,6 @@ class UnixClientTransportError2 extends Error {
   }
 }
 
-// src/server/unix-client.ts
-import {
-  Agent,
-  request as httpRequest
-} from "node:http";
-
 // src/server/unix-client-body.ts
 async function readBoundedRequestBody(request, maxBytes) {
   if (!request.body)

package/dist/index-bph35vpy.js

@@ -0,0 +1,77 @@
+import {
+  sleep
+} from "./index-eemvahkc.js";
+
+// src/tools/operations/wait-core.ts
+var DEFAULT_BACKOFF = [2, 3, 5, 5, 8, 10];
+var DEFAULT_TIMEOUT = 600;
+
+class WaitTimeoutError extends Error {
+  constructor() {
+    super("wait deadline elapsed before the first snapshot");
+    this.name = "WaitTimeoutError";
+  }
+}
+async function pollUntil(params) {
+  const backoff = params.backoff?.length ? params.backoff : DEFAULT_BACKOFF;
+  const lastBackoff = backoff[backoff.length - 1] ?? 5;
+  const timeoutSec = params.timeoutSec ?? DEFAULT_TIMEOUT;
+  const pause = params.sleepFn ?? sleep;
+  const now = params.nowFn ?? (() => performance.now());
+  const startedAt = now();
+  const deadline = startedAt + timeoutSec * 1000;
+  let last;
+  for (let attempt = 0;; attempt++) {
+    params.signal?.throwIfAborted();
+    const remainingBeforePoll = Math.max(0, deadline - now());
+    if (remainingBeforePoll === 0 && last) {
+      return { state: last.state, timedOut: true };
+    }
+    const deadlineController = new AbortController;
+    const onCallerAbort = () => deadlineController.abort(params.signal?.reason);
+    params.signal?.addEventListener("abort", onCallerAbort, { once: true });
+    const deadlineTimer = setTimeout(() => deadlineController.abort(new WaitTimeoutError), remainingBeforePoll);
+    deadlineTimer.unref?.();
+    let state;
+    try {
+      state = await params.poll(deadlineController.signal);
+    } catch (error) {
+      if (params.signal?.aborted)
+        throw params.signal.reason ?? error;
+      if (deadlineController.signal.aborted && now() >= deadline) {
+        if (last)
+          return { state: last.state, timedOut: true };
+        throw new WaitTimeoutError;
+      }
+      throw error;
+    } finally {
+      clearTimeout(deadlineTimer);
+      params.signal?.removeEventListener("abort", onCallerAbort);
+    }
+    params.signal?.throwIfAborted();
+    last = { state };
+    if (params.done(state))
+      return { state, timedOut: false };
+    const elapsedMs = now() - startedAt;
+    const elapsedSec = elapsedMs / 1000;
+    params.onTick?.(attempt + 1, elapsedSec);
+    if (elapsedSec >= timeoutSec)
+      return { state, timedOut: true };
+    const waitSec = backoff[Math.min(attempt, backoff.length - 1)] ?? lastBackoff;
+    await pause(Math.min(waitSec * 1000, Math.max(0, deadline - now())), params.signal);
+  }
+}
+function runWaitOperation(params) {
+  return pollUntil({
+    poll: (signal) => params.poll(params.input, signal),
+    done: params.done,
+    backoff: params.backoff,
+    timeoutSec: params.timeoutSec,
+    sleepFn: params.sleepFn,
+    onTick: params.onTick,
+    signal: params.signal,
+    nowFn: params.nowFn
+  });
+}
+
+export { WaitTimeoutError, pollUntil, runWaitOperation };

package/dist/{index-tdpmfks8.js → index-bz479f0x.js}

@@ -3,7 +3,7 @@ import {
   ProcessInstanceSchema2,
   readProcessInstance,
   probeProcessOwner2
-} from "./index-n8z3rvzw.js";
+} from "./index-qevqn3d3.js";
 import {
   BoundedFileReadError,
   readBoundedFile

package/dist/index-d3xdyjt6.js

@@ -0,0 +1,38 @@
+// src/geo/schema.ts
+import { z } from "zod";
+var GeoTextSchema = z.string().min(1);
+var GeoNonnegativeIntegerSchema = z.number().int().nonnegative();
+var GeoLocalizedNamesSchema = z.record(GeoTextSchema, GeoTextSchema).readonly();
+var GeoLocalizedNameSetSchema = z.strictObject({
+  continent: GeoLocalizedNamesSchema.optional(),
+  country: GeoLocalizedNamesSchema.optional(),
+  registeredCountry: GeoLocalizedNamesSchema.optional(),
+  region: GeoLocalizedNamesSchema.optional(),
+  city: GeoLocalizedNamesSchema.optional()
+}).readonly();
+var GeoAttributionSchema2 = z.strictObject({
+  continentCode: GeoTextSchema.optional(),
+  continentName: GeoTextSchema.optional(),
+  continentGeonameId: GeoNonnegativeIntegerSchema.optional(),
+  countryCode: GeoTextSchema.optional(),
+  countryName: GeoTextSchema.optional(),
+  countryGeonameId: GeoNonnegativeIntegerSchema.optional(),
+  registeredCountryCode: GeoTextSchema.optional(),
+  registeredCountryName: GeoTextSchema.optional(),
+  registeredCountryGeonameId: GeoNonnegativeIntegerSchema.optional(),
+  regionCode: GeoTextSchema.optional(),
+  regionName: GeoTextSchema.optional(),
+  regionGeonameId: GeoNonnegativeIntegerSchema.optional(),
+  city: GeoTextSchema.optional(),
+  cityGeonameId: GeoNonnegativeIntegerSchema.optional(),
+  postalCode: GeoTextSchema.optional(),
+  latitude: z.number().min(-90).max(90).optional(),
+  longitude: z.number().min(-180).max(180).optional(),
+  timezone: GeoTextSchema.optional(),
+  accuracyRadiusKm: GeoNonnegativeIntegerSchema.optional(),
+  autonomousSystemNumber: z.number().optional(),
+  autonomousSystemOrganization: GeoTextSchema.optional(),
+  localizedNames: GeoLocalizedNameSetSchema.optional()
+}).readonly();
+
+export { GeoTextSchema, GeoAttributionSchema2 };

package/dist/{index-q968hy6y.js → index-e452syyh.js}

@@ -4,7 +4,7 @@ import {
 import {
   descriptorPath,
   NumericFileHandle
-} from "./index-arjmb6de.js";
+} from "./index-1jwsfkfz.js";
 import {
   stagingName
 } from "./index-tt30h7mr.js";

package/dist/{index-86nbfysb.js → index-ff39f9dr.js}

@@ -1,12 +1,12 @@
 import {
   projectToolSurface
-} from "./index-rhzkndr5.js";
+} from "./index-x4p3kw1p.js";
 import {
   contractToolMountable
-} from "./index-htxh46ej.js";
+} from "./index-ycqhyars.js";
 import {
   runtimeToolMountable
-} from "./index-ega3yz4c.js";
+} from "./index-aqwg2dm5.js";
 
 // src/tools/surface.ts
 function collectToolSurface({