stitchkit 0.54.0 → 0.55.0

package/dist/{index-b15rtha1.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,6 +247,63 @@ function createImplementRegistry() {
   return (contracts, handlers) => transportResult(bindRegistry(contracts, handlers));
 }
 
+// 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 = {
@@ -275,4 +333,4 @@ function guardSignalCallback(run, phase, onError) {
   }
 }
 
-export { 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 { 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 };

package/dist/index.js

@@ -1,6 +1,8 @@
 import {
   ALL_TRANSPORTS,
   AppError,
+  ManagedFilePathSchema,
+  ManagedFileRefSchema,
   STITCH_ERROR_STATUS,
   appError,
   badRequest,
@@ -17,7 +19,7 @@ import {
   parseTrailingWildcard,
   rateLimited,
   unauthorized
-} from "./index-pfqjb5xy.js";
+} from "./index-rgd18hx3.js";
 import {
   isRecord,
   mapObject,
@@ -806,6 +808,39 @@ function createUrlBuilders(contracts, source, contractConfig) {
 function createScopedUrlBuilders(contracts, source, scopeConfigs) {
   return buildScopedRegistry(contracts, scopeConfigs, "URL builder", (contract, config) => createUrlBuilder(contract, source, config));
 }
+// src/realtime/request.ts
+class RealtimeRequestTimeoutError extends Error {
+  code = "REALTIME_REQUEST_TIMEOUT";
+  event;
+  timeoutMs;
+  constructor(event, timeoutMs) {
+    super(`Realtime request "${event}" timed out after ${timeoutMs}ms`);
+    this.name = "RealtimeRequestTimeoutError";
+    this.event = event;
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+class RealtimeRequestDisconnectedError extends Error {
+  code = "REALTIME_REQUEST_DISCONNECTED";
+  event;
+  constructor(event) {
+    super(`Realtime request "${event}" was interrupted by disconnect`);
+    this.name = "RealtimeRequestDisconnectedError";
+    this.event = event;
+  }
+}
+
+class RealtimeRequestInvalidAcknowledgementError extends Error {
+  code = "REALTIME_REQUEST_INVALID_ACKNOWLEDGEMENT";
+  event;
+  constructor(event, cause) {
+    super(`Realtime request "${event}" received an invalid acknowledgement`, { cause });
+    this.name = "RealtimeRequestInvalidAcknowledgementError";
+    this.event = event;
+  }
+}
+
 // src/realtime/rejection.ts
 import { z as z2 } from "zod";
 
@@ -884,6 +919,45 @@ function reportRejected(rejected, hook, logger) {
     console.error("[stitchkit] realtime rejection hook failed", 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 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,
@@ -1070,6 +1144,25 @@ function createRealtimeClient(contract, { onRejected, logger, ...config }) {
       };
     }
   });
+  async function request(event, ...args) {
+    const options = args.at(-1);
+    if (!options || typeof options !== "object" || !("timeoutMs" in options)) {
+      throw new TypeError(`Realtime request "${event}" requires { timeoutMs }`);
+    }
+    const timeoutMs = options.timeoutMs;
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      throw new RangeError(`Realtime request "${event}" timeoutMs must be finite and > 0`);
+    }
+    const values = args.slice(0, -1);
+    const parsedArgs = parseRealtimeRequestArguments(contract.clientToServer, event, "client-outbound", values);
+    const definition = contract.clientToServer[event];
+    if (!definition?.ack) {
+      throw new Error(`Realtime request "${event}" has no acknowledgement schema`);
+    }
+    const value = await transport.emitWithAck(event, parsedArgs, { timeoutMs });
+    const acknowledgement = parseRealtimeRequestAcknowledgement(definition.ack, event, "client-inbound", value, onRejected, logger);
+    return acknowledgement;
+  }
   return {
     ...events,
     connect: transport.connect,
@@ -1077,6 +1170,7 @@ function createRealtimeClient(contract, { onRejected, logger, ...config }) {
     get connected() {
       return transport.connected;
     },
+    request,
     onConnectionChange: transport.onConnectionChange
   };
 }
@@ -1084,6 +1178,7 @@ function createSocketIOClient(config) {
   let socket = null;
   let desiredConnected = false;
   let reconnectTimer = null;
+  const pendingRequestDisconnects = new Set;
   const serverDisconnectDelay = config.reconnectOnServerDisconnect ?? 1000;
   const connectionListeners = new Set;
   const subscriptions = new Set;
@@ -1169,6 +1264,8 @@ function createSocketIOClient(config) {
     disconnect() {
       desiredConnected = false;
       clearReconnectTimer();
+      for (const reject of [...pendingRequestDisconnects])
+        reject();
       if (!socket)
         return;
       const wasConnected = socket.connected;
@@ -1204,6 +1301,31 @@ function createSocketIOClient(config) {
       socket.emit(name, ...args);
       return true;
     },
+    emitWithAck(event, args, options) {
+      const active = socket;
+      if (!active?.connected) {
+        return Promise.reject(new RealtimeRequestDisconnectedError(event));
+      }
+      return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (result) => {
+          if (settled)
+            return;
+          settled = true;
+          pendingRequestDisconnects.delete(onDisconnect);
+          active.off("disconnect", onDisconnect);
+          result();
+        };
+        const onDisconnect = () => {
+          finish(() => reject(new RealtimeRequestDisconnectedError(event)));
+        };
+        pendingRequestDisconnects.add(onDisconnect);
+        active.on("disconnect", onDisconnect);
+        active.timeout(options.timeoutMs).emitWithAck(event, ...args).then((value) => finish(() => resolve(value)), () => {
+          finish(() => reject(active.connected ? new RealtimeRequestTimeoutError(event, options.timeoutMs) : new RealtimeRequestDisconnectedError(event)));
+        });
+      });
+    },
     onConnectionChange(listener) {
       connectionListeners.add(listener);
       return () => connectionListeners.delete(listener);
@@ -1249,39 +1371,44 @@ function defineRealtimeContract(contract) {
   return contract;
 }
 export {
-  unauthorized,
-  rateLimited,
-  parseTraceparent,
-  parseSSE,
-  paginatedSchema,
-  notFound,
-  isStitchErrorCode,
-  formatTraceparent,
-  forbidden,
-  encodeCursor,
-  defineRealtimeContract,
-  defineErrors,
-  defineContract,
-  decodeCursor,
-  createUrlBuilders,
-  createUrlBuilder,
-  createTraceContext,
-  createSocketIOClient,
-  createScopedUrlBuilders,
-  createScopedClients,
-  createRetainedTopics,
-  createRealtimeClient,
-  createHttpClient,
-  createContractFactory,
-  createClients,
-  createClient,
-  contractEndpointMatchers,
-  conflict,
-  childSpan,
-  badRequest,
-  appError,
-  STITCH_ERROR_STATUS,
-  AppError,
+  ALL_TRANSPORTS,
   ApiError,
-  ALL_TRANSPORTS
+  AppError,
+  ManagedFilePathSchema,
+  ManagedFileRefSchema,
+  RealtimeRequestDisconnectedError,
+  RealtimeRequestInvalidAcknowledgementError,
+  RealtimeRequestTimeoutError,
+  STITCH_ERROR_STATUS,
+  appError,
+  badRequest,
+  childSpan,
+  conflict,
+  contractEndpointMatchers,
+  createClient,
+  createClients,
+  createContractFactory,
+  createHttpClient,
+  createRealtimeClient,
+  createRetainedTopics,
+  createScopedClients,
+  createScopedUrlBuilders,
+  createSocketIOClient,
+  createTraceContext,
+  createUrlBuilder,
+  createUrlBuilders,
+  decodeCursor,
+  defineContract,
+  defineErrors,
+  defineRealtimeContract,
+  encodeCursor,
+  forbidden,
+  formatTraceparent,
+  isStitchErrorCode,
+  notFound,
+  paginatedSchema,
+  parseSSE,
+  parseTraceparent,
+  rateLimited,
+  unauthorized
 };

package/dist/node.js

@@ -8,7 +8,7 @@ import {
   createHandler,
   createServerLifecycle,
   createSocketIOServer
-} from "./index-z7761jk2.js";
+} from "./index-npye5kt7.js";
 import {
   createImplement,
   createImplementRegistry,
@@ -17,7 +17,8 @@ import {
   createScopedImplementRegistry,
   implement,
   implementRegistry
-} from "./index-b15rtha1.js";
+} from "./index-pzc32v75.js";
+import"./index-v4bbq3p4.js";
 import {
   AppError,
   appError,
@@ -27,8 +28,10 @@ import {
   notFound,
   rateLimited,
   unauthorized
-} from "./index-173tvqcp.js";
-import"./index-bmnhqtya.js";
+} from "./index-h60df7rj.js";
+import"./index-6k1937bx.js";
+import"./index-7eq9va6e.js";
+import"./index-1bx83sw4.js";
 // src/server/node.ts
 import { serve } from "srvx/node";
 async function serveNode(config) {
@@ -139,28 +142,28 @@ async function createNodeSocketIOServer(config) {
   return createSocketIOServer(config);
 }
 export {
-  unauthorized,
-  serveNode,
-  rateLimited,
-  notFound,
-  implementRegistry,
-  implement,
-  forbidden,
-  createNodeSocketIOServer as createSocketIOServer,
-  createScopedImplementRegistry,
-  createScopedImplement,
-  createMultipartStream,
-  createImplementRegistry,
-  createImplement,
-  createHandler,
-  conflict,
-  bindRealtimeServer,
-  bindProcessSignals,
-  badRequest,
-  appError,
-  ShutdownStatusSchema,
-  ShutdownStateSchema,
-  ShutdownResultSchema,
+  AppError,
   ShutdownOptionsSchema,
-  AppError
+  ShutdownResultSchema,
+  ShutdownStateSchema,
+  ShutdownStatusSchema,
+  appError,
+  badRequest,
+  bindProcessSignals,
+  bindRealtimeServer,
+  conflict,
+  createHandler,
+  createImplement,
+  createImplementRegistry,
+  createMultipartStream,
+  createScopedImplement,
+  createScopedImplementRegistry,
+  createNodeSocketIOServer as createSocketIOServer,
+  forbidden,
+  implement,
+  implementRegistry,
+  notFound,
+  rateLimited,
+  serveNode,
+  unauthorized
 };