stitchkit 0.77.0 → 0.79.0

package/dist/{index-nt1mp8km.js → index-fxz0v7vg.js}

@@ -3,7 +3,89 @@ import {
 } from "./index-0w9abg87.js";
 import {
   isRecord
-} from "./index-qyrqwr4c.js";
+} from "./index-77fekveh.js";
+
+// src/internal/random-hex.ts
+function randomHex(bytes) {
+  const arr = new Uint8Array(bytes);
+  crypto.getRandomValues(arr);
+  let hex = "";
+  for (const byte of arr)
+    hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+
+// src/observability/trace.ts
+var TRACEPARENT_RE = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(.*)$/i;
+function createTraceContext() {
+  return { traceId: randomHex(16), spanId: randomHex(8) };
+}
+function parseTraceparent(header) {
+  if (!header)
+    return null;
+  const match = TRACEPARENT_RE.exec(header.trim());
+  if (!match?.[1] || !match[2] || !match[3] || !match[4] || match[5] === undefined)
+    return null;
+  const version = match[1].toLowerCase();
+  if (version === "ff")
+    return null;
+  const suffix = match[5];
+  if (version === "00" ? suffix !== "" : suffix !== "" && !/^(?:-[0-9a-f]{2,})+$/i.test(suffix)) {
+    return null;
+  }
+  const traceId = match[2].toLowerCase();
+  const parentSpanId = match[3].toLowerCase();
+  const traceFlags = match[4].toLowerCase();
+  if (/^0+$/.test(traceId) || /^0+$/.test(parentSpanId))
+    return null;
+  return { traceId, spanId: randomHex(8), parentSpanId, traceFlags };
+}
+function formatTraceparent(ctx) {
+  return `00-${ctx.traceId}-${ctx.spanId}-${ctx.traceFlags ?? "01"}`;
+}
+function resolveTraceContext(req) {
+  return parseTraceparent(req.headers.get("traceparent")) ?? createTraceContext();
+}
+function childSpan(parent) {
+  return {
+    traceId: parent.traceId,
+    spanId: randomHex(8),
+    parentSpanId: parent.spanId,
+    ...parent.tracestate !== undefined && { tracestate: parent.tracestate },
+    ...parent.baggage !== undefined && { baggage: parent.baggage },
+    ...parent.traceFlags !== undefined && { traceFlags: parent.traceFlags }
+  };
+}
+var encoder = new TextEncoder;
+function boundedPropagationValue(value, maxBytes, maxMembers) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  if (!trimmed || encoder.encode(trimmed).byteLength > maxBytes)
+    return;
+  for (const character of trimmed) {
+    const code = character.charCodeAt(0);
+    if (code <= 31 || code === 127)
+      return;
+  }
+  const members = trimmed.split(",");
+  if (members.length > maxMembers || members.some((member) => !member.trim())) {
+    return;
+  }
+  return trimmed;
+}
+function resolvePropagationContext(metadata, fallback) {
+  const traceparent = metadata?.traceparent;
+  const parsed = typeof traceparent === "string" ? parseTraceparent(traceparent) : null;
+  const trace = traceparent === undefined ? fallback ?? createTraceContext() : parsed ?? createTraceContext();
+  const tracestate = parsed ? boundedPropagationValue(metadata?.tracestate, 512, 32) : undefined;
+  const baggage = boundedPropagationValue(metadata?.baggage, 8192, 180);
+  return {
+    ...trace,
+    ...tracestate !== undefined && { tracestate },
+    ...baggage !== undefined && { baggage }
+  };
+}
 
 // src/internal/errors.ts
 import { z } from "zod";
@@ -109,86 +191,4 @@ function validateDeclaredOutput(schema, data, onStripped) {
   return validateHandlerOutput(schema, data, onStripped);
 }
 
-// src/internal/random-hex.ts
-function randomHex(bytes) {
-  const arr = new Uint8Array(bytes);
-  crypto.getRandomValues(arr);
-  let hex = "";
-  for (const byte of arr)
-    hex += byte.toString(16).padStart(2, "0");
-  return hex;
-}
-
-// src/observability/trace.ts
-var TRACEPARENT_RE = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(.*)$/i;
-function createTraceContext() {
-  return { traceId: randomHex(16), spanId: randomHex(8) };
-}
-function parseTraceparent(header) {
-  if (!header)
-    return null;
-  const match = TRACEPARENT_RE.exec(header.trim());
-  if (!match?.[1] || !match[2] || !match[3] || !match[4] || match[5] === undefined)
-    return null;
-  const version = match[1].toLowerCase();
-  if (version === "ff")
-    return null;
-  const suffix = match[5];
-  if (version === "00" ? suffix !== "" : suffix !== "" && !/^(?:-[0-9a-f]{2,})+$/i.test(suffix)) {
-    return null;
-  }
-  const traceId = match[2].toLowerCase();
-  const parentSpanId = match[3].toLowerCase();
-  const traceFlags = match[4].toLowerCase();
-  if (/^0+$/.test(traceId) || /^0+$/.test(parentSpanId))
-    return null;
-  return { traceId, spanId: randomHex(8), parentSpanId, traceFlags };
-}
-function formatTraceparent(ctx) {
-  return `00-${ctx.traceId}-${ctx.spanId}-${ctx.traceFlags ?? "01"}`;
-}
-function resolveTraceContext(req) {
-  return parseTraceparent(req.headers.get("traceparent")) ?? createTraceContext();
-}
-function childSpan(parent) {
-  return {
-    traceId: parent.traceId,
-    spanId: randomHex(8),
-    parentSpanId: parent.spanId,
-    ...parent.tracestate !== undefined && { tracestate: parent.tracestate },
-    ...parent.baggage !== undefined && { baggage: parent.baggage },
-    ...parent.traceFlags !== undefined && { traceFlags: parent.traceFlags }
-  };
-}
-var encoder = new TextEncoder;
-function boundedPropagationValue(value, maxBytes, maxMembers) {
-  if (typeof value !== "string")
-    return;
-  const trimmed = value.trim();
-  if (!trimmed || encoder.encode(trimmed).byteLength > maxBytes)
-    return;
-  for (const character of trimmed) {
-    const code = character.charCodeAt(0);
-    if (code <= 31 || code === 127)
-      return;
-  }
-  const members = trimmed.split(",");
-  if (members.length > maxMembers || members.some((member) => !member.trim())) {
-    return;
-  }
-  return trimmed;
-}
-function resolvePropagationContext(metadata, fallback) {
-  const traceparent = metadata?.traceparent;
-  const parsed = typeof traceparent === "string" ? parseTraceparent(traceparent) : null;
-  const trace = traceparent === undefined ? fallback ?? createTraceContext() : parsed ?? createTraceContext();
-  const tracestate = parsed ? boundedPropagationValue(metadata?.tracestate, 512, 32) : undefined;
-  const baggage = boundedPropagationValue(metadata?.baggage, 8192, 180);
-  return {
-    ...trace,
-    ...tracestate !== undefined && { tracestate },
-    ...baggage !== undefined && { baggage }
-  };
-}
-
-export { formatZodError, zodIssues, errorCode, recordedErrorMessage, normalizeError, validateDeclaredOutput, createTraceContext, parseTraceparent, formatTraceparent, resolveTraceContext, childSpan, resolvePropagationContext };
+export { randomHex, createTraceContext, parseTraceparent, formatTraceparent, resolveTraceContext, childSpan, resolvePropagationContext, formatZodError, zodIssues, errorCode, recordedErrorMessage, normalizeError, validateDeclaredOutput };

package/dist/index-h4pj6fta.js

@@ -0,0 +1,87 @@
+// src/browser/resumable.ts
+import { z } from "zod";
+var PositiveSafeIntegerSchema = z.number().int().positive().safe();
+var BackoffPolicySchema = z.object({
+  minDelayMs: PositiveSafeIntegerSchema,
+  maxDelayMs: PositiveSafeIntegerSchema,
+  jitter: z.number().min(0).max(1)
+}).strict().readonly().refine((policy) => policy.maxDelayMs >= policy.minDelayMs, {
+  message: "maxDelayMs must be at least minDelayMs"
+});
+function createBackoff(policy, random = Math.random) {
+  const { minDelayMs, maxDelayMs, jitter } = BackoffPolicySchema.parse(policy);
+  let attempt = 0;
+  return {
+    next() {
+      const exponential = Math.min(maxDelayMs, minDelayMs * 2 ** attempt);
+      attempt += 1;
+      const spread = exponential * jitter * random();
+      return Math.max(1, Math.round(exponential - spread));
+    },
+    reset() {
+      attempt = 0;
+    }
+  };
+}
+var DEFAULT_RETRY = { minDelayMs: 100, maxDelayMs: 30000, jitter: 0.5 };
+
+class ResumableAbortError extends Error {
+  constructor() {
+    super("Resumable iterator was aborted");
+    this.name = "ResumableAbortError";
+  }
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      reject(new ResumableAbortError);
+    }
+    if (signal?.aborted) {
+      clearTimeout(timer);
+      reject(new ResumableAbortError);
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function* resumableIterator(config) {
+  const backoff = createBackoff(config.retry ?? DEFAULT_RETRY, config.random);
+  let cursor;
+  let attempt = 0;
+  for (;; ) {
+    if (config.signal?.aborted)
+      return;
+    try {
+      const source = await config.open(cursor);
+      for await (const item of source) {
+        if (config.signal?.aborted)
+          return;
+        attempt = 0;
+        backoff.reset();
+        cursor = config.advance(item, cursor);
+        yield item;
+        if (config.isTerminal?.(item))
+          return;
+      }
+      throw new Error("Resumable source ended without a terminal item");
+    } catch (error) {
+      if (config.signal?.aborted || error instanceof ResumableAbortError)
+        return;
+      attempt += 1;
+      const delayMs = backoff.next();
+      config.onAttempt?.({ number: attempt, delayMs, error });
+      try {
+        await sleep(delayMs, config.signal);
+      } catch {
+        return;
+      }
+    }
+  }
+}
+
+export { BackoffPolicySchema, createBackoff, resumableIterator };

package/dist/{index-1rxswfbv.js → index-hb5pf3s4.js}

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

package/dist/{index-t8qyvrvg.js → index-k9ay6v6d.js}

@@ -1,3 +1,13 @@
+import {
+  ShutdownOptionsSchema,
+  isStreamCancellation,
+  ownHttpStream,
+  settleStreamCleanup
+} from "./index-3z73fh2c.js";
+import {
+  createValidatedRealtimeSocket,
+  isModuleNotFound
+} from "./index-t0z5p5w6.js";
 import {
   DEFAULT_PROCESS_SIGNALS,
   RUNTIME_CONTEXT_RESERVED_KEYS,
@@ -7,7 +17,7 @@ import {
   defaultSignalSource,
   guardSignalCallback,
   reportSignalError
-} from "./index-vbf2p6me.js";
+} from "./index-m9kzax52.js";
 import {
   extractIp,
   getClientInfo,
@@ -18,36 +28,31 @@ import {
   runWithRequestContext,
   setRequestEndpoint,
   setRequestError
-} from "./index-nemjkxjp.js";
-import {
-  ShutdownOptionsSchema,
-  isStreamCancellation,
-  ownHttpStream,
-  settleStreamCleanup
-} from "./index-3z73fh2c.js";
+} from "./index-dwf1f2ap.js";
 import {
   errorCode,
   normalizeError,
   recordedErrorMessage,
   resolveTraceContext,
-  validateDeclaredOutput,
-  zodIssues
-} from "./index-nt1mp8km.js";
+  validateDeclaredOutput
+} from "./index-fxz0v7vg.js";
 import {
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
-  isUnsafeKey,
   joinRoutePath,
-  parseTrailingWildcard,
-  safeJsonParse
-} from "./index-vj3vvpaa.js";
+  parseTrailingWildcard
+} from "./index-y01f4223.js";
 import {
   AppError,
   badRequest
 } from "./index-0w9abg87.js";
+import {
+  isUnsafeKey,
+  safeJsonParse
+} from "./index-kzfs85xp.js";
 import {
   isRecord,
   transportResult
-} from "./index-qyrqwr4c.js";
+} from "./index-77fekveh.js";
 
 // src/server/multipart.ts
 var DEFAULT_MAX_REQUEST_BYTES = 25 * 1024 * 1024;
@@ -2049,253 +2054,6 @@ function bindProcessSignals(handle, options = {}) {
   return { promise, close };
 }
 
-// src/realtime/rejected-frame.ts
-var REALTIME_REJECTION_KEY = "@stitchkit/realtime-rejected";
-var MAX_REJECTION_ISSUES = 20;
-function realtimeRejectionEnvelope(report) {
-  return { [REALTIME_REJECTION_KEY]: report };
-}
-function asRealtimeRejection(value) {
-  if (typeof value !== "object" || value === null)
-    return null;
-  const report = Reflect.get(value, REALTIME_REJECTION_KEY);
-  if (typeof report !== "object" || report === null)
-    return null;
-  const event = Reflect.get(report, "event");
-  const reason = Reflect.get(report, "reason");
-  const message = Reflect.get(report, "message");
-  if (typeof event !== "string" || typeof reason !== "string" || typeof message !== "string") {
-    return null;
-  }
-  if (reason.length === 0)
-    return null;
-  const issues = parseIssues(Reflect.get(report, "issues"));
-  return { event, reason, message, ...issues !== undefined && { issues } };
-}
-function parseIssues(value) {
-  if (!Array.isArray(value))
-    return;
-  const issues = [];
-  for (const entry of value.slice(0, MAX_REJECTION_ISSUES)) {
-    if (typeof entry !== "object" || entry === null)
-      continue;
-    const path = Reflect.get(entry, "path");
-    const code = Reflect.get(entry, "code");
-    const message = Reflect.get(entry, "message");
-    if (typeof path === "string" && typeof code === "string" && typeof message === "string") {
-      issues.push({ path, code, message });
-    }
-  }
-  return issues.length > 0 ? issues : undefined;
-}
-
-// src/realtime/rejection.ts
-import { z } from "zod";
-function realtimeContractViolation(options) {
-  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,
-    direction: options.direction,
-    phase: options.phase,
-    reason: options.reason,
-    fault: options.fault,
-    ...issues !== undefined && { issues }
-  });
-  if (options.cause !== undefined)
-    error.cause = options.cause;
-  return { ...options, error };
-}
-
-// src/realtime/socket.ts
-function method(target, name) {
-  const value = Reflect.get(target, name);
-  if (typeof value !== "function") {
-    throw new Error(`Realtime target does not implement ${name}()`);
-  }
-  return (...args) => Reflect.apply(value, target, args);
-}
-function splitWireArguments(definition, args) {
-  const trailing = args.at(-1);
-  const replyTo = typeof trailing === "function" ? (...callbackArgs) => Reflect.apply(trailing, undefined, callbackArgs) : undefined;
-  if (!definition.ack || !replyTo)
-    return { values: args, ...replyTo && { replyTo } };
-  return { values: args.slice(0, -1), acknowledgement: replyTo, replyTo };
-}
-function eventDefinition(registry, event, direction) {
-  const definition = registry[event];
-  if (!definition) {
-    throw realtimeContractViolation({
-      event,
-      direction,
-      phase: "arguments",
-      reason: "unknown-event",
-      fault: "local"
-    }).error;
-  }
-  return definition;
-}
-function reportRejected(rejected, hook, logger) {
-  if (!hook) {
-    if (logger) {
-      logger.warn(rejected.error.message, rejected.error.details);
-      return;
-    }
-    console.warn(`[stitchkit] rejected realtime ${rejected.direction} event "${rejected.event}" (${rejected.phase})`, rejected.error);
-    return;
-  }
-  Promise.resolve(hook(rejected)).catch((error) => {
-    console.error("[stitchkit] realtime rejection hook failed", error);
-  });
-}
-function answerWithRejection(acknowledgement, report, logger) {
-  if (!acknowledgement)
-    return;
-  try {
-    acknowledgement(realtimeRejectionEnvelope(report));
-  } catch (error) {
-    const message = "[stitchkit] could not answer a rejected realtime frame";
-    if (logger)
-      logger.warn(message, { error });
-    else
-      console.warn(message, error);
-  }
-}
-function createValidatedRealtimeSocket({
-  target,
-  inbound,
-  outbound,
-  inboundDirection,
-  outboundDirection,
-  onRejected,
-  logger,
-  subscribe
-}) {
-  const emitTarget = method(target, "emit");
-  return {
-    on: (event, handler) => {
-      const definition = eventDefinition(inbound, event, inboundDirection);
-      const wrapped = (...wireArgs) => {
-        const { values, acknowledgement, replyTo } = splitWireArguments(definition, wireArgs);
-        const parsed = definition.args.safeParse(values);
-        if (!parsed.success) {
-          const rejected = realtimeContractViolation({
-            event,
-            direction: inboundDirection,
-            phase: "arguments",
-            reason: "invalid-arguments",
-            fault: "peer",
-            cause: parsed.error
-          });
-          reportRejected(rejected, onRejected, logger);
-          answerWithRejection(replyTo, {
-            event,
-            reason: "invalid-arguments",
-            message: rejected.error.message,
-            issues: zodIssues(parsed.error).slice(0, MAX_REJECTION_ISSUES)
-          }, logger);
-          return;
-        }
-        if (definition.ack && !acknowledgement) {
-          reportRejected(realtimeContractViolation({
-            event,
-            direction: inboundDirection,
-            phase: "acknowledgement",
-            reason: "missing-acknowledgement",
-            fault: "peer"
-          }), onRejected, logger);
-          return;
-        }
-        const applicationArgs = [...parsed.data];
-        if (definition.ack) {
-          applicationArgs.push((value) => {
-            const ack = definition.ack?.safeParse(value);
-            if (!ack?.success) {
-              if (ack) {
-                reportRejected(realtimeContractViolation({
-                  event,
-                  direction: outboundDirection,
-                  phase: "acknowledgement",
-                  reason: "invalid-acknowledgement-value",
-                  fault: "local",
-                  cause: ack.error
-                }), onRejected, logger);
-              }
-              return;
-            }
-            acknowledgement?.(ack.data);
-          });
-        }
-        Reflect.apply(handler, undefined, applicationArgs);
-      };
-      if (subscribe)
-        return subscribe(event, wrapped);
-      const onTarget = method(target, "on");
-      const offTarget = method(target, "off");
-      onTarget(event, wrapped);
-      return () => {
-        offTarget(event, wrapped);
-      };
-    },
-    emit: (event, ...args) => {
-      const definition = eventDefinition(outbound, event, outboundDirection);
-      const { values, acknowledgement } = splitWireArguments(definition, args);
-      const parsed = definition.args.safeParse(values);
-      if (!parsed.success) {
-        throw realtimeContractViolation({
-          event,
-          direction: outboundDirection,
-          phase: "arguments",
-          reason: "invalid-arguments",
-          fault: "local",
-          cause: parsed.error
-        }).error;
-      }
-      if (definition.ack && !acknowledgement) {
-        throw realtimeContractViolation({
-          event,
-          direction: outboundDirection,
-          phase: "acknowledgement",
-          reason: "missing-acknowledgement",
-          fault: "local"
-        }).error;
-      }
-      const wireArgs = [...parsed.data];
-      if (definition.ack && acknowledgement) {
-        wireArgs.push((value) => {
-          const refusal = asRealtimeRejection(value);
-          if (refusal) {
-            reportRejected(realtimeContractViolation({
-              event,
-              direction: outboundDirection,
-              phase: "arguments",
-              reason: "rejected-by-peer",
-              fault: "local"
-            }), onRejected, logger);
-            return;
-          }
-          const ack = definition.ack?.safeParse(value);
-          if (!ack?.success) {
-            if (ack) {
-              reportRejected(realtimeContractViolation({
-                event,
-                direction: inboundDirection,
-                phase: "acknowledgement",
-                reason: "invalid-acknowledgement-value",
-                fault: "peer",
-                cause: ack.error
-              }), onRejected, logger);
-            }
-            return;
-          }
-          acknowledgement(ack.data);
-        });
-      }
-      return emitTarget(event, ...wireArgs) !== false;
-    }
-  };
-}
-
 // src/server/realtime.ts
 function bindRealtimeServer(contract, handle, options = {}) {
   const outbound = (target) => createValidatedRealtimeSocket({
@@ -2394,15 +2152,6 @@ function composeWebSocketHandlers(lanes, config) {
   };
 }
 
-// src/internal/optional-peer.ts
-function isModuleNotFound(error) {
-  if (typeof error !== "object" || error === null)
-    return false;
-  const code = "code" in error ? error.code : undefined;
-  const message = "message" in error && typeof error.message === "string" ? error.message : "";
-  return code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND" || message.includes("Cannot find module") || message.includes("Cannot find package");
-}
-
 // src/server/socket-io.ts
 var SOCKET_IO_SERVER = "socket.io";
 var SOCKET_IO_BUN_ENGINE = "@socket.io/bun-engine";

package/dist/index-kzfs85xp.js

@@ -0,0 +1,9 @@
+// src/internal/safe-json.ts
+function isUnsafeKey(key) {
+  return key === "__proto__";
+}
+function safeJsonParse(text) {
+  return JSON.parse(text, (key, value) => isUnsafeKey(key) ? undefined : value);
+}
+
+export { isUnsafeKey, safeJsonParse };