stitchkit 0.77.0 → 0.79.0

package/dist/{index-vbf2p6me.js → index-m9kzax52.js}

@@ -1,69 +1,15 @@
 import {
-  isUnsafeKey,
   mergeMeta
-} from "./index-vj3vvpaa.js";
+} from "./index-y01f4223.js";
+import {
+  isUnsafeKey
+} from "./index-kzfs85xp.js";
 import {
   callRuntimeHandler,
   isRecord,
   transportResult,
   typedEntries
-} from "./index-qyrqwr4c.js";
-
-// src/server/middleware/cors.ts
-var DEFAULT_CORS_ALLOW_HEADERS = "Content-Type, Authorization, X-Trace-Id, traceparent, tracestate";
-var DEFAULT_CORS_EXPOSE_HEADERS = "Content-Disposition, Content-Length, Content-Range, Accept-Ranges, ETag, Last-Modified, X-Request-Id";
-function assertCorsConfig(config) {
-  if (config.credentials && (config.origin === undefined || config.origin === "*")) {
-    throw new Error("[stitchkit] cors: `credentials: true` cannot be combined with a wildcard origin. " + "Set `origin` to an explicit string or list.");
-  }
-  if (config.origin === undefined) {
-    throw new Error("[stitchkit] cors: `origin` is required. Pass an explicit origin (or list), or '*' to deliberately allow every origin — omit `cors` entirely to emit no CORS headers.");
-  }
-  if (Array.isArray(config.origin) && config.origin.length === 0) {
-    throw new Error("[stitchkit] cors: `origin` cannot be an empty list. Pass explicit origins, or '*' to deliberately allow every origin.");
-  }
-}
-function resolveOrigin(config, requestOrigin) {
-  if (config.origin === undefined)
-    return;
-  if (config.origin === "*") {
-    return "*";
-  }
-  if (Array.isArray(config.origin)) {
-    if (!requestOrigin)
-      return;
-    const lower = requestOrigin.toLowerCase();
-    return config.origin.some((o) => o.toLowerCase() === lower) ? requestOrigin : undefined;
-  }
-  return config.origin;
-}
-function corsHeaders(config, requestOrigin) {
-  const allowOrigin = resolveOrigin(config, requestOrigin);
-  const headers = {
-    "Access-Control-Allow-Methods": config.methods ?? "GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS",
-    "Access-Control-Allow-Headers": config.headers ?? DEFAULT_CORS_ALLOW_HEADERS
-  };
-  const expose = Array.isArray(config.exposeHeaders) ? config.exposeHeaders.join(", ") : config.exposeHeaders ?? DEFAULT_CORS_EXPOSE_HEADERS;
-  if (expose !== "") {
-    headers["Access-Control-Expose-Headers"] = expose;
-  }
-  if (allowOrigin !== undefined) {
-    headers["Access-Control-Allow-Origin"] = allowOrigin;
-    if (config.credentials) {
-      headers["Access-Control-Allow-Credentials"] = "true";
-    }
-  }
-  if (Array.isArray(config.origin)) {
-    headers.Vary = "Origin";
-  }
-  return headers;
-}
-function corsPreflightResponse(config, req) {
-  return new Response(null, {
-    status: 204,
-    headers: corsHeaders(config, req.headers.get("origin"))
-  });
-}
+} from "./index-77fekveh.js";
 
 // src/server/implement.ts
 function isStreamingImplementation(value) {
@@ -248,6 +194,91 @@ function createImplementRegistry() {
   return (contracts, handlers) => transportResult(bindRegistry(contracts, handlers));
 }
 
+// src/server/middleware/cors.ts
+var DEFAULT_CORS_ALLOW_HEADERS = "Content-Type, Authorization, X-Trace-Id, traceparent, tracestate";
+var DEFAULT_CORS_EXPOSE_HEADERS = "Content-Disposition, Content-Length, Content-Range, Accept-Ranges, ETag, Last-Modified, X-Request-Id";
+function assertCorsConfig(config) {
+  if (config.credentials && (config.origin === undefined || config.origin === "*")) {
+    throw new Error("[stitchkit] cors: `credentials: true` cannot be combined with a wildcard origin. " + "Set `origin` to an explicit string or list.");
+  }
+  if (config.origin === undefined) {
+    throw new Error("[stitchkit] cors: `origin` is required. Pass an explicit origin (or list), or '*' to deliberately allow every origin — omit `cors` entirely to emit no CORS headers.");
+  }
+  if (Array.isArray(config.origin) && config.origin.length === 0) {
+    throw new Error("[stitchkit] cors: `origin` cannot be an empty list. Pass explicit origins, or '*' to deliberately allow every origin.");
+  }
+}
+function resolveOrigin(config, requestOrigin) {
+  if (config.origin === undefined)
+    return;
+  if (config.origin === "*") {
+    return "*";
+  }
+  if (Array.isArray(config.origin)) {
+    if (!requestOrigin)
+      return;
+    const lower = requestOrigin.toLowerCase();
+    return config.origin.some((o) => o.toLowerCase() === lower) ? requestOrigin : undefined;
+  }
+  return config.origin;
+}
+function corsHeaders(config, requestOrigin) {
+  const allowOrigin = resolveOrigin(config, requestOrigin);
+  const headers = {
+    "Access-Control-Allow-Methods": config.methods ?? "GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": config.headers ?? DEFAULT_CORS_ALLOW_HEADERS
+  };
+  const expose = Array.isArray(config.exposeHeaders) ? config.exposeHeaders.join(", ") : config.exposeHeaders ?? DEFAULT_CORS_EXPOSE_HEADERS;
+  if (expose !== "") {
+    headers["Access-Control-Expose-Headers"] = expose;
+  }
+  if (allowOrigin !== undefined) {
+    headers["Access-Control-Allow-Origin"] = allowOrigin;
+    if (config.credentials) {
+      headers["Access-Control-Allow-Credentials"] = "true";
+    }
+  }
+  if (Array.isArray(config.origin)) {
+    headers.Vary = "Origin";
+  }
+  return headers;
+}
+function corsPreflightResponse(config, req) {
+  return new Response(null, {
+    status: 204,
+    headers: corsHeaders(config, req.headers.get("origin"))
+  });
+}
+
+// src/server/process-signal-common.ts
+var DEFAULT_PROCESS_SIGNALS = ["SIGINT", "SIGTERM"];
+var defaultSignalSource = {
+  on: (signal, handler) => {
+    process.on(signal, handler);
+  },
+  off: (signal, handler) => {
+    process.off(signal, handler);
+  },
+  raiseDefault: (signal) => {
+    if (process.listenerCount(signal) > 0)
+      return false;
+    process.kill(process.pid, signal);
+    return true;
+  }
+};
+function reportSignalError(phase, error, onError) {
+  try {
+    onError?.(phase, error);
+  } catch {}
+}
+function guardSignalCallback(run, phase, onError) {
+  try {
+    run();
+  } catch (error) {
+    reportSignalError(phase, error, onError);
+  }
+}
+
 // src/server/context-contribution.ts
 var RUNTIME_CONTEXT_RESERVED_KEYS = new Set([
   "params",
@@ -342,33 +373,4 @@ function mergeContextContribution(ctx, value, scope) {
   Object.assign(ctx, prepareContextContribution(value, scope));
 }
 
-// src/server/process-signal-common.ts
-var DEFAULT_PROCESS_SIGNALS = ["SIGINT", "SIGTERM"];
-var defaultSignalSource = {
-  on: (signal, handler) => {
-    process.on(signal, handler);
-  },
-  off: (signal, handler) => {
-    process.off(signal, handler);
-  },
-  raiseDefault: (signal) => {
-    if (process.listenerCount(signal) > 0)
-      return false;
-    process.kill(process.pid, signal);
-    return true;
-  }
-};
-function reportSignalError(phase, error, onError) {
-  try {
-    onError?.(phase, error);
-  } catch {}
-}
-function guardSignalCallback(run, phase, onError) {
-  try {
-    run();
-  } catch (error) {
-    reportSignalError(phase, error, onError);
-  }
-}
-
-export { RUNTIME_CONTEXT_RESERVED_KEYS, contextContributionDelta, prepareContextContribution, mergeContextContribution, DEFAULT_CORS_ALLOW_HEADERS, DEFAULT_CORS_EXPOSE_HEADERS, assertCorsConfig, corsHeaders, corsPreflightResponse, defineMultipartStream, createMultipartStream, contractOnlyService, implement, createImplement, createScopedImplement, createScopedImplementRegistry, implementRegistry, createImplementRegistry, DEFAULT_PROCESS_SIGNALS, defaultSignalSource, reportSignalError, guardSignalCallback };
+export { defineMultipartStream, createMultipartStream, contractOnlyService, implement, createImplement, createScopedImplement, createScopedImplementRegistry, implementRegistry, createImplementRegistry, DEFAULT_CORS_ALLOW_HEADERS, DEFAULT_CORS_EXPOSE_HEADERS, assertCorsConfig, corsHeaders, corsPreflightResponse, DEFAULT_PROCESS_SIGNALS, defaultSignalSource, reportSignalError, guardSignalCallback, RUNTIME_CONTEXT_RESERVED_KEYS, contextContributionDelta, prepareContextContribution, mergeContextContribution };

package/dist/{index-22by16v6.js → index-mgtxfe6b.js}

@@ -3,7 +3,7 @@ import {
 } from "./index-cby4ar3v.js";
 import {
   isRecord
-} from "./index-qyrqwr4c.js";
+} from "./index-77fekveh.js";
 
 // src/tools/portable-formats.ts
 var PORTABLE_JSON_SCHEMA_FORMATS = new Set([

package/dist/index-p7hgdyhb.js

@@ -0,0 +1,22 @@
+// src/realtime/contract.ts
+import { z } from "zod";
+function defineRealtimeContract(contract) {
+  return contract;
+}
+var RealtimeRejectDirectionSchema = z.enum([
+  "client-inbound",
+  "client-outbound",
+  "server-inbound",
+  "server-outbound"
+]);
+var RealtimeRejectPhaseSchema = z.enum(["arguments", "acknowledgement"]);
+var RealtimeRejectReasonSchema = z.enum([
+  "unknown-event",
+  "invalid-arguments",
+  "invalid-acknowledgement-value",
+  "missing-acknowledgement",
+  "rejected-by-peer"
+]);
+var RealtimeRejectFaultSchema = z.enum(["peer", "local"]);
+
+export { defineRealtimeContract, RealtimeRejectDirectionSchema, RealtimeRejectPhaseSchema, RealtimeRejectReasonSchema, RealtimeRejectFaultSchema };

package/dist/index-t0z5p5w6.js

@@ -0,0 +1,318 @@
+import {
+  RealtimeRequestInvalidAcknowledgementError,
+  RealtimeRequestRejectedError
+} from "./index-2qzskm8h.js";
+import {
+  zodIssues
+} from "./index-fxz0v7vg.js";
+import {
+  AppError
+} from "./index-0w9abg87.js";
+
+// 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/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/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 parseRealtimeRequestArguments(registry, event, direction, args) {
+  const definition = eventDefinition(registry, event, direction);
+  const parsed = definition.args.safeParse(args);
+  if (!parsed.success) {
+    throw realtimeContractViolation({
+      event,
+      direction,
+      phase: "arguments",
+      reason: "invalid-arguments",
+      fault: "local",
+      cause: parsed.error
+    }).error;
+  }
+  if (!definition.ack) {
+    throw realtimeContractViolation({
+      event,
+      direction,
+      phase: "acknowledgement",
+      reason: "missing-acknowledgement",
+      fault: "local"
+    }).error;
+  }
+  return parsed.data;
+}
+function parseRealtimeRequestAcknowledgement(schema, event, direction, value, hook, logger) {
+  const refusal = asRealtimeRejection(value);
+  if (refusal) {
+    reportRejected(realtimeContractViolation({
+      event,
+      direction,
+      phase: "arguments",
+      reason: "rejected-by-peer",
+      fault: "local"
+    }), hook, logger);
+    throw new RealtimeRequestRejectedError(event, refusal.reason, refusal.message, refusal.issues);
+  }
+  const parsed = schema.safeParse(value);
+  if (parsed.success)
+    return parsed.data;
+  const rejected = realtimeContractViolation({
+    event,
+    direction,
+    phase: "acknowledgement",
+    reason: "invalid-acknowledgement-value",
+    fault: "peer",
+    cause: parsed.error
+  });
+  reportRejected(rejected, hook, logger);
+  throw new RealtimeRequestInvalidAcknowledgementError(event, rejected.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;
+    }
+  };
+}
+
+export { isModuleNotFound, REALTIME_REJECTION_KEY, asRealtimeRejection, parseRealtimeRequestArguments, parseRealtimeRequestAcknowledgement, createValidatedRealtimeSocket };

package/dist/{index-s2rchahr.js → index-vwp69871.js}

@@ -1,36 +1,38 @@
+import {
+  isWithinDir
+} from "./index-sbdmyz75.js";
 import {
   collectToolSurface
-} from "./index-k2zczx1g.js";
+} from "./index-2rwwmr7v.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-7qy2ex0m.js";
+} from "./index-5mtc969c.js";
 import {
-  coerceJsonArgs,
   toolResultFromError
-} from "./index-s4c8wy8m.js";
-import {
-  isWithinDir
-} from "./index-sbdmyz75.js";
+} from "./index-758zx2ha.js";
 import {
   assertUniqueToolName,
   buildToolPresentationSchema,
   objectShapeKeys
-} from "./index-22by16v6.js";
+} from "./index-mgtxfe6b.js";
 import {
   jsonSchemaFields
 } from "./index-cby4ar3v.js";
+import {
+  coerceJsonArgs
+} from "./index-7zbps32p.js";
 import {
   formatZodError,
   validateDeclaredOutput
-} from "./index-nt1mp8km.js";
+} from "./index-fxz0v7vg.js";
 import {
   isUnsafeKey,
   safeJsonParse
-} from "./index-vj3vvpaa.js";
+} from "./index-kzfs85xp.js";
 import {
   isRecord
-} from "./index-qyrqwr4c.js";
+} from "./index-77fekveh.js";
 
 // src/tools/cli-args.ts
 import { z } from "zod";