stitchkit 0.93.0 → 0.94.1

package/dist/entrypoints/live.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `stitchkit/live` — declarations for the things that change while a caller is
+ * watching: announcements and watched reads.
+ *
+ * Browser-safe and evolving. Browser-safe because both halves are declarations
+ * plus a client, and a client that cannot run in a browser is not a client.
+ * Evolving because the shape here is being found with its first consumers — the
+ * entrypoint says so rather than leaving a reader to discover it in a minor.
+ *
+ * What lives here is deliberately small: this entrypoint owns no transport. The
+ * wire is the Socket.IO realtime contract from `stitchkit`, the in-process
+ * delivery is `createEventBus` from `stitchkit/server`, and the server halves of
+ * a watched read live in `stitchkit/application`. → ADR 0150.
+ */
+export { defineEvents, type EventDeliveryMode, type EventPayloads, type EventsConfig, type EventsDeclaration, type EventTopicDeclaration, type EventTopicRegistry, type EventTopicsOfMode, type PolicyDecision, toRealtimeContract, type UndecidedOutcome, type WireTopic, } from '../live/events.js';
+export { createWatchClient, type RealtimeClientLike, type TypedWatchClient, type WatchClientConfig, type WatchHandle, type WatchInboundEvents, type WatchListeners, type WatchTransport, watchTransport, } from '../live/watch-client.js';
+export { WATCH_CLOSE, WATCH_OPEN, WATCH_STATE, WATCH_VALUE, type WatchHave, WatchHaveSchema, type WatchKey, WatchKeySchema, type WatchStateFrame, WatchStateSchema, type WatchValueFrame, WatchValueSchema, watchContract, watchKeyString, } from '../live/watch-contract.js';
+export { apply as applyWatchDelta, deltaWins as watchDeltaWins, diff as watchDiff, type WatchArrayOp, WatchArrayOpSchema, type WatchDelta, WatchDeltaSchema, } from '../live/watch-delta.js';
+//# sourceMappingURL=live.d.ts.map

package/dist/entrypoints/live.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live.d.ts","sourceRoot":"","sources":["../../src/entrypoints/live.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EACL,YAAY,EACZ,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,SAAS,GACf,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,iBAAiB,EACjB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,cAAc,GACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,WAAW,EACX,UAAU,EACV,WAAW,EACX,WAAW,EACX,KAAK,SAAS,EACd,eAAe,EACf,KAAK,QAAQ,EACb,cAAc,EACd,KAAK,eAAe,EACpB,gBAAgB,EAChB,KAAK,eAAe,EACpB,gBAAgB,EAChB,aAAa,EACb,cAAc,GACf,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,KAAK,IAAI,eAAe,EACxB,SAAS,IAAI,cAAc,EAC3B,IAAI,IAAI,SAAS,EACjB,KAAK,YAAY,EACjB,kBAAkB,EAClB,KAAK,UAAU,EACf,gBAAgB,GACjB,MAAM,qBAAqB,CAAC"}

package/dist/entrypoints/live.js

@@ -0,0 +1,302 @@
+import {
+  WATCH_CLOSE,
+  WATCH_OPEN,
+  WATCH_STATE,
+  WATCH_VALUE,
+  WatchArrayOpSchema,
+  WatchDeltaSchema,
+  WatchHaveSchema,
+  WatchKeySchema,
+  WatchStateSchema,
+  WatchValueSchema,
+  apply,
+  deltaWins,
+  diff,
+  watchContract,
+  watchKeyString
+} from "../index-wdkt63w3.js";
+import"../index-1j8pm5t0.js";
+import"../index-d9pk3td4.js";
+import {
+  argumentsDigest
+} from "../index-0b1ess5e.js";
+import"../index-k5hsfc3j.js";
+import"../index-hffjpmq9.js";
+
+// src/live/events.ts
+import { z } from "zod";
+function assertName(kind, value) {
+  if (value.length === 0) {
+    throw new Error(`[stitchkit] defineEvents: ${kind} name cannot be empty.`);
+  }
+  if (/\s/.test(value)) {
+    throw new Error(`[stitchkit] defineEvents: ${kind} name "${value}" cannot contain whitespace.`);
+  }
+}
+function defineEvents(config, topics) {
+  const prefix = config.prefix;
+  if (prefix !== undefined)
+    assertName("prefix", prefix);
+  const declared = {};
+  for (const [name, topic] of Object.entries(topics)) {
+    assertName("topic", name);
+    if (topic.mode === "emit") {
+      if (topic.whenAllDefer !== undefined) {
+        throw new Error(`[stitchkit] defineEvents: topic "${name}" declares whenAllDefer, which only a 'decision' topic has. Its mode is 'emit'.`);
+      }
+      if (topic.listenerTimeoutMs !== undefined) {
+        throw new Error(`[stitchkit] defineEvents: topic "${name}" declares listenerTimeoutMs, but mode 'emit' never waits for a listener.`);
+      }
+    } else {
+      if (topic.listenerTimeoutMs === undefined) {
+        throw new Error(`[stitchkit] defineEvents: topic "${name}" has mode '${topic.mode}', which waits for listeners, so it must declare listenerTimeoutMs.`);
+      }
+      if (!Number.isFinite(topic.listenerTimeoutMs) || topic.listenerTimeoutMs <= 0) {
+        throw new Error(`[stitchkit] defineEvents: topic "${name}" declares listenerTimeoutMs ${String(topic.listenerTimeoutMs)}; it must be finite and greater than zero.`);
+      }
+      if (topic.mode === "decision" && topic.whenAllDefer === undefined) {
+        throw new Error(`[stitchkit] defineEvents: topic "${name}" has mode 'decision', so it must declare whenAllDefer: 'allow' or 'deny' — the outcome when every listener defers. There is no default, because a default would decide it silently.`);
+      }
+      if (topic.mode === "serial" && topic.whenAllDefer !== undefined) {
+        throw new Error(`[stitchkit] defineEvents: topic "${name}" declares whenAllDefer, which only a 'decision' topic has. Its mode is 'serial'.`);
+      }
+    }
+    declared[prefix === undefined ? name : `${prefix}.${name}`] = topic;
+  }
+  return { prefix, topics: declared };
+}
+function toRealtimeContract(declaration) {
+  const serverToClient = {};
+  for (const [topic, definition] of Object.entries(declaration.topics)) {
+    const schema = definition.schema;
+    serverToClient[topic] = { args: z.tuple([schema]) };
+  }
+  return { serverToClient, clientToServer: {} };
+}
+// src/live/watch-client.ts
+function watchTransport(client) {
+  return client;
+}
+function publishState(entry, state) {
+  entry.state = state;
+  for (const listener of [...entry.listeners])
+    listener.state?.(state);
+}
+async function openWatch(config, openTimeoutMs, entry) {
+  if (entry.opened)
+    return;
+  entry.opened = true;
+  try {
+    const have = entry.hasValue && entry.fingerprint !== undefined ? { revision: entry.revision, fingerprint: entry.fingerprint } : undefined;
+    const acknowledgement = await config.transport.request(WATCH_OPEN, { key: entry.key, args: entry.args, ...have !== undefined && { have } }, { timeoutMs: openTimeoutMs });
+    if (!acknowledgement.accepted) {
+      const reason = acknowledgement.reason ?? "the server refused this watch";
+      config.onRefused?.(entry.key, reason);
+      publishState(entry, {
+        key: entry.key,
+        phase: "unavailable",
+        reason: "source-unavailable",
+        message: reason
+      });
+    }
+  } catch (error) {
+    entry.opened = false;
+    const code = typeof error === "object" && error !== null && "code" in error ? String(Reflect.get(error, "code")) : undefined;
+    publishState(entry, {
+      key: entry.key,
+      phase: "unavailable",
+      reason: "source-unavailable",
+      ...code !== undefined && { code },
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function applyWatchFrame(entry, frame) {
+  if (frame.kind === "unchanged") {
+    if (!entry.hasValue) {
+      return {
+        kind: "resync",
+        message: "the server confirmed a value this client does not hold"
+      };
+    }
+    entry.revision = frame.revision;
+    entry.fingerprint = frame.fingerprint;
+    return { kind: "confirmed" };
+  }
+  if (entry.hasValue && frame.revision <= entry.revision)
+    return { kind: "stale" };
+  let value;
+  if (frame.kind === "full") {
+    value = frame.value;
+  } else {
+    if (!entry.hasValue || entry.revision !== frame.base) {
+      return {
+        kind: "resync",
+        message: `a difference against revision ${frame.base} arrived while holding ${entry.hasValue ? String(entry.revision) : "nothing"}`
+      };
+    }
+    try {
+      value = apply(entry.value, frame.delta);
+    } catch (error) {
+      return {
+        kind: "resync",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+    if (argumentsDigest({ value }) !== frame.fingerprint) {
+      return {
+        kind: "resync",
+        message: "the rebuilt value did not match the fingerprint the server sent"
+      };
+    }
+  }
+  entry.revision = frame.revision;
+  entry.value = value;
+  entry.fingerprint = frame.fingerprint;
+  entry.hasValue = true;
+  return { kind: "value", value };
+}
+function createWatchClient(contract, config) {
+  const entries = new Map;
+  const holdMs = config.holdMs ?? 0;
+  const openTimeoutMs = config.openTimeoutMs ?? 1e4;
+  const service = contract.meta.prefix;
+  function resynchronise(entry, message) {
+    entry.hasValue = false;
+    entry.value = undefined;
+    entry.revision = 0;
+    entry.fingerprint = undefined;
+    entry.opened = false;
+    publishState(entry, { key: entry.key, phase: "resync-required", message });
+    config.transport.emit(WATCH_CLOSE, { key: entry.key });
+    openWatch(config, openTimeoutMs, entry);
+  }
+  config.transport.on(WATCH_VALUE, (frame) => {
+    const entry = entries.get(watchKeyString(frame.key));
+    if (!entry)
+      return;
+    const outcome = applyWatchFrame(entry, frame);
+    if (outcome.kind === "resync") {
+      resynchronise(entry, outcome.message);
+      return;
+    }
+    if (outcome.kind !== "value")
+      return;
+    for (const listener of [...entry.listeners])
+      listener.value(outcome.value);
+  });
+  config.transport.on(WATCH_STATE, (frame) => {
+    const entry = entries.get(watchKeyString(frame.key));
+    if (!entry)
+      return;
+    publishState(entry, frame);
+  });
+  config.transport.onConnectionChange((connected, reason) => {
+    if (!connected) {
+      for (const entry of entries.values()) {
+        entry.opened = false;
+        publishState(entry, {
+          key: entry.key,
+          phase: "unavailable",
+          reason: "source-unavailable",
+          ...reason !== undefined && { message: reason }
+        });
+      }
+      return;
+    }
+    for (const entry of entries.values()) {
+      if (entry.listeners.size === 0)
+        continue;
+      publishState(entry, { key: entry.key, phase: "opening" });
+      openWatch(config, openTimeoutMs, entry);
+    }
+  });
+  function entryFor(key, args) {
+    const id = watchKeyString(key);
+    const existing = entries.get(id);
+    if (existing) {
+      clearTimeout(existing.release);
+      existing.release = undefined;
+      return existing;
+    }
+    const entry = {
+      key,
+      args,
+      listeners: new Set,
+      revision: 0,
+      hasValue: false,
+      opened: false,
+      state: { key, phase: "opening" }
+    };
+    entries.set(id, entry);
+    return entry;
+  }
+  function releaseEntry(entry) {
+    if (entry.listeners.size > 0)
+      return;
+    const drop = () => {
+      if (entry.listeners.size > 0)
+        return;
+      entries.delete(watchKeyString(entry.key));
+      config.transport.emit(WATCH_CLOSE, { key: entry.key });
+    };
+    if (holdMs === 0) {
+      drop();
+      return;
+    }
+    entry.release = setTimeout(drop, holdMs);
+    entry.release.unref?.();
+  }
+  function handleFor(action, args) {
+    const mine = new Set;
+    const entry = entryFor({ service, action, digest: argumentsDigest(args) }, args);
+    return {
+      subscribe(listeners) {
+        const registered = listeners;
+        mine.add(registered);
+        entry.listeners.add(registered);
+        if (entry.hasValue)
+          registered.value(entry.value);
+        registered.state?.(entry.state);
+        openWatch(config, openTimeoutMs, entry);
+        return () => {
+          mine.delete(registered);
+          entry.listeners.delete(registered);
+          releaseEntry(entry);
+        };
+      },
+      close() {
+        for (const listener of mine)
+          entry.listeners.delete(listener);
+        mine.clear();
+        releaseEntry(entry);
+      }
+    };
+  }
+  const client = {};
+  for (const action of Object.keys(contract.endpoints)) {
+    client[action] = (args = {}) => handleFor(action, args);
+  }
+  return client;
+}
+export {
+  watchTransport,
+  watchKeyString,
+  diff as watchDiff,
+  deltaWins as watchDeltaWins,
+  watchContract,
+  toRealtimeContract,
+  defineEvents,
+  createWatchClient,
+  apply as applyWatchDelta,
+  WatchValueSchema,
+  WatchStateSchema,
+  WatchKeySchema,
+  WatchHaveSchema,
+  WatchDeltaSchema,
+  WatchArrayOpSchema,
+  WATCH_VALUE,
+  WATCH_STATE,
+  WATCH_OPEN,
+  WATCH_CLOSE
+};

package/dist/entrypoints/node.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `stitchkit/node` — the Node entrypoint. Everything a Node app needs without
+ * touching the Bun-named `createServer`: the Fetch-clean `createHandler`, the
+ * srvx-backed `serveNode`, `implement`, the error helpers and (lazily-loaded,
+ * Node-safe) `createSocketIOServer`.
+ */
+export { createHandler } from '../server/create.js';
+export { createImplement, createMultipartStream, createScopedImplement, implement, type MultipartStreamConfig, type StreamScope, } from '../server/implement.js';
+export { createImplementRegistry, createScopedImplementRegistry, type ExactRegistryHandlers, type ExactScopedRegistryHandlers, type ImplementationRegistry, implementRegistry, type KeyedServices, type RegistryHandlers, type ScopedImplementationRegistry, type ScopedRegistryHandlers, } from '../server/implement-registry.js';
+export type { LogFormat } from '../server/logger.js';
+export { type NodeRuntimeServer, type NodeServerConfig, type NodeServerHandle, type NodeSocketLifecycle, serveNode, } from '../server/node.js';
+export { bindProcessSignals, type ProcessSignalName, type ProcessSignalsBinding, type ProcessSignalsErrorPhase, type ProcessSignalsOptions, type ShutdownTarget, type SignalSource, } from '../server/process-signals.js';
+export { bindRealtimeServer, type RealtimeServer, type RealtimeServerConnection, type RealtimeServerHandle, } from '../server/realtime.js';
+export { type ManagedServerHandle, type ShutdownOptions, ShutdownOptionsSchema, type ShutdownResult, ShutdownResultSchema, type ShutdownState, ShutdownStateSchema, type ShutdownStatus, ShutdownStatusSchema, } from '../server/shutdown.js';
+export { createNodeSocketIOServer as createSocketIOServer, type NodeSocketIOServerHandle as SocketIOServerHandle, type SocketIOHandshakeConfig, type SocketIOPeerLoaders, type SocketIORequestPolicy, type SocketIOServerConfig, } from '../server/socket-io-node.js';
+export type { EffectiveScope, FetchComposition, FetchHandler, HandlerConfig, LoggingConfig, LogOutcome, RawRoute, RawRouteContext, ScopeContexts, ScopedHandlers, ServiceDef, } from '../server/types.js';
+export { createUnixClientTransport, type UnixClientDeliveryState, type UnixClientTransport, type UnixClientTransportConfig, UnixClientTransportError, type UnixClientTransportErrorCode, type UnixResponseBodyMode, } from '../server/unix-client.js';
+export { AppError, appError, badRequest, conflict, forbidden, notFound, rateLimited, unauthorized, } from './contract.js';
+//# sourceMappingURL=node.d.ts.map

package/dist/entrypoints/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/entrypoints/node.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,SAAS,EACT,KAAK,qBAAqB,EAC1B,KAAK,WAAW,GACjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,uBAAuB,EACvB,6BAA6B,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,sBAAsB,EAC3B,iBAAiB,EACjB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,4BAA4B,EACjC,KAAK,sBAAsB,GAC5B,MAAM,8BAA8B,CAAC;AACtC,YAAY,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,SAAS,GACV,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,kBAAkB,EAClB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,YAAY,GAClB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,kBAAkB,EAClB,KAAK,cAAc,EACnB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,GAC1B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,qBAAqB,EACrB,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,aAAa,EAClB,mBAAmB,EACnB,KAAK,cAAc,EACnB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,wBAAwB,IAAI,oBAAoB,EAChD,KAAK,wBAAwB,IAAI,oBAAoB,EACrD,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,GAC1B,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,aAAa,EACb,UAAU,EACV,QAAQ,EACR,eAAe,EACf,aAAa,EACb,cAAc,EACd,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,yBAAyB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,wBAAwB,EACxB,KAAK,4BAA4B,EACjC,KAAK,oBAAoB,GAC1B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,WAAW,EACX,YAAY,GACb,MAAM,YAAY,CAAC"}

package/dist/entrypoints/node.js

@@ -0,0 +1,308 @@
+import {
+  UnixClientTransportError,
+  bindProcessSignals,
+  bindRealtimeServer,
+  createHandler,
+  createImplementRegistry,
+  createScopedImplementRegistry,
+  createSocketIOServer,
+  createUnixClientTransport,
+  implementRegistry
+} from "../index-p3vsv1fb.js";
+import"../index-y91ry9h2.js";
+import {
+  ShutdownOptionsSchema,
+  ShutdownResultSchema,
+  ShutdownStateSchema,
+  ShutdownStatusSchema,
+  createServerLifecycle
+} from "../index-3z73fh2c.js";
+import"../index-ndddxtyx.js";
+import"../index-dce5wxcq.js";
+import"../index-7p1f0vp2.js";
+import"../index-wqgjfstn.js";
+import {
+  createImplement,
+  createMultipartStream,
+  createScopedImplement,
+  implement
+} from "../index-2gxzjvyr.js";
+import"../index-2bxbyab0.js";
+import"../index-rxfy4cq7.js";
+import"../index-k30h66yd.js";
+import"../index-4gcnakhx.js";
+import"../index-6k1937bx.js";
+import"../index-zfrhfn82.js";
+import"../index-35mh5bhj.js";
+import"../index-zcgf3gqf.js";
+import"../index-znfs20ss.js";
+import"../index-p5r7qpdd.js";
+import {
+  AppError,
+  appError,
+  badRequest,
+  conflict,
+  forbidden,
+  notFound,
+  rateLimited,
+  unauthorized
+} from "../index-2vtcmrj9.js";
+import"../index-kzfs85xp.js";
+import"../index-hffjpmq9.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);
+  let runtime;
+  let nodeServer;
+  const sockets = new Set;
+  const upgradedSockets = new Set;
+  const responses = new Set;
+  const socketDrainWaiters = new Set;
+  const resolveSocketDrain = () => {
+    if (sockets.size !== 0)
+      return;
+    for (const resolve of socketDrainWaiters)
+      resolve();
+    socketDrainWaiters.clear();
+  };
+  const waitForSocketDrain = () => {
+    if (sockets.size === 0)
+      return Promise.resolve();
+    return new Promise((resolve) => socketDrainWaiters.add(resolve));
+  };
+  const waitForUpgradedSocketDrain = () => {
+    if (upgradedSockets.size === 0)
+      return Promise.resolve();
+    return Promise.all([...upgradedSockets].map((activeSocket) => new Promise((resolve) => {
+      if (activeSocket.closed)
+        resolve();
+      else
+        activeSocket.once("close", () => resolve());
+    }))).then(() => {
+      return;
+    });
+  };
+  const requireRuntime = () => {
+    if (!runtime)
+      throw new Error("[stitchkit] Node server lifecycle started before srvx");
+    return runtime;
+  };
+  const requireNodeServer = () => {
+    if (!nodeServer)
+      throw new Error("[stitchkit] Node HTTP server is unavailable");
+    return nodeServer;
+  };
+  const adapter = {
+    beginShutdown: () => socket?.beginShutdown(),
+    pendingRequests: () => responses.size,
+    pendingWebSockets: () => upgradedSockets.size,
+    closeRealtime: () => socket?.close() ?? Promise.resolve(),
+    async terminateRealtime() {
+      const count = upgradedSockets.size;
+      const physicalClose = waitForUpgradedSocketDrain();
+      for (const activeSocket of [...upgradedSockets])
+        activeSocket.destroy();
+      await physicalClose;
+      return count;
+    },
+    async stopGracefully() {
+      const runtimeClose = socket ? Promise.resolve() : requireRuntime().close(false);
+      requireNodeServer().closeIdleConnections?.();
+      await runtimeClose;
+      await waitForSocketDrain();
+    },
+    async forceStop() {
+      const activeServer = requireNodeServer();
+      const logicalClose = socket?.close();
+      const physicalClosures = [...sockets].map((activeSocket) => new Promise((resolve) => {
+        if (activeSocket.closed)
+          resolve();
+        else
+          activeSocket.once("close", () => resolve());
+      }));
+      activeServer.closeAllConnections?.();
+      for (const activeSocket of sockets)
+        activeSocket.destroy();
+      if (logicalClose)
+        await logicalClose;
+      else
+        await requireRuntime().close(true);
+      await Promise.all(physicalClosures);
+      responses.clear();
+    }
+  };
+  const lifecycle = createServerLifecycle(() => adapter);
+  const consumerFetch = wrapFetch ? wrapFetch(handler) : handler;
+  const fetch = lifecycle.wrapFetch(consumerFetch);
+  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.on("connection", (activeSocket) => {
+    sockets.add(activeSocket);
+    activeSocket.once("close", () => {
+      sockets.delete(activeSocket);
+      upgradedSockets.delete(activeSocket);
+      resolveSocketDrain();
+    });
+  });
+  nodeServer.on("upgrade", (request) => upgradedSockets.add(request.socket));
+  nodeServer.prependListener("request", (_request, response) => {
+    responses.add(response);
+    const complete = () => responses.delete(response);
+    response.once("finish", complete);
+    response.once("close", complete);
+  });
+  socket?.attach(nodeServer);
+  const listenUrl = runtime.url ?? `http://${hostname ?? "localhost"}:${port}`;
+  const resolvedPort = Number(new URL(listenUrl).port) || port;
+  const resolvedHost = hostname ?? "localhost";
+  const server = runtime;
+  return {
+    url: `http://${resolvedHost}:${resolvedPort}`,
+    port: resolvedPort,
+    runtime: server,
+    get status() {
+      return lifecycle.status;
+    },
+    shutdown: lifecycle.shutdown
+  };
+}
+// src/server/socket-io-node.ts
+async function createNodeSocketIOServer(config) {
+  return createSocketIOServer(config);
+}
+export {
+  unauthorized,
+  serveNode,
+  rateLimited,
+  notFound,
+  implementRegistry,
+  implement,
+  forbidden,
+  createUnixClientTransport,
+  createNodeSocketIOServer as createSocketIOServer,
+  createScopedImplementRegistry,
+  createScopedImplement,
+  createMultipartStream,
+  createImplementRegistry,
+  createImplement,
+  createHandler,
+  conflict,
+  bindRealtimeServer,
+  bindProcessSignals,
+  badRequest,
+  appError,
+  UnixClientTransportError,
+  ShutdownStatusSchema,
+  ShutdownStateSchema,
+  ShutdownResultSchema,
+  ShutdownOptionsSchema,
+  AppError
+};

package/dist/entrypoints/oauth.d.ts

@@ -0,0 +1,2 @@
+export * from '../oauth/authorization-code.js';
+//# sourceMappingURL=oauth.d.ts.map

package/dist/entrypoints/oauth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../src/entrypoints/oauth.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}