stitchkit 0.53.2 → 0.55.0

package/dist/{index-pdv1mjjr.js → index-npye5kt7.js}

@@ -1,35 +1,44 @@
 import {
+  DEFAULT_PROCESS_SIGNALS,
+  RUNTIME_CONTEXT_RESERVED_KEYS,
   assertCorsConfig,
   corsHeaders,
-  corsPreflightResponse
-} from "./index-yydqk4fh.js";
+  corsPreflightResponse,
+  defaultSignalSource,
+  guardSignalCallback,
+  reportSignalError
+} from "./index-pzc32v75.js";
 import {
-  AppError,
-  badRequest,
   errorCode,
   extractIp,
   getClientInfo,
   getRequestContext,
-  isUnsafeKey,
   normalizeError,
   parseQueryParams,
   recordedErrorMessage,
   resolveSocketIp,
   resolveTraceId,
   runWithRequestContext,
-  safeJsonParse,
   setRequestEndpoint,
   setRequestError,
   validateDeclaredOutput,
   zodIssues
-} from "./index-173tvqcp.js";
+} from "./index-v4bbq3p4.js";
+import {
+  AppError,
+  badRequest,
+  isUnsafeKey,
+  safeJsonParse
+} from "./index-h60df7rj.js";
 import {
-  __require,
   isRecord,
   parseTrailingWildcard,
   resolveTraceContext,
   transportResult
-} from "./index-bmnhqtya.js";
+} from "./index-7eq9va6e.js";
+import {
+  __require
+} from "./index-1bx83sw4.js";
 
 // src/server/multipart.ts
 var DEFAULT_MAX_REQUEST_BYTES = 25 * 1024 * 1024;
@@ -496,19 +505,6 @@ async function readRequestText(req, maxBytes) {
 }
 
 // src/server/context.ts
-var RESERVED_KEYS = new Set([
-  "params",
-  "input",
-  "source",
-  "req",
-  "url",
-  "headers",
-  "rawBody",
-  "traceId",
-  "spanId",
-  "ipAddress",
-  "userAgent"
-]);
 function parseJsonBody(req, text) {
   if (text.trim() === "")
     return {};
@@ -524,7 +520,7 @@ function parseJsonBody(req, text) {
 function buildBaseContext(req, url, pathParams, traceId, clientIp) {
   const safePathParams = {};
   for (const [k, v] of Object.entries(pathParams)) {
-    if (!RESERVED_KEYS.has(k) && !isUnsafeKey(k))
+    if (!RUNTIME_CONTEXT_RESERVED_KEYS.has(k) && !isUnsafeKey(k))
       safePathParams[k] = v;
   }
   return {
@@ -534,6 +530,7 @@ function buildBaseContext(req, url, pathParams, traceId, clientIp) {
     req,
     url,
     headers: req.headers,
+    signal: req.signal,
     ...safePathParams,
     traceId,
     ...getClientInfo(req, clientIp)
@@ -581,6 +578,7 @@ function buildErrorContext(req, url, traceId, clientIp) {
     req,
     url,
     headers: req.headers,
+    signal: req.signal,
     traceId,
     ...getClientInfo(req, clientIp)
   };
@@ -1606,40 +1604,13 @@ function createServerLifecycle(getAdapter) {
 }
 
 // src/server/process-signals.ts
-var DEFAULT_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;
-  }
-};
 var bound = new WeakSet;
-function reportError(phase, error, onError) {
-  try {
-    onError?.(phase, error);
-  } catch {}
-}
-function guard(run, phase, onError) {
-  try {
-    run();
-  } catch (error) {
-    reportError(phase, error, onError);
-  }
-}
 function bindProcessSignals(handle, options = {}) {
   if (bound.has(handle)) {
     throw new Error("[stitchkit] bindProcessSignals: this server is already bound; close the first binding before creating another");
   }
   bound.add(handle);
-  const signals = [...new Set(options.signals ?? DEFAULT_SIGNALS)];
+  const signals = [...new Set(options.signals ?? DEFAULT_PROCESS_SIGNALS)];
   const source = options.signalSource ?? defaultSignalSource;
   const budgets = ShutdownOptionsSchema.omit({ signal: true }).parse(options.shutdown ?? {});
   const controller = new AbortController;
@@ -1680,7 +1651,7 @@ function bindProcessSignals(handle, options = {}) {
     try {
       await options.onShutdown?.(signal);
     } catch (error) {
-      reportError("prepare", error, options.onError);
+      reportSignalError("prepare", error, options.onError);
     }
     let result;
     try {
@@ -1688,7 +1659,7 @@ function bindProcessSignals(handle, options = {}) {
     } catch (error) {
       settled = true;
       rejectChain(error);
-      reportError("shutdown", error, options.onError);
+      reportSignalError("shutdown", error, options.onError);
       removeListeners();
       return;
     }
@@ -1697,7 +1668,7 @@ function bindProcessSignals(handle, options = {}) {
     try {
       await options.onComplete?.(result);
     } catch (error) {
-      reportError("complete", error, options.onError);
+      reportSignalError("complete", error, options.onError);
     } finally {
       removeListeners();
     }
@@ -1709,26 +1680,26 @@ function bindProcessSignals(handle, options = {}) {
       queueMicrotask(() => {
         sameTurnAsStart = false;
       });
-      run(signal).catch((error) => reportError("shutdown", error, options.onError));
+      run(signal).catch((error) => reportSignalError("shutdown", error, options.onError));
       return;
     }
     if (sameTurnAsStart)
       return;
     if (!settled && !controller.signal.aborted) {
       controller.abort();
-      guard(() => options.onRepeatedSignal?.(signal, "force"), "shutdown", options.onError);
+      guardSignalCallback(() => options.onRepeatedSignal?.(signal, "force"), "shutdown", options.onError);
       return;
     }
     removeListeners();
-    guard(() => options.onRepeatedSignal?.(signal, "escalate"), "shutdown", options.onError);
+    guardSignalCallback(() => options.onRepeatedSignal?.(signal, "escalate"), "shutdown", options.onError);
     let restored = false;
     try {
       restored = source.raiseDefault(signal);
     } catch (error) {
-      reportError("shutdown", error, options.onError);
+      reportSignalError("shutdown", error, options.onError);
     }
     if (!restored) {
-      guard(() => options.onEscalationBlocked?.(signal), "shutdown", options.onError);
+      guardSignalCallback(() => options.onEscalationBlocked?.(signal), "shutdown", options.onError);
     }
   };
   for (const signal of signals) {

package/dist/{index-yydqk4fh.js → index-pzc32v75.js}

@@ -1,12 +1,13 @@
 import {
+  isUnsafeKey,
   mergeMeta
-} from "./index-173tvqcp.js";
+} from "./index-h60df7rj.js";
 import {
   callRuntimeHandler,
   isRecord,
   transportResult,
   typedEntries
-} from "./index-bmnhqtya.js";
+} from "./index-7eq9va6e.js";
 
 // src/server/middleware/cors.ts
 var DEFAULT_CORS_ALLOW_HEADERS = "Content-Type, Authorization, X-Trace-Id, traceparent, tracestate";
@@ -246,4 +247,90 @@ function createImplementRegistry() {
   return (contracts, handlers) => transportResult(bindRegistry(contracts, handlers));
 }
 
-export { DEFAULT_CORS_ALLOW_HEADERS, DEFAULT_CORS_EXPOSE_HEADERS, assertCorsConfig, corsHeaders, corsPreflightResponse, defineMultipartStream, createMultipartStream, contractOnlyService, implement, createImplement, createScopedImplement, createScopedImplementRegistry, implementRegistry, createImplementRegistry };
+// 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"
+]);
+function contributionError(scope, reason) {
+  return new TypeError(`[stitchkit] auth: invalid context contribution for scope ${JSON.stringify(scope)}: ${reason}`);
+}
+function mergeContextContribution(ctx, 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;
+  }
+  Object.assign(ctx, prepared);
+}
+
+// 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, 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 };

package/dist/{index-e1es808r.js → index-qh4xevf5.js}

@@ -6,7 +6,7 @@ import {
   mapObject,
   parseTrailingWildcard,
   typedEntries
-} from "./index-bmnhqtya.js";
+} from "./index-7eq9va6e.js";
 
 // src/browser/cancellation.ts
 class RequestCancellationError extends Error {

package/dist/{index-gvha32jh.js → index-qx84bqzk.js}

@@ -1,9 +1,9 @@
 import {
   isUnsafeKey
-} from "./index-173tvqcp.js";
+} from "./index-h60df7rj.js";
 import {
   isRecord
-} from "./index-bmnhqtya.js";
+} from "./index-7eq9va6e.js";
 
 // src/observability/sanitize.ts
 var SENSITIVE_WORDS = new Set([

package/dist/{index-pfqjb5xy.js → index-rgd18hx3.js}

@@ -350,8 +350,26 @@ function createContractFactory(config) {
   };
   return { defineContract: explicit };
 }
-// src/contract/pagination.ts
+// src/contract/file-ref.ts
 import { z as z3 } from "zod";
+function isManagedFilePath(value) {
+  if (value.length === 0 || value.includes("\x00") || value.includes("\\"))
+    return false;
+  if (value.startsWith("/") || value.startsWith("//") || /^[A-Za-z]:/.test(value)) {
+    return false;
+  }
+  const parts = value.split("/");
+  return parts.every((part) => part.length > 0 && part !== "." && part !== "..");
+}
+var ManagedFilePathSchema = z3.string().refine(isManagedFilePath, "expected a canonical relative managed-file path");
+var ManagedFileRefSchema = z3.object({
+  path: ManagedFilePathSchema,
+  size: z3.number().int().nonnegative(),
+  mediaType: z3.string().min(1).optional(),
+  name: z3.string().min(1).optional()
+});
+// src/contract/pagination.ts
+import { z as z4 } from "zod";
 
 // src/internal/base64url.ts
 function bytesToBase64Url(bytes) {
@@ -371,9 +389,9 @@ function base64UrlToBytes(segment) {
 
 // src/contract/pagination.ts
 function paginatedSchema(itemSchema) {
-  return z3.object({
-    items: z3.array(itemSchema),
-    nextCursor: z3.string().nullable()
+  return z4.object({
+    items: z4.array(itemSchema),
+    nextCursor: z4.string().nullable()
   });
 }
 function toBase64Url(str) {
@@ -395,4 +413,4 @@ function decodeCursor(cursor, schema) {
     return null;
   }
 }
-export { parseTrailingWildcard, AppError, notFound, badRequest, unauthorized, forbidden, conflict, rateLimited, STITCH_ERROR_STATUS, isStitchErrorCode, appError, ALL_TRANSPORTS, defineContract, defineErrors, createContractFactory, paginatedSchema, encodeCursor, decodeCursor };
+export { parseTrailingWildcard, AppError, notFound, badRequest, unauthorized, forbidden, conflict, rateLimited, STITCH_ERROR_STATUS, isStitchErrorCode, appError, ALL_TRANSPORTS, defineContract, defineErrors, createContractFactory, ManagedFilePathSchema, ManagedFileRefSchema, paginatedSchema, encodeCursor, decodeCursor };

package/dist/index-sbdmyz75.js

@@ -0,0 +1,18 @@
+// src/internal/within-dir.ts
+import { realpath } from "node:fs/promises";
+import { sep } from "node:path";
+function isWithinDir(root, target) {
+  const base = root.endsWith(sep) ? root.slice(0, -sep.length) : root;
+  return target === root || target === base || target.startsWith(base + sep);
+}
+async function realPathWithinDir(root, target) {
+  const [realRoot, realTarget] = await Promise.all([
+    realpath(root).catch(() => null),
+    realpath(target).catch(() => null)
+  ]);
+  if (realRoot === null || realTarget === null)
+    return null;
+  return isWithinDir(realRoot, realTarget) ? realTarget : null;
+}
+
+export { isWithinDir, realPathWithinDir };

package/dist/{index-173tvqcp.js → index-v4bbq3p4.js}

@@ -1,119 +1,14 @@
+import {
+  AppError,
+  isUnsafeKey
+} from "./index-h60df7rj.js";
 import {
   isRecord,
   resolveTraceContext
-} from "./index-bmnhqtya.js";
-
-// src/contract/errors.ts
-var APP_ERROR_BRAND = Symbol.for("stitchkit.AppError");
-
-class AppError extends Error {
-  code;
-  status;
-  details;
-  hint;
-  traceId;
-  constructor(code, message, status = 500, details, hint, traceId) {
-    super(message ?? code);
-    this.code = code;
-    this.status = status;
-    this.details = details;
-    this.hint = hint;
-    this.traceId = traceId;
-    this.name = "AppError";
-    Object.defineProperty(this, APP_ERROR_BRAND, { value: true });
-  }
-  static is(err) {
-    return typeof err === "object" && err !== null && APP_ERROR_BRAND in err;
-  }
-  toJSON() {
-    return {
-      error: {
-        code: this.code,
-        message: this.message,
-        ...this.details && { details: this.details },
-        ...this.hint && { hint: this.hint }
-      }
-    };
-  }
-}
-function notFound(message = "Not found") {
-  throw new AppError("NOT_FOUND", message, 404);
-}
-function badRequest(message, details) {
-  throw new AppError("BAD_REQUEST", message, 400, details);
-}
-function unauthorized(message = "Unauthorized") {
-  throw new AppError("UNAUTHORIZED", message, 401);
-}
-function forbidden(message = "Forbidden") {
-  throw new AppError("FORBIDDEN", message, 403);
-}
-function conflict(message = "Conflict", details) {
-  throw new AppError("CONFLICT", message, 409, details);
-}
-function rateLimited(message = "Too many requests") {
-  throw new AppError("RATE_LIMITED", message, 429);
-}
-var STITCH_ERROR_STATUS = {
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  METHOD_NOT_ALLOWED: 405,
-  CONFLICT: 409,
-  RATE_LIMITED: 429,
-  VALIDATION_ERROR: 400,
-  REALTIME_CONTRACT_VIOLATION: 500,
-  INTERNAL_SERVER_ERROR: 500
-};
-function isStitchErrorCode(code) {
-  return Object.hasOwn(STITCH_ERROR_STATUS, code);
-}
-function appError(code, message, details) {
-  throw new AppError(code, message, isStitchErrorCode(code) ? STITCH_ERROR_STATUS[code] : 500, details);
-}
-
-// src/contract/define.ts
-import { z } from "zod";
-
-// src/internal/safe-json.ts
-function isUnsafeKey(key) {
-  return key === "__proto__";
-}
-function safeJsonParse(text) {
-  return JSON.parse(text, (key, value) => isUnsafeKey(key) ? undefined : value);
-}
-
-// src/contract/define.ts
-function mergeMeta(contractMeta, endpointMeta) {
-  if (!contractMeta)
-    return endpointMeta;
-  if (!endpointMeta)
-    return { ...contractMeta };
-  return { ...contractMeta, ...endpointMeta };
-}
-// src/contract/errors-factory.ts
-import { z as z2 } from "zod";
-// src/contract/pagination.ts
-import { z as z3 } from "zod";
+} from "./index-7eq9va6e.js";
 
-// src/internal/base64url.ts
-function bytesToBase64Url(bytes) {
-  let binary = "";
-  for (const byte of bytes)
-    binary += String.fromCharCode(byte);
-  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function base64UrlToBytes(segment) {
-  if (!/^[A-Za-z0-9_-]*$/.test(segment) || segment.length % 4 === 1) {
-    throw new Error("invalid base64url segment");
-  }
-  const b64 = segment.replace(/-/g, "+").replace(/_/g, "/");
-  const padded = b64.padEnd(Math.ceil(b64.length / 4) * 4, "=");
-  return Uint8Array.from(atob(padded), (c) => c.charCodeAt(0));
-}
 // src/internal/errors.ts
-import { z as z4 } from "zod";
+import { z } from "zod";
 function issuePath(path) {
   return path.length > 0 ? path.map(String).join(".") : "(root)";
 }
@@ -136,7 +31,7 @@ var MAX_DETAIL_ISSUES = 20;
 function errorCode(err) {
   if (AppError.is(err))
     return err.code;
-  if (err instanceof z4.ZodError)
+  if (err instanceof z.ZodError)
     return "VALIDATION_ERROR";
   return;
 }
@@ -156,7 +51,7 @@ function normalizeError(err) {
     }
     return err;
   }
-  if (err instanceof z4.ZodError) {
+  if (err instanceof z.ZodError) {
     return new AppError("VALIDATION_ERROR", formatZodError(err), 400, {
       issues: zodIssues(err).slice(0, MAX_DETAIL_ISSUES)
     });
@@ -322,4 +217,4 @@ function wrapInRequestContext(handler, options = {}) {
   };
 }
 
-export { isUnsafeKey, safeJsonParse, mergeMeta, AppError, notFound, badRequest, unauthorized, forbidden, conflict, rateLimited, STITCH_ERROR_STATUS, isStitchErrorCode, appError, bytesToBase64Url, base64UrlToBytes, formatZodError, zodIssues, errorCode, recordedErrorMessage, normalizeError, validateDeclaredOutput, generateTraceId, resolveTraceId, resolveSocketIp, extractIp, getClientInfo, parseQueryParams, runWithRequestContext, getRequestContext, getTraceId, getUserId, setRequestUser, setRequestEndpoint, setRequestDimensions, setRequestError, wrapInRequestContext };
+export { formatZodError, zodIssues, errorCode, recordedErrorMessage, normalizeError, validateDeclaredOutput, generateTraceId, resolveTraceId, resolveSocketIp, extractIp, getClientInfo, parseQueryParams, runWithRequestContext, getRequestContext, getTraceId, getUserId, setRequestUser, setRequestEndpoint, setRequestDimensions, setRequestError, wrapInRequestContext };