stitchkit 0.59.1 → 0.59.3

package/dist/cli.js

@@ -16,7 +16,6 @@ import"./index-ps5pxp3h.js";
 import"./index-6k1937bx.js";
 import"./index-y2rb7dwx.js";
 import"./index-smpbdg6k.js";
-import"./index-1bx83sw4.js";
 export {
   DEFAULT_EXIT_CODES,
   createCli,

package/dist/files.js

@@ -7,7 +7,6 @@ import {
   ManagedFilePathSchema,
   ManagedFileRefSchema
 } from "./index-6k1937bx.js";
-import"./index-1bx83sw4.js";
 export {
   ManagedFileError,
   ManagedFilePathSchema,

package/dist/{index-9zn9fb4e.js → index-0tszzfxp.js}

@@ -1,3 +1,6 @@
+import {
+  ShutdownOptionsSchema
+} from "./index-dk6e56g0.js";
 import {
   DEFAULT_PROCESS_SIGNALS,
   RUNTIME_CONTEXT_RESERVED_KEYS,
@@ -38,9 +41,6 @@ import {
   isRecord,
   transportResult
 } from "./index-smpbdg6k.js";
-import {
-  __require
-} from "./index-1bx83sw4.js";
 
 // src/server/multipart.ts
 var DEFAULT_MAX_REQUEST_BYTES = 25 * 1024 * 1024;
@@ -1457,216 +1457,6 @@ function json(data, status, cors, req) {
   return Response.json(data, { status, headers: corsHeaders2(cors, req) });
 }
 
-// src/server/shutdown.ts
-import { z } from "zod";
-var ShutdownStateSchema = z.enum([
-  "running",
-  "draining-http",
-  "closing-realtime",
-  "stopping-runtime",
-  "clean",
-  "forced"
-]);
-var ShutdownOptionsSchema = z.object({
-  gracePeriodMs: z.number().int().nonnegative().default(30000),
-  forceTimeoutMs: z.number().int().nonnegative().default(5000),
-  retryAfterSeconds: z.number().int().nonnegative().default(5),
-  signal: z.custom((value) => typeof value === "object" && value !== null && ("aborted" in value) && ("addEventListener" in value), "Expected an AbortSignal").optional()
-});
-var ShutdownStatusSchema = z.object({
-  state: ShutdownStateSchema,
-  acceptedRequests: z.number().int().nonnegative(),
-  completedRequests: z.number().int().nonnegative(),
-  pendingRequests: z.number().int().nonnegative(),
-  pendingWebSockets: z.number().int().nonnegative()
-});
-var ShutdownResultSchema = z.object({
-  outcome: z.enum(["clean", "forced"]),
-  reason: z.enum(["deadline", "signal"]).optional(),
-  acceptedRequests: z.number().int().nonnegative(),
-  completedRequests: z.number().int().nonnegative(),
-  pendingRequests: z.number().int().nonnegative(),
-  pendingWebSockets: z.number().int().nonnegative(),
-  pendingRequestsAtForce: z.number().int().nonnegative(),
-  pendingWebSocketsAtForce: z.number().int().nonnegative(),
-  abortedRequests: z.number().int().nonnegative(),
-  forcedWebSockets: z.number().int().nonnegative(),
-  durationMs: z.number().nonnegative()
-});
-function rejectedResponse(retryAfterSeconds) {
-  return Response.json({ error: { code: "SERVER_SHUTTING_DOWN", message: "Server is shutting down" } }, {
-    status: 503,
-    headers: {
-      Connection: "close",
-      "Retry-After": String(retryAfterSeconds)
-    }
-  });
-}
-function waitForZero(read, signal) {
-  if (read() === 0)
-    return Promise.resolve();
-  return new Promise((resolve) => {
-    const check = () => {
-      if (read() === 0 || signal.aborted) {
-        clearInterval(timer);
-        signal.removeEventListener("abort", check);
-        resolve();
-      }
-    };
-    const timer = setInterval(check, 5);
-    signal.addEventListener("abort", check, { once: true });
-  });
-}
-function untilAbort(signal) {
-  if (signal.aborted)
-    return Promise.resolve();
-  return new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
-}
-function withTimeout(promise, timeoutMs, message) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
-    promise.then((value) => {
-      clearTimeout(timer);
-      resolve(value);
-    }, (error) => {
-      clearTimeout(timer);
-      reject(error);
-    });
-  });
-}
-function createServerLifecycle(getAdapter) {
-  let state = "running";
-  let acceptedRequests = 0;
-  let completedRequests = 0;
-  let pendingApplicationRequests = 0;
-  let retryAfterSeconds = 5;
-  let shutdownPromise;
-  const status = () => {
-    const adapter = getAdapter();
-    return ShutdownStatusSchema.parse({
-      state,
-      acceptedRequests,
-      completedRequests,
-      pendingRequests: adapter.pendingRequests(),
-      pendingWebSockets: adapter.pendingWebSockets()
-    });
-  };
-  const wrapFetch = (handler) => {
-    return async (request, server) => {
-      if (state !== "running")
-        return rejectedResponse(retryAfterSeconds);
-      acceptedRequests += 1;
-      pendingApplicationRequests += 1;
-      try {
-        return await handler(request, server);
-      } finally {
-        pendingApplicationRequests -= 1;
-        completedRequests += 1;
-      }
-    };
-  };
-  const shutdown = (options) => {
-    if (shutdownPromise)
-      return shutdownPromise;
-    const parsed = ShutdownOptionsSchema.parse(options ?? {});
-    retryAfterSeconds = parsed.retryAfterSeconds;
-    const startedAt = performance.now();
-    const adapter = getAdapter();
-    state = "draining-http";
-    adapter.beginShutdown(retryAfterSeconds);
-    shutdownPromise = new Promise((resolve, reject) => {
-      const phaseAbort = new AbortController;
-      let forcedReason;
-      let phaseError;
-      const force = (reason) => {
-        if (forcedReason)
-          return;
-        forcedReason = reason;
-        phaseAbort.abort();
-      };
-      const timer = setTimeout(() => force("deadline"), parsed.gracePeriodMs);
-      const onExternalAbort = () => force("signal");
-      parsed.signal?.addEventListener("abort", onExternalAbort, { once: true });
-      if (parsed.signal?.aborted)
-        force("signal");
-      const cleanup = () => {
-        clearTimeout(timer);
-        parsed.signal?.removeEventListener("abort", onExternalAbort);
-      };
-      (async () => {
-        try {
-          await waitForZero(() => pendingApplicationRequests, phaseAbort.signal);
-          if (!forcedReason) {
-            state = "closing-realtime";
-            await Promise.race([adapter.closeRealtime(), untilAbort(phaseAbort.signal)]);
-          }
-          if (!forcedReason) {
-            state = "stopping-runtime";
-            await Promise.race([adapter.stopGracefully(), untilAbort(phaseAbort.signal)]);
-          }
-        } catch (error) {
-          if (!forcedReason) {
-            phaseError = error;
-            force("error");
-          }
-        }
-        let pendingRequestsAtForce = 0;
-        let pendingWebSocketsAtForce = 0;
-        if (forcedReason) {
-          state = "stopping-runtime";
-          pendingRequestsAtForce = adapter.pendingRequests();
-          pendingWebSocketsAtForce = adapter.pendingWebSockets();
-          let forceError;
-          let forceFailed = false;
-          try {
-            await withTimeout(adapter.forceStop(), parsed.forceTimeoutMs, `[stitchkit] forced shutdown did not complete within ${parsed.forceTimeoutMs}ms`);
-          } catch (error) {
-            forceFailed = true;
-            forceError = error;
-          } finally {
-            state = "forced";
-          }
-          if (forcedReason === "error") {
-            if (forceFailed) {
-              throw new AggregateError([phaseError, forceError], "[stitchkit] graceful shutdown failed and forced cleanup also failed", { cause: phaseError });
-            }
-            throw phaseError;
-          }
-          if (forceFailed)
-            throw forceError;
-        } else {
-          state = "clean";
-        }
-        cleanup();
-        resolve(ShutdownResultSchema.parse({
-          outcome: forcedReason ? "forced" : "clean",
-          ...forcedReason && { reason: forcedReason },
-          acceptedRequests,
-          completedRequests,
-          pendingRequests: adapter.pendingRequests(),
-          pendingWebSockets: adapter.pendingWebSockets(),
-          pendingRequestsAtForce,
-          pendingWebSocketsAtForce,
-          abortedRequests: pendingRequestsAtForce,
-          forcedWebSockets: pendingWebSocketsAtForce,
-          durationMs: performance.now() - startedAt
-        }));
-      })().catch((error) => {
-        cleanup();
-        reject(error);
-      });
-    });
-    return shutdownPromise;
-  };
-  return {
-    wrapFetch,
-    get status() {
-      return status();
-    },
-    shutdown
-  };
-}
-
 // src/server/process-signals.ts
 var bound = new WeakSet;
 function bindProcessSignals(handle, options = {}) {
@@ -1775,9 +1565,9 @@ function bindProcessSignals(handle, options = {}) {
 }
 
 // src/realtime/rejection.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 function realtimeContractViolation(options) {
-  const issues = options.cause instanceof z2.ZodError ? zodIssues(options.cause) : undefined;
+  const issues = options.cause instanceof z.ZodError ? zodIssues(options.cause) : undefined;
   const reason = options.reason.replaceAll("-", " ");
   const error = new AppError("REALTIME_CONTRACT_VIOLATION", `Realtime event "${options.event}" (${options.direction}, ${options.phase}): ${reason}`, 500, {
     event: options.event,
@@ -2053,6 +1843,8 @@ function composeWebSocketHandlers(lanes, config) {
 }
 
 // src/server/socket-io.ts
+var SOCKET_IO_SERVER = "socket.io";
+var SOCKET_IO_BUN_ENGINE = "@socket.io/bun-engine";
 var noop = () => {};
 function isModuleNotFound(err) {
   if (typeof err !== "object" || err === null)
@@ -2147,7 +1939,7 @@ async function createSocketIOServer(config) {
     });
     checkRequest(webRequest).then(() => done(null, true), (error) => done(error instanceof Error ? error.message : "Request rejected", false));
   };
-  const { Server } = await importPeer(() => import("socket.io"), "socket.io");
+  const { Server } = await importPeer(() => import(SOCKET_IO_SERVER).then((module) => module), SOCKET_IO_SERVER);
   const io = new Server({
     ...config.serverOptions,
     path,
@@ -2174,7 +1966,7 @@ async function createSocketIOServer(config) {
     }
   };
   if (onBun) {
-    const { Server: Engine } = await importPeer(() => import("@socket.io/bun-engine"), "@socket.io/bun-engine");
+    const { Server: Engine } = await importPeer(() => import(SOCKET_IO_BUN_ENGINE).then((module) => module), SOCKET_IO_BUN_ENGINE);
     const engineOpts = {
       path,
       cors,
@@ -2227,4 +2019,4 @@ function socketIoLane(websocket) {
   });
 }
 
-export { parseMultipart, createHandler, ShutdownStateSchema, ShutdownOptionsSchema, ShutdownStatusSchema, ShutdownResultSchema, createServerLifecycle, bindProcessSignals, bindRealtimeServer, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane };
+export { parseMultipart, createHandler, bindProcessSignals, bindRealtimeServer, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane };

package/dist/index-dk6e56g0.js

@@ -0,0 +1,211 @@
+// src/server/shutdown.ts
+import { z } from "zod";
+var ShutdownStateSchema = z.enum([
+  "running",
+  "draining-http",
+  "closing-realtime",
+  "stopping-runtime",
+  "clean",
+  "forced"
+]);
+var ShutdownOptionsSchema = z.object({
+  gracePeriodMs: z.number().int().nonnegative().default(30000),
+  forceTimeoutMs: z.number().int().nonnegative().default(5000),
+  retryAfterSeconds: z.number().int().nonnegative().default(5),
+  signal: z.custom((value) => typeof value === "object" && value !== null && ("aborted" in value) && ("addEventListener" in value), "Expected an AbortSignal").optional()
+});
+var ShutdownStatusSchema = z.object({
+  state: ShutdownStateSchema,
+  acceptedRequests: z.number().int().nonnegative(),
+  completedRequests: z.number().int().nonnegative(),
+  pendingRequests: z.number().int().nonnegative(),
+  pendingWebSockets: z.number().int().nonnegative()
+});
+var ShutdownResultSchema = z.object({
+  outcome: z.enum(["clean", "forced"]),
+  reason: z.enum(["deadline", "signal"]).optional(),
+  acceptedRequests: z.number().int().nonnegative(),
+  completedRequests: z.number().int().nonnegative(),
+  pendingRequests: z.number().int().nonnegative(),
+  pendingWebSockets: z.number().int().nonnegative(),
+  pendingRequestsAtForce: z.number().int().nonnegative(),
+  pendingWebSocketsAtForce: z.number().int().nonnegative(),
+  abortedRequests: z.number().int().nonnegative(),
+  forcedWebSockets: z.number().int().nonnegative(),
+  durationMs: z.number().nonnegative()
+});
+function rejectedResponse(retryAfterSeconds) {
+  return Response.json({ error: { code: "SERVER_SHUTTING_DOWN", message: "Server is shutting down" } }, {
+    status: 503,
+    headers: {
+      Connection: "close",
+      "Retry-After": String(retryAfterSeconds)
+    }
+  });
+}
+function waitForZero(read, signal) {
+  if (read() === 0)
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    const check = () => {
+      if (read() === 0 || signal.aborted) {
+        clearInterval(timer);
+        signal.removeEventListener("abort", check);
+        resolve();
+      }
+    };
+    const timer = setInterval(check, 5);
+    signal.addEventListener("abort", check, { once: true });
+  });
+}
+function untilAbort(signal) {
+  if (signal.aborted)
+    return Promise.resolve();
+  return new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
+}
+function withTimeout(promise, timeoutMs, message) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    promise.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }, (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+function createServerLifecycle(getAdapter) {
+  let state = "running";
+  let acceptedRequests = 0;
+  let completedRequests = 0;
+  let pendingApplicationRequests = 0;
+  let retryAfterSeconds = 5;
+  let shutdownPromise;
+  const status = () => {
+    const adapter = getAdapter();
+    return ShutdownStatusSchema.parse({
+      state,
+      acceptedRequests,
+      completedRequests,
+      pendingRequests: adapter.pendingRequests(),
+      pendingWebSockets: adapter.pendingWebSockets()
+    });
+  };
+  const wrapFetch = (handler) => {
+    return async (request, server) => {
+      if (state !== "running")
+        return rejectedResponse(retryAfterSeconds);
+      acceptedRequests += 1;
+      pendingApplicationRequests += 1;
+      try {
+        return await handler(request, server);
+      } finally {
+        pendingApplicationRequests -= 1;
+        completedRequests += 1;
+      }
+    };
+  };
+  const shutdown = (options) => {
+    if (shutdownPromise)
+      return shutdownPromise;
+    const parsed = ShutdownOptionsSchema.parse(options ?? {});
+    retryAfterSeconds = parsed.retryAfterSeconds;
+    const startedAt = performance.now();
+    const adapter = getAdapter();
+    state = "draining-http";
+    adapter.beginShutdown(retryAfterSeconds);
+    shutdownPromise = new Promise((resolve, reject) => {
+      const phaseAbort = new AbortController;
+      let forcedReason;
+      let phaseError;
+      const force = (reason) => {
+        if (forcedReason)
+          return;
+        forcedReason = reason;
+        phaseAbort.abort();
+      };
+      const timer = setTimeout(() => force("deadline"), parsed.gracePeriodMs);
+      const onExternalAbort = () => force("signal");
+      parsed.signal?.addEventListener("abort", onExternalAbort, { once: true });
+      if (parsed.signal?.aborted)
+        force("signal");
+      const cleanup = () => {
+        clearTimeout(timer);
+        parsed.signal?.removeEventListener("abort", onExternalAbort);
+      };
+      (async () => {
+        try {
+          await waitForZero(() => pendingApplicationRequests, phaseAbort.signal);
+          if (!forcedReason) {
+            state = "closing-realtime";
+            await Promise.race([adapter.closeRealtime(), untilAbort(phaseAbort.signal)]);
+          }
+          if (!forcedReason) {
+            state = "stopping-runtime";
+            await Promise.race([adapter.stopGracefully(), untilAbort(phaseAbort.signal)]);
+          }
+        } catch (error) {
+          if (!forcedReason) {
+            phaseError = error;
+            force("error");
+          }
+        }
+        let pendingRequestsAtForce = 0;
+        let pendingWebSocketsAtForce = 0;
+        if (forcedReason) {
+          state = "stopping-runtime";
+          pendingRequestsAtForce = adapter.pendingRequests();
+          pendingWebSocketsAtForce = adapter.pendingWebSockets();
+          let forceError;
+          let forceFailed = false;
+          try {
+            await withTimeout(adapter.forceStop(), parsed.forceTimeoutMs, `[stitchkit] forced shutdown did not complete within ${parsed.forceTimeoutMs}ms`);
+          } catch (error) {
+            forceFailed = true;
+            forceError = error;
+          } finally {
+            state = "forced";
+          }
+          if (forcedReason === "error") {
+            if (forceFailed) {
+              throw new AggregateError([phaseError, forceError], "[stitchkit] graceful shutdown failed and forced cleanup also failed", { cause: phaseError });
+            }
+            throw phaseError;
+          }
+          if (forceFailed)
+            throw forceError;
+        } else {
+          state = "clean";
+        }
+        cleanup();
+        resolve(ShutdownResultSchema.parse({
+          outcome: forcedReason ? "forced" : "clean",
+          ...forcedReason && { reason: forcedReason },
+          acceptedRequests,
+          completedRequests,
+          pendingRequests: adapter.pendingRequests(),
+          pendingWebSockets: adapter.pendingWebSockets(),
+          pendingRequestsAtForce,
+          pendingWebSocketsAtForce,
+          abortedRequests: pendingRequestsAtForce,
+          forcedWebSockets: pendingWebSocketsAtForce,
+          durationMs: performance.now() - startedAt
+        }));
+      })().catch((error) => {
+        cleanup();
+        reject(error);
+      });
+    });
+    return shutdownPromise;
+  };
+  return {
+    wrapFetch,
+    get status() {
+      return status();
+    },
+    shutdown
+  };
+}
+
+export { ShutdownStateSchema, ShutdownOptionsSchema, ShutdownStatusSchema, ShutdownResultSchema, createServerLifecycle };

package/dist/index-yr276yz0.js

@@ -0,0 +1,6 @@
+// src/application/resource.ts
+function defineManagedResource(resource) {
+  return resource;
+}
+
+export { defineManagedResource };

package/dist/internal/fetch-port.d.ts

@@ -0,0 +1,2 @@
+export declare function isFetchBlockedPort(port: number): boolean;
+//# sourceMappingURL=fetch-port.d.ts.map

package/dist/internal/fetch-port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-port.d.ts","sourceRoot":"","sources":["../../src/internal/fetch-port.ts"],"names":[],"mappings":"AAaA,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD"}

package/dist/node.js

@@ -1,14 +1,16 @@
 import {
-  ShutdownOptionsSchema,
-  ShutdownResultSchema,
-  ShutdownStateSchema,
-  ShutdownStatusSchema,
   bindProcessSignals,
   bindRealtimeServer,
   createHandler,
-  createServerLifecycle,
   createSocketIOServer
-} from "./index-9zn9fb4e.js";
+} from "./index-0tszzfxp.js";
+import {
+  ShutdownOptionsSchema,
+  ShutdownResultSchema,
+  ShutdownStateSchema,
+  ShutdownStatusSchema,
+  createServerLifecycle
+} from "./index-dk6e56g0.js";
 import {
   createImplement,
   createImplementRegistry,
@@ -33,9 +35,99 @@ import {
 import"./index-6k1937bx.js";
 import"./index-y2rb7dwx.js";
 import"./index-smpbdg6k.js";
-import"./index-1bx83sw4.js";
 // src/server/node.ts
 import { serve } from "srvx/node";
+
+// src/internal/fetch-port.ts
+var FETCH_BLOCKED_PORTS = new Set([
+  1,
+  7,
+  9,
+  11,
+  13,
+  15,
+  17,
+  19,
+  20,
+  21,
+  22,
+  23,
+  25,
+  37,
+  42,
+  43,
+  53,
+  69,
+  77,
+  79,
+  87,
+  95,
+  101,
+  102,
+  103,
+  104,
+  109,
+  110,
+  111,
+  113,
+  115,
+  117,
+  119,
+  123,
+  135,
+  137,
+  139,
+  143,
+  161,
+  179,
+  389,
+  427,
+  465,
+  512,
+  513,
+  514,
+  515,
+  526,
+  530,
+  531,
+  532,
+  540,
+  548,
+  554,
+  556,
+  563,
+  587,
+  601,
+  636,
+  989,
+  990,
+  993,
+  995,
+  1719,
+  1720,
+  1723,
+  2049,
+  3659,
+  4045,
+  4190,
+  5060,
+  5061,
+  6000,
+  6566,
+  6665,
+  6666,
+  6667,
+  6668,
+  6669,
+  6679,
+  6697,
+  10080
+]);
+function isFetchBlockedPort(port) {
+  return FETCH_BLOCKED_PORTS.has(port);
+}
+
+// src/server/node.ts
 async function serveNode(config) {
   const { port = 3000, hostname, socket, wrapFetch, ...handlerConfig } = config;
   const handler = createHandler(handlerConfig);
@@ -101,14 +193,23 @@ async function serveNode(config) {
   const lifecycle = createServerLifecycle(() => adapter);
   const consumerFetch = wrapFetch ? wrapFetch(handler) : handler;
   const fetch = lifecycle.wrapFetch(consumerFetch);
-  runtime = serve({ port, hostname, fetch, gracefulShutdown: false });
-  await runtime.ready();
-  const candidate = runtime.node?.server;
-  if (!candidate || !("maxRequestsPerSocket" in candidate)) {
-    await runtime.close(true);
-    throw new Error("[stitchkit] serveNode: expected a node:http.Server for the managed lifecycle.");
+  for (;; ) {
+    runtime = serve({ port, hostname, fetch, gracefulShutdown: false });
+    await runtime.ready();
+    const candidate = runtime.node?.server;
+    if (!candidate || !("maxRequestsPerSocket" in candidate)) {
+      await runtime.close(true);
+      throw new Error("[stitchkit] serveNode: expected a node:http.Server for the managed lifecycle.");
+    }
+    const candidateUrl = runtime.url ?? `http://${hostname ?? "localhost"}:${port}`;
+    const candidatePort = Number(new URL(candidateUrl).port) || port;
+    if (port === 0 && isFetchBlockedPort(candidatePort)) {
+      await runtime.close(true);
+      continue;
+    }
+    nodeServer = candidate;
+    break;
   }
-  nodeServer = candidate;
   nodeServer.on("connection", (activeSocket) => {
     sockets.add(activeSocket);
     activeSocket.once("close", () => {

package/dist/observability/index.js

@@ -36,7 +36,6 @@ import {
 import {
   isRecord
 } from "../index-smpbdg6k.js";
-import"../index-1bx83sw4.js";
 
 // src/observability/audit.ts
 function toolErrorMessage(result) {

package/dist/remote.js

@@ -12,7 +12,6 @@ import"./index-y2rb7dwx.js";
 import {
   isRecord
 } from "./index-smpbdg6k.js";
-import"./index-1bx83sw4.js";
 
 // src/tools/remote.ts
 var HTTP_ONLY = Object.freeze(["HTTP"]);