stitchkit 0.93.0 → 0.94.0

package/dist/{index-wc4x00bn.js → index-qwhynv6x.js}

@@ -1,6 +1,6 @@
 import {
   isRecord
-} from "./index-77fekveh.js";
+} from "./index-hffjpmq9.js";
 
 // src/application/diagnostic-journal-contract.ts
 import { z } from "zod";

package/dist/index-r7nmqpsg.js

@@ -0,0 +1,154 @@
+import {
+  base64UrlToBytes,
+  bytesToBase64Url
+} from "./index-rxfy4cq7.js";
+import {
+  defineContract
+} from "./index-gyr48nzg.js";
+import {
+  AppError,
+  STITCH_ERROR_STATUS,
+  isStitchErrorCode
+} from "./index-2vtcmrj9.js";
+import {
+  mapObjectTypeBoundary,
+  transportResult,
+  typedEntries
+} from "./index-hffjpmq9.js";
+// src/contract/errors-factory.ts
+import { z } from "zod";
+function isErrorDetailsSchema(value) {
+  return value instanceof z.ZodObject || value instanceof z.ZodOptional && value.unwrap() instanceof z.ZodObject;
+}
+function validateDefinition(code, definition) {
+  if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
+    throw new Error(`[stitchkit] Error "${code}" must declare an integer HTTP status from 400 to 599`);
+  }
+  if (definition.details !== undefined && !isErrorDetailsSchema(definition.details)) {
+    throw new Error(`[stitchkit] Error "${code}" details must be a Zod object or optional Zod object`);
+  }
+  if (definition.message !== undefined && (typeof definition.message !== "string" || definition.message.trim() === "")) {
+    throw new Error(`[stitchkit] Error "${code}" message must be a non-empty string`);
+  }
+}
+function defineErrors(source, mapping) {
+  const definitions = mapObjectTypeBoundary(source, (code, definition) => {
+    const name = String(code);
+    validateDefinition(name, definition);
+    return Object.freeze({ ...definition });
+  });
+  Object.freeze(definitions);
+  const errors = mapObjectTypeBoundary(definitions, (code, definition) => {
+    const name = String(code);
+    return (options = {}) => {
+      const message = options.message ?? definition.message;
+      if (definition.details === undefined) {
+        if ("details" in options) {
+          throw new Error(`[stitchkit] Error "${name}" does not declare details`);
+        }
+        return new AppError(name, message, definition.status, undefined, options.hint, undefined, definition.retryable);
+      }
+      const details = definition.details.parse(options.details);
+      return new AppError(name, message, definition.status, details, options.hint, undefined, definition.retryable);
+    };
+  });
+  Object.freeze(errors);
+  const codes = mapObjectTypeBoundary(definitions, (code) => String(code));
+  Object.freeze(codes);
+  const known = new Set(Object.keys(definitions));
+  for (const [code, target] of Object.entries(mapping?.map ?? {})) {
+    if (!isStitchErrorCode(code)) {
+      throw new Error(`[stitchkit] Error vocabulary contains unknown framework code "${code}"`);
+    }
+    if (typeof target !== "string" || !known.has(target)) {
+      throw new Error(`[stitchkit] Error vocabulary maps "${code}" to undeclared code "${String(target)}"`);
+    }
+    const status = STITCH_ERROR_STATUS[code];
+    if (definitions[target]?.status !== status) {
+      throw new Error(`[stitchkit] Error vocabulary maps "${code}" (${status}) to "${target}", declared with status ${String(definitions[target]?.status)}`);
+    }
+  }
+  for (const [statusText, target] of Object.entries(mapping?.fallback ?? {})) {
+    const status = Number(statusText);
+    if (!Number.isInteger(status) || status < 400 || status > 599) {
+      throw new Error(`[stitchkit] Error vocabulary fallback status "${statusText}" must be an integer from 400 to 599`);
+    }
+    if (typeof target !== "string" || !known.has(target)) {
+      throw new Error(`[stitchkit] Error vocabulary fallback ${status} names undeclared code "${String(target)}"`);
+    }
+    if (definitions[target]?.status !== status) {
+      throw new Error(`[stitchkit] Error vocabulary fallback ${status} must name a code with status ${status}`);
+    }
+  }
+  if (mapping?.exhaustive === true) {
+    for (const code of Object.keys(STITCH_ERROR_STATUS)) {
+      if (!Object.hasOwn(mapping.map, code)) {
+        throw new Error(`[stitchkit] Exhaustive error vocabulary is missing "${code}"`);
+      }
+    }
+  }
+  const codeMap = {};
+  for (const [stitchCode, status] of typedEntries(STITCH_ERROR_STATUS)) {
+    const code = mapping?.map?.[stitchCode] ?? mapping?.fallback?.[status];
+    if (code === undefined)
+      continue;
+    if (!known.has(code)) {
+      throw new Error(`[stitchkit] Error vocabulary maps "${stitchCode}" to undeclared code "${code}"`);
+    }
+    codeMap[stitchCode] = code;
+  }
+  Object.freeze(codeMap);
+  const vocabularyCodeMap = transportResult(codeMap);
+  return Object.freeze({
+    errors,
+    codes,
+    definitions,
+    isCode: (code) => known.has(code),
+    codeMap: vocabularyCodeMap
+  });
+}
+// src/contract/factory.ts
+function createContractFactory(config) {
+  const scoped = (meta, endpoints) => {
+    const validated = defineContract({ prefix: meta.prefix }, endpoints);
+    return {
+      endpoints: validated.endpoints,
+      meta: { ...meta, prefix: meta.prefix, scope: meta.scope }
+    };
+  };
+  if (config?.toolExposure !== "explicit")
+    return { defineContract: scoped };
+  const explicit = (meta, endpoints) => {
+    const materialized = mapObjectTypeBoundary(endpoints, (_key, endpoint) => endpoint.expose ? endpoint : { ...endpoint, expose: ["HTTP"] });
+    return scoped(meta, materialized);
+  };
+  return { defineContract: explicit };
+}
+// src/contract/pagination.ts
+import { z as z2 } from "zod";
+function paginatedSchema(itemSchema) {
+  return z2.object({
+    items: z2.array(itemSchema),
+    nextCursor: z2.string().nullable()
+  });
+}
+function toBase64Url(str) {
+  return bytesToBase64Url(new TextEncoder().encode(str));
+}
+function fromBase64Url(value) {
+  return new TextDecoder().decode(base64UrlToBytes(value));
+}
+function encodeCursor(value) {
+  return toBase64Url(JSON.stringify(value));
+}
+function decodeCursor(cursor, schema) {
+  if (!cursor)
+    return null;
+  try {
+    const parsed = schema.safeParse(JSON.parse(fromBase64Url(cursor)));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+export { defineErrors, createContractFactory, paginatedSchema, encodeCursor, decodeCursor };

package/dist/{index-bx75zwt7.js → index-rewkc2hj.js}

@@ -1,13 +1,13 @@
 import {
   collectTools,
   createToolRunner
-} from "./index-mzvgxp0n.js";
+} from "./index-2cr1cqhn.js";
 import {
   toolErrorFromResult
-} from "./index-yn8remb1.js";
+} from "./index-j05z5gn4.js";
 import {
   assertUniqueToolName
-} from "./index-h9etkkyk.js";
+} from "./index-dydjcp8z.js";
 import {
   AppError
 } from "./index-2vtcmrj9.js";
@@ -42,7 +42,8 @@ function createToolInvoker(services, config) {
       lifecycle: options.lifecycle,
       extend: config.extend,
       coerceJsonArgs: config.coerceJsonArgs,
-      onOutputStrip: options.onOutputStrip
+      onOutputStrip: options.onOutputStrip,
+      toolSurface: config.toolSurface ?? false
     });
     return runTool(operation(name), args);
   };

package/dist/{index-9f8ztey6.js → index-sees8yf8.js}

@@ -4,10 +4,10 @@ import {
 import {
   assertDrainBound,
   withinBound
-} from "./index-wnfk50r0.js";
+} from "./index-h6eeys1v.js";
 import {
   createBoundedChannel
-} from "./index-7gnkny4z.js";
+} from "./index-d9pk3td4.js";
 
 // src/application/latest-sink.ts
 import { z } from "zod";

package/dist/{index-vjpvjqpn.js → index-v38qyerb.js}

@@ -1,6 +1,6 @@
 import {
   projectRuntimeTool
-} from "./index-h9etkkyk.js";
+} from "./index-dydjcp8z.js";
 
 // src/tools/runtime-tool.ts
 function defineRuntimeTool(definition) {
@@ -82,5 +82,19 @@ function runtimeToolMountable(definition, assertName = true) {
     shouldExtend: false
   };
 }
+function executableAgentRuntimeTools(tools) {
+  for (const tool of tools) {
+    if (typeof tool.handler !== "function") {
+      throw new TypeError(`Runtime tool "${tool.name}" must provide a handler`);
+    }
+    if (tool.present?.agent !== undefined && typeof tool.present.agent !== "function") {
+      throw new TypeError(`Runtime tool "${tool.name}" Agent presenter must be a function`);
+    }
+    if (tool.present?.agent !== undefined && tool.output === undefined) {
+      throw new TypeError(`Runtime tool "${tool.name}" Agent presenter requires an output schema`);
+    }
+  }
+  return tools;
+}
 
-export { defineRuntimeTool, createRuntimeToolFactory, runtimeToolMountable };
+export { defineRuntimeTool, createRuntimeToolFactory, runtimeToolMountable, executableAgentRuntimeTools };

package/dist/{index-2c2bjw3s.js → index-vcvkq30w.js}

@@ -1,12 +1,12 @@
 import {
   contractToolMountable
-} from "./index-mzvgxp0n.js";
+} from "./index-2cr1cqhn.js";
 import {
   runtimeToolMountable
-} from "./index-vjpvjqpn.js";
+} from "./index-v38qyerb.js";
 import {
   projectToolSurface
-} from "./index-h9etkkyk.js";
+} from "./index-dydjcp8z.js";
 
 // src/tools/surface.ts
 function collectToolSurface({

package/dist/index-wqgjfstn.js

@@ -0,0 +1,18 @@
+// src/contract/stream.ts
+import { z } from "zod";
+var DEFAULT_CONTRACT_STREAM_FRAME_BYTES = 256 * 1024;
+var ContractStreamFrameSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("data"), data: z.unknown() }).strict(),
+  z.object({
+    type: z.literal("error"),
+    error: z.object({
+      code: z.string(),
+      message: z.string().optional(),
+      details: z.unknown().optional(),
+      hint: z.string().optional()
+    }).strict()
+  }).strict(),
+  z.object({ type: z.literal("end") }).strict()
+]);
+
+export { DEFAULT_CONTRACT_STREAM_FRAME_BYTES, ContractStreamFrameSchema };

package/dist/{index-f477k430.js → index-x4799c19.js}

@@ -4,7 +4,7 @@ import {
 } from "./index-2qzskm8h.js";
 import {
   zodIssues
-} from "./index-e0znv5gn.js";
+} from "./index-p5r7qpdd.js";
 import {
   AppError
 } from "./index-2vtcmrj9.js";

package/dist/{index-cxqhvq21.js → index-xnj9bgxe.js}

@@ -1,7 +1,6 @@
 import {
-  mergeMeta,
-  resolveRouteParamsSchema
-} from "./index-0a349c33.js";
+  contractMethodFields
+} from "./index-kvj7f4hq.js";
 import {
   AppError
 } from "./index-2vtcmrj9.js";
@@ -13,7 +12,110 @@ import {
   isRecord,
   transportResult,
   typedEntries
-} from "./index-77fekveh.js";
+} from "./index-hffjpmq9.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, X-Build-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 isOriginAllowed(config, requestOrigin) {
+  if (!config || config.origin === undefined || config.origin === "*")
+    return false;
+  if (!requestOrigin || requestOrigin === "null")
+    return false;
+  const lower = requestOrigin.toLowerCase();
+  const allowed = Array.isArray(config.origin) ? config.origin : [config.origin];
+  return allowed.some((origin) => origin.toLowerCase() === lower);
+}
+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"))
+  });
+}
+function requestCorsHeaders(cors, req) {
+  if (!cors)
+    return {};
+  return corsHeaders(cors, req.headers.get("origin"));
+}
+function applyCors(res, cors, req) {
+  const extra = requestCorsHeaders(cors, req);
+  if (Object.keys(extra).length === 0)
+    return res;
+  try {
+    for (const [key, value] of Object.entries(extra))
+      setCorsHeader(res.headers, key, value);
+    return res;
+  } catch {
+    const headers = new Headers(res.headers);
+    for (const [key, value] of Object.entries(extra))
+      setCorsHeader(headers, key, value);
+    return new Response(res.body, {
+      status: res.status,
+      statusText: res.statusText,
+      headers
+    });
+  }
+}
+function setCorsHeader(headers, key, value) {
+  if (key !== "Vary") {
+    headers.set(key, value);
+    return;
+  }
+  const existing = headers.get("Vary");
+  if (existing === null || existing.trim() === "") {
+    headers.set("Vary", value);
+    return;
+  }
+  const present = existing.split(",").some((field) => field.trim().toLowerCase() === "origin");
+  if (!present)
+    headers.set("Vary", `${existing}, ${value}`);
+}
 
 // src/server/implement.ts
 function isStreamingImplementation(value) {
@@ -72,7 +174,6 @@ function contractOnlyService(contract) {
   }
   return bindContract(contract, handlers);
 }
-var HTTP_ONLY = Object.freeze(["HTTP"]);
 function stubHandler(label) {
   return () => {
     throw new AppError("NOT_IMPLEMENTED", `[stitchkit] ${label} is declared by its contract and has no handler`, 501);
@@ -98,31 +199,8 @@ function bindContract(contract, handlers, options) {
     const streamingHandler = isStreamingImplementation(typedHandler) ? typedHandler : undefined;
     const regularHandler = typeof typedHandler === "function" ? typedHandler : undefined;
     methods[String(key)] = {
-      method: endpoint.method,
-      path: endpoint.path,
-      desc: endpoint.desc,
-      serviceName: contract.meta.prefix,
-      key: String(key),
-      toolName: "toolName" in endpoint ? endpoint.toolName : undefined,
-      expose: endpoint.rawResponse || endpoint.rawBody || endpoint.responseMeta || "stream" in endpoint && endpoint.stream ? HTTP_ONLY : endpoint.expose,
-      scope: endpoint.scope ?? groupScope,
-      paramsSchema: resolveRouteParamsSchema(endpoint.path, endpoint.params),
-      inputSchema: endpoint.input,
-      outputSchema: endpoint.output,
-      stream: "stream" in endpoint ? endpoint.stream : undefined,
-      multipart: endpoint.multipart,
+      ...contractMethodFields(contract, String(key), endpoint),
       multipartReceivers: streamingHandler?.receivers,
-      maxJsonBodyBytes: endpoint.maxJsonBodyBytes,
-      idempotent: endpoint.idempotent,
-      ui: "ui" in endpoint ? endpoint.ui : undefined,
-      annotations: "annotations" in endpoint ? endpoint.annotations : undefined,
-      mcp: "mcp" in endpoint ? endpoint.mcp : undefined,
-      meta: mergeMeta(contract.meta.meta, endpoint.meta),
-      rawResponse: endpoint.rawResponse,
-      rawBody: endpoint.rawBody,
-      safelistedBody: endpoint.safelistedBody,
-      responseMeta: endpoint.responseMeta,
-      contentType: "contentType" in endpoint ? endpoint.contentType : undefined,
       handler: streamingHandler ? (ctx) => streamingHandler.execute(ctx, ctx.files ?? {}) : (ctx) => {
         if (!regularHandler) {
           throw new Error(`[stitchkit] implement: missing handler for "${contract.meta.prefix}.${String(key)}"`);
@@ -216,105 +294,6 @@ function createImplementRegistry() {
   return (contracts, handlers, options) => transportResult(bindRegistry(contracts, handlers, options));
 }
 
-// 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, X-Build-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 isOriginAllowed(config, requestOrigin) {
-  if (!config || config.origin === undefined || config.origin === "*")
-    return false;
-  if (!requestOrigin || requestOrigin === "null")
-    return false;
-  const lower = requestOrigin.toLowerCase();
-  const allowed = Array.isArray(config.origin) ? config.origin : [config.origin];
-  return allowed.some((origin) => origin.toLowerCase() === lower);
-}
-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/internal/media-type.ts
-function mediaTypeEssence(contentType) {
-  return (contentType ?? "").split(";", 1)[0]?.trim().toLowerCase() ?? "";
-}
-
-// 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",
@@ -410,4 +389,38 @@ function mergeContextContribution(ctx, value, scope) {
   Object.assign(ctx, prepareContextContribution(value, scope));
 }
 
-export { mediaTypeEssence, defineMultipartStream, createMultipartStream, contractOnlyService, implement, createImplement, createScopedImplement, createScopedImplementRegistry, implementRegistry, createImplementRegistry, DEFAULT_CORS_ALLOW_HEADERS, DEFAULT_CORS_EXPOSE_HEADERS, assertCorsConfig, isOriginAllowed, corsHeaders, corsPreflightResponse, DEFAULT_PROCESS_SIGNALS, defaultSignalSource, reportSignalError, guardSignalCallback, RUNTIME_CONTEXT_RESERVED_KEYS, contextContributionDelta, prepareContextContribution, mergeContextContribution };
+// 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/internal/media-type.ts
+function mediaTypeEssence(contentType) {
+  return (contentType ?? "").split(";", 1)[0]?.trim().toLowerCase() ?? "";
+}
+
+export { DEFAULT_CORS_ALLOW_HEADERS, DEFAULT_CORS_EXPOSE_HEADERS, assertCorsConfig, isOriginAllowed, corsHeaders, corsPreflightResponse, requestCorsHeaders, applyCors, RUNTIME_CONTEXT_RESERVED_KEYS, contextContributionDelta, prepareContextContribution, mergeContextContribution, defineMultipartStream, createMultipartStream, contractOnlyService, implement, createImplement, createScopedImplement, createScopedImplementRegistry, implementRegistry, createImplementRegistry, DEFAULT_PROCESS_SIGNALS, defaultSignalSource, reportSignalError, guardSignalCallback, mediaTypeEssence };