stitchkit 0.44.1 → 0.46.0

package/dist/{index-4fyn9f09.js → index-zwqty9zf.js}

@@ -2,14 +2,12 @@ import {
   assertCorsConfig,
   corsHeaders,
   corsPreflightResponse
-} from "./index-6jypn22c.js";
-import {
-  isWithinDir
-} from "./index-x3fcszf8.js";
+} from "./index-r1qp4rve.js";
 import {
   AppError,
   __require,
   badRequest,
+  callRuntimeHandler,
   errorCode,
   extractIp,
   getClientInfo,
@@ -29,8 +27,9 @@ import {
   setRequestEndpoint,
   setRequestError,
   typedEntries,
-  validateDeclaredOutput
-} from "./index-yh0p5ddn.js";
+  validateDeclaredOutput,
+  zodIssues
+} from "./index-5s8b7z6q.js";
 
 // src/server/multipart.ts
 var DEFAULT_MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
@@ -85,244 +84,6 @@ async function parseMultipart(req, fileField, fieldsSchema, maxBytes = DEFAULT_M
   return { file, fields: fieldsSchema ? fieldsSchema.parse(fields) : fields };
 }
 
-// src/server/router.ts
-import { readFile, stat } from "node:fs/promises";
-import { resolve } from "node:path";
-
-// src/server/mime.ts
-import { extname } from "node:path";
-var MIME_BY_EXT = {
-  ".html": "text/html; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".mjs": "text/javascript; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".avif": "image/avif",
-  ".ico": "image/x-icon",
-  ".woff2": "font/woff2",
-  ".txt": "text/plain; charset=utf-8",
-  ".wasm": "application/wasm",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mov": "video/quicktime",
-  ".ogv": "video/ogg",
-  ".mp3": "audio/mpeg",
-  ".m4a": "audio/mp4",
-  ".wav": "audio/wav",
-  ".flac": "audio/flac",
-  ".oga": "audio/ogg",
-  ".ogg": "audio/ogg",
-  ".pdf": "application/pdf",
-  ".zip": "application/zip"
-};
-function mimeForPath(path) {
-  return MIME_BY_EXT[extname(path).toLowerCase()] ?? "application/octet-stream";
-}
-
-// src/server/router.ts
-function joinPath(...parts) {
-  const joined = parts.filter(Boolean).map((part) => part.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
-  return `/${joined}`;
-}
-function matchSegments(patternSegments, requestSegments) {
-  const wildcardSegment = patternSegments.at(-1);
-  const wildcardName = wildcardSegment?.startsWith("*") ? wildcardSegment.slice(1) : null;
-  const prefixLength = wildcardName ? patternSegments.length - 1 : patternSegments.length;
-  if (wildcardName) {
-    if (requestSegments.length < prefixLength)
-      return null;
-  } else if (patternSegments.length !== requestSegments.length) {
-    return null;
-  }
-  const params = {};
-  for (const [i, pattern] of patternSegments.slice(0, prefixLength).entries()) {
-    const actual = requestSegments[i];
-    if (actual === undefined)
-      return null;
-    if (pattern.startsWith(":")) {
-      params[pattern.slice(1)] = decodeURIComponent(actual);
-    } else if (pattern !== actual) {
-      return null;
-    }
-  }
-  if (wildcardName) {
-    params[wildcardName] = requestSegments.slice(prefixLength).map(decodeURIComponent).join("/");
-  }
-  return params;
-}
-function segmentRank(segment) {
-  if (segment?.startsWith("*"))
-    return 2;
-  if (segment?.startsWith(":"))
-    return 1;
-  return 0;
-}
-function buildRouteMap(groups) {
-  const map = new Map;
-  for (const { prefix, service, hooks } of groups) {
-    for (const [, method] of Object.entries(service.methods)) {
-      if (method.expose && !method.expose.includes("HTTP"))
-        continue;
-      const servicePath = joinPath("/", service.prefix, method.path === "/" ? "" : method.path);
-      const fullPath = prefix ? joinPath(prefix, servicePath) : servicePath;
-      const segments = fullPath.split("/").filter(Boolean);
-      const entries = map.get(method.method) ?? [];
-      entries.push({ method, pattern: fullPath, segments, groupHooks: hooks });
-      map.set(method.method, entries);
-    }
-  }
-  for (const [, entries] of map) {
-    entries.sort((a, b) => {
-      const len = Math.min(a.segments.length, b.segments.length);
-      for (let i = 0;i < len; i++) {
-        const rankDifference = segmentRank(a.segments[i]) - segmentRank(b.segments[i]);
-        if (rankDifference !== 0)
-          return rankDifference;
-      }
-      return a.segments.length - b.segments.length;
-    });
-  }
-  return map;
-}
-function matchRoute(routeMap, httpMethod, pathname) {
-  const entries = routeMap.get(httpMethod);
-  if (!entries)
-    return null;
-  const requestSegments = pathname.split("/").filter(Boolean);
-  for (const entry of entries) {
-    const pathParams = matchSegments(entry.segments, requestSegments);
-    if (pathParams) {
-      return {
-        method: entry.method,
-        pathParams,
-        groupHooks: entry.groupHooks
-      };
-    }
-  }
-  return null;
-}
-function allowedMethods(routeMap, pathname) {
-  const requestSegments = pathname.split("/").filter(Boolean);
-  const methods = [];
-  for (const [method, entries] of routeMap) {
-    for (const entry of entries) {
-      if (matchSegments(entry.segments, requestSegments)) {
-        methods.push(method);
-        break;
-      }
-    }
-  }
-  return methods;
-}
-function validateRoutes(routeMap) {
-  for (const [method, entries] of routeMap) {
-    const seen = new Map;
-    for (const entry of entries) {
-      parseTrailingWildcard(entry.pattern);
-      const normalized = entry.segments.map((s) => s.startsWith(":") ? ":param" : s.startsWith("*") ? "*wildcard" : s).join("/");
-      const key = `${method} /${normalized}`;
-      const existing = seen.get(key);
-      if (existing) {
-        throw new Error(`Duplicate route: ${method} ${entry.pattern} conflicts with ${existing}`);
-      }
-      seen.set(key, entry.pattern);
-    }
-  }
-}
-function findShadowedRoutes(routeMap, rawRoutes) {
-  if (!rawRoutes || rawRoutes.length === 0)
-    return [];
-  const shadowed = [];
-  for (const [httpMethod, entries] of routeMap) {
-    for (const entry of entries) {
-      const probe = `/${entry.segments.map((segment) => {
-        if (segment.startsWith(":"))
-          return "__param__";
-        if (segment.startsWith("*"))
-          return "__wildcard__";
-        return segment;
-      }).join("/")}`;
-      const match = matchRawRoute(rawRoutes, httpMethod, probe);
-      if (!match)
-        continue;
-      shadowed.push({
-        pattern: `${httpMethod} ${entry.pattern}`,
-        endpoint: `${entry.method.serviceName}.${entry.method.key}`,
-        rawRoute: `${match.route.method} ${match.route.path}`,
-        scope: entry.method.scope
-      });
-    }
-  }
-  return shadowed;
-}
-function matchRawRoute(rawRoutes, httpMethod, pathname) {
-  for (const route of rawRoutes) {
-    if (route.method !== "ALL" && route.method !== httpMethod)
-      continue;
-    if (parseTrailingWildcard(route.path)) {
-      const routeSegs = route.path.split("/").filter(Boolean);
-      const pathSegs = pathname.split("/").filter(Boolean);
-      const params = matchSegments(routeSegs, pathSegs);
-      if (params)
-        return { route, params };
-      continue;
-    }
-    if (route.path.includes("/:")) {
-      const routeSegs = route.path.split("/").filter(Boolean);
-      const pathSegs = pathname.split("/").filter(Boolean);
-      const params = matchSegments(routeSegs, pathSegs);
-      if (params)
-        return { route, params };
-      continue;
-    }
-    if (route.path === pathname)
-      return { route, params: {} };
-  }
-  return null;
-}
-function validateRawRoutes(rawRoutes) {
-  for (const route of rawRoutes ?? [])
-    parseTrailingWildcard(route.path);
-}
-function staticRoute(prefix, dir) {
-  const cleanPrefix = prefix.replace(/\/+$/, "");
-  const root = resolve(dir.replace(/\/+$/, ""));
-  return {
-    method: "GET",
-    path: `${cleanPrefix}/*filePath`,
-    handler: async (req) => {
-      const pathname = new URL(req.url).pathname;
-      let rel;
-      try {
-        rel = decodeURIComponent(pathname.slice(cleanPrefix.length)).replace(/^\/+/, "");
-      } catch {
-        return new Response("Bad request", { status: 400 });
-      }
-      const target = resolve(root, rel);
-      if (!isWithinDir(root, target)) {
-        return new Response("Forbidden", { status: 403 });
-      }
-      const info = await stat(target).catch(() => null);
-      if (!info?.isFile()) {
-        return new Response("Not found", { status: 404 });
-      }
-      const body = await readFile(target);
-      return new Response(body, {
-        headers: {
-          "Content-Type": mimeForPath(target),
-          "X-Content-Type-Options": "nosniff"
-        }
-      });
-    }
-  };
-}
-
 // src/server/request-body.ts
 function assertJsonBodyLimit(maxBytes, owner) {
   if (maxBytes !== undefined && (!Number.isSafeInteger(maxBytes) || maxBytes <= 0)) {
@@ -662,6 +423,172 @@ function applyResponseMetadata(target, metadata, endpointIdentity) {
   }
 }
 
+// src/server/router.ts
+function joinPath(...parts) {
+  const joined = parts.filter(Boolean).map((part) => part.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+  return `/${joined}`;
+}
+function matchSegments(patternSegments, requestSegments) {
+  const wildcardSegment = patternSegments.at(-1);
+  const wildcardName = wildcardSegment?.startsWith("*") ? wildcardSegment.slice(1) : null;
+  const prefixLength = wildcardName ? patternSegments.length - 1 : patternSegments.length;
+  if (wildcardName) {
+    if (requestSegments.length < prefixLength)
+      return null;
+  } else if (patternSegments.length !== requestSegments.length) {
+    return null;
+  }
+  const params = {};
+  for (const [i, pattern] of patternSegments.slice(0, prefixLength).entries()) {
+    const actual = requestSegments[i];
+    if (actual === undefined)
+      return null;
+    if (pattern.startsWith(":")) {
+      params[pattern.slice(1)] = decodeURIComponent(actual);
+    } else if (pattern !== actual) {
+      return null;
+    }
+  }
+  if (wildcardName) {
+    params[wildcardName] = requestSegments.slice(prefixLength).map(decodeURIComponent).join("/");
+  }
+  return params;
+}
+function segmentRank(segment) {
+  if (segment?.startsWith("*"))
+    return 2;
+  if (segment?.startsWith(":"))
+    return 1;
+  return 0;
+}
+function buildRouteMap(groups) {
+  const map = new Map;
+  for (const { prefix, service, hooks } of groups) {
+    for (const [, method] of Object.entries(service.methods)) {
+      if (method.expose && !method.expose.includes("HTTP"))
+        continue;
+      const servicePath = joinPath("/", service.prefix, method.path === "/" ? "" : method.path);
+      const fullPath = prefix ? joinPath(prefix, servicePath) : servicePath;
+      const segments = fullPath.split("/").filter(Boolean);
+      const entries = map.get(method.method) ?? [];
+      entries.push({ method, pattern: fullPath, segments, groupHooks: hooks });
+      map.set(method.method, entries);
+    }
+  }
+  for (const [, entries] of map) {
+    entries.sort((a, b) => {
+      const len = Math.min(a.segments.length, b.segments.length);
+      for (let i = 0;i < len; i++) {
+        const rankDifference = segmentRank(a.segments[i]) - segmentRank(b.segments[i]);
+        if (rankDifference !== 0)
+          return rankDifference;
+      }
+      return a.segments.length - b.segments.length;
+    });
+  }
+  return map;
+}
+function matchRoute(routeMap, httpMethod, pathname) {
+  const entries = routeMap.get(httpMethod);
+  if (!entries)
+    return null;
+  const requestSegments = pathname.split("/").filter(Boolean);
+  for (const entry of entries) {
+    const pathParams = matchSegments(entry.segments, requestSegments);
+    if (pathParams) {
+      return {
+        method: entry.method,
+        pathParams,
+        groupHooks: entry.groupHooks
+      };
+    }
+  }
+  return null;
+}
+function allowedMethods(routeMap, pathname) {
+  const requestSegments = pathname.split("/").filter(Boolean);
+  const methods = [];
+  for (const [method, entries] of routeMap) {
+    for (const entry of entries) {
+      if (matchSegments(entry.segments, requestSegments)) {
+        methods.push(method);
+        break;
+      }
+    }
+  }
+  return methods;
+}
+function validateRoutes(routeMap) {
+  for (const [method, entries] of routeMap) {
+    const seen = new Map;
+    for (const entry of entries) {
+      parseTrailingWildcard(entry.pattern);
+      const normalized = entry.segments.map((s) => s.startsWith(":") ? ":param" : s.startsWith("*") ? "*wildcard" : s).join("/");
+      const key = `${method} /${normalized}`;
+      const existing = seen.get(key);
+      if (existing) {
+        throw new Error(`Duplicate route: ${method} ${entry.pattern} conflicts with ${existing}`);
+      }
+      seen.set(key, entry.pattern);
+    }
+  }
+}
+function findShadowedRoutes(routeMap, rawRoutes) {
+  if (!rawRoutes || rawRoutes.length === 0)
+    return [];
+  const shadowed = [];
+  for (const [httpMethod, entries] of routeMap) {
+    for (const entry of entries) {
+      const probe = `/${entry.segments.map((segment) => {
+        if (segment.startsWith(":"))
+          return "__param__";
+        if (segment.startsWith("*"))
+          return "__wildcard__";
+        return segment;
+      }).join("/")}`;
+      const match = matchRawRoute(rawRoutes, httpMethod, probe);
+      if (!match)
+        continue;
+      shadowed.push({
+        pattern: `${httpMethod} ${entry.pattern}`,
+        endpoint: `${entry.method.serviceName}.${entry.method.key}`,
+        rawRoute: `${match.route.method} ${match.route.path}`,
+        scope: entry.method.scope
+      });
+    }
+  }
+  return shadowed;
+}
+function matchRawRoute(rawRoutes, httpMethod, pathname) {
+  for (const route of rawRoutes) {
+    if (route.method !== "ALL" && route.method !== httpMethod)
+      continue;
+    if (parseTrailingWildcard(route.path)) {
+      const routeSegs = route.path.split("/").filter(Boolean);
+      const pathSegs = pathname.split("/").filter(Boolean);
+      const params = matchSegments(routeSegs, pathSegs);
+      if (params)
+        return { route, params };
+      continue;
+    }
+    if (route.path.includes("/:")) {
+      const routeSegs = route.path.split("/").filter(Boolean);
+      const pathSegs = pathname.split("/").filter(Boolean);
+      const params = matchSegments(routeSegs, pathSegs);
+      if (params)
+        return { route, params };
+      continue;
+    }
+    if (route.path === pathname)
+      return { route, params: {} };
+  }
+  return null;
+}
+function validateRawRoutes(rawRoutes) {
+  for (const route of rawRoutes ?? [])
+    parseTrailingWildcard(route.path);
+}
+
 // src/server/create.ts
 var BODY_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
 function createHandler(config) {
@@ -1018,6 +945,9 @@ function implement(contract, handlers) {
   const groupScope = contract.meta.scope ?? "public";
   for (const [key, endpoint] of typedEntries(contract.endpoints)) {
     const typedHandler = handlers[key];
+    if (typeof typedHandler !== "function") {
+      throw new Error(`[stitchkit] implement: missing handler for "${contract.meta.prefix}.${String(key)}"`);
+    }
     methods[String(key)] = {
       method: endpoint.method,
       path: endpoint.path,
@@ -1042,7 +972,7 @@ function implement(contract, handlers) {
       rawBody: endpoint.rawBody,
       responseMeta: endpoint.responseMeta,
       contentType: "contentType" in endpoint ? endpoint.contentType : undefined,
-      handler: (ctx) => typedHandler(ctx)
+      handler: (ctx) => callRuntimeHandler(typedHandler, ctx)
     };
   }
   return {
@@ -1056,6 +986,226 @@ function createImplement() {
   return (contract, handlers) => implement(contract, handlers);
 }
 
+// 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) {
+  if (!definition.ack)
+    return { values: args };
+  const acknowledgement = args.at(-1);
+  if (typeof acknowledgement !== "function")
+    return { values: args };
+  return {
+    values: args.slice(0, -1),
+    acknowledgement: (...callbackArgs) => Reflect.apply(acknowledgement, undefined, callbackArgs)
+  };
+}
+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 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 } = splitWireArguments(definition, wireArgs);
+        const parsed = definition.args.safeParse(values);
+        if (!parsed.success) {
+          reportRejected(realtimeContractViolation({
+            event,
+            direction: inboundDirection,
+            phase: "arguments",
+            reason: "invalid-arguments",
+            fault: "peer",
+            cause: parsed.error
+          }), onRejected, 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 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);
+        });
+      }
+      emitTarget(event, ...wireArgs);
+    }
+  };
+}
+
+// src/server/realtime.ts
+function bindRealtimeServer(contract, handle, options = {}) {
+  const outbound = (target) => createValidatedRealtimeSocket({
+    target,
+    inbound: {},
+    outbound: contract.serverToClient,
+    inboundDirection: "server-inbound",
+    outboundDirection: "server-outbound",
+    onRejected: options.onRejected,
+    logger: options.logger
+  });
+  const broadcast = outbound(handle.io);
+  return {
+    onConnection: (handler) => {
+      const listener = (raw) => {
+        const events = createValidatedRealtimeSocket({
+          target: raw,
+          inbound: contract.clientToServer,
+          outbound: contract.serverToClient,
+          inboundDirection: "server-inbound",
+          outboundDirection: "server-outbound",
+          onRejected: options.onRejected,
+          logger: options.logger
+        });
+        handler({
+          raw,
+          events,
+          to: (room) => outbound(raw.to(room))
+        });
+      };
+      handle.io.on("connection", listener);
+      return () => {
+        handle.io.off("connection", listener);
+      };
+    },
+    emit: broadcast.emit,
+    to: (room) => outbound(handle.io.to(room))
+  };
+}
+
 // src/server/websocket.ts
 function webSocketLane(lane) {
   const { match, handlers } = lane;
@@ -1202,4 +1352,4 @@ function socketIoLane(websocket) {
   });
 }
 
-export { parseMultipart, mimeForPath, staticRoute, createHandler, implement, createImplement, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane };
+export { parseMultipart, createHandler, implement, createImplement, bindRealtimeServer, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane };

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 export { type ClientConfig, type ClientContract, type ClientRegistryValue, type ContractClientConfig, contractEndpointMatchers, createClient, createClients, createScopedClients, createScopedUrlBuilders, createUrlBuilder, createUrlBuilders, type PathPrefixArgs, type RegistryScope, type ScopeClientConfigs, type ScopedClientRegistry, type ScopedUrlBuilderRegistry, type UrlBuilderConfig, } from './browser/client';
 export { ApiError, type ApiEvent, type ApiEventListener, type ConfiguredHttpClient, createHttpClient, type HeaderProvider, type HttpClient, type HttpClientConfig, type RequestOptions, type UnauthorizedMatcher, } from './browser/http';
-export type { SocketEventMap, SocketIOClient, SocketIOClientConfig, } from './browser/socket-io';
-export { createSocketIOClient } from './browser/socket-io';
+export type { RealtimeClient, RealtimeClientOptions, SocketEventMap, SocketIOClient, SocketIOClientConfig, } from './browser/socket-io';
+export { createRealtimeClient, createSocketIOClient } from './browser/socket-io';
 export { type ParseSSEOptions, parseSSE } from './browser/stream';
 export * from './contract';
+export type { StitchLogger } from './logger';
 export { childSpan, createTraceContext, formatTraceparent, parseTraceparent, type TraceContext, } from './observability/trace';
+export * from './realtime';
 export { createRetainedTopics, type RetainedTopics } from './retained';
 //# sourceMappingURL=index.d.ts.map