stitchkit 0.77.0 → 0.79.0

package/dist/index.js

@@ -1,1590 +1,87 @@
+import {
+  defineRealtimeContract
+} from "./index-p7hgdyhb.js";
+import {
+  BackoffPolicySchema,
+  createBackoff,
+  resumableIterator
+} from "./index-h4pj6fta.js";
+import {
+  REALTIME_REJECTION_KEY,
+  asRealtimeRejection,
+  createValidatedRealtimeSocket,
+  isModuleNotFound,
+  parseRealtimeRequestAcknowledgement,
+  parseRealtimeRequestArguments
+} from "./index-t0z5p5w6.js";
+import {
+  RealtimeRequestDisconnectedError,
+  RealtimeRequestInvalidAcknowledgementError,
+  RealtimeRequestPhaseEventSchema,
+  RealtimeRequestPhaseSchema,
+  RealtimeRequestRejectedError,
+  RealtimeRequestTimeoutError
+} from "./index-2qzskm8h.js";
 import {
   LiveStateControllerStatusSchema,
   LiveStatePhaseSchema,
   LiveStateStopReasonSchema,
   createLiveStateController
-} from "./index-35z5h2ty.js";
+} from "./index-ywd0y6m1.js";
+import"./index-7gnkny4z.js";
+import {
+  ApiError,
+  contractEndpointMatchers,
+  createClient,
+  createClients,
+  createHttpClient,
+  createScopedClients,
+  createScopedUrlBuilders,
+  createUrlBuilder,
+  createUrlBuilders,
+  parseNDJSON
+} from "./index-7ag81v2f.js";
+import {
+  parseSSE
+} from "./index-hb5pf3s4.js";
+import {
+  childSpan,
+  createTraceContext,
+  formatTraceparent,
+  formatZodError,
+  parseTraceparent,
+  randomHex,
+  zodIssues
+} from "./index-fxz0v7vg.js";
 import {
   ALL_TRANSPORTS,
-  AppError,
   ContractStreamFrameSchema,
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
-  ManagedFilePathSchema,
-  ManagedFileRefSchema,
-  STITCH_ERROR_STATUS,
-  appError,
-  badRequest,
-  conflict,
   createContractFactory,
   decodeCursor,
   defineContract,
   defineErrors,
   encodeCursor,
+  paginatedSchema
+} from "./index-y01f4223.js";
+import {
+  ManagedFilePathSchema,
+  ManagedFileRefSchema
+} from "./index-6k1937bx.js";
+import {
+  AppError,
+  STITCH_ERROR_STATUS,
+  appError,
+  badRequest,
+  conflict,
   forbidden,
   isStitchErrorCode,
   notFound,
-  paginatedSchema,
-  parseTrailingWildcard,
   rateLimited,
   unauthorized
-} from "./index-f6n5n7nz.js";
-import {
-  isRecord,
-  mapObject,
-  transportResult,
-  typedEntries
-} from "./index-ksp6e2ye.js";
-
-// src/browser/cancellation.ts
-class RequestCancellationError extends Error {
-  cause;
-  constructor(cause) {
-    super(cause === "caller" ? "Request was aborted" : "Request timed out");
-    this.cause = cause;
-    this.name = "RequestCancellationError";
-  }
-}
-function createRequestCancellation(caller, timeoutMs) {
-  if (!caller && timeoutMs === undefined) {
-    return { signal: undefined, run: (operation) => operation() };
-  }
-  const timeoutController = timeoutMs === undefined ? undefined : new AbortController;
-  const signal = caller && timeoutController ? AbortSignal.any([caller, timeoutController.signal]) : caller ?? timeoutController?.signal;
-  let cause;
-  let timer;
-  const abortFromCaller = () => {
-    if (cause)
-      return;
-    cause = "caller";
-  };
-  if (caller?.aborted)
-    abortFromCaller();
-  else
-    caller?.addEventListener("abort", abortFromCaller, { once: true });
-  if (timeoutMs !== undefined && timeoutController) {
-    timer = setTimeout(() => {
-      if (cause)
-        return;
-      cause = "timeout";
-      timeoutController.abort(new DOMException("Request timed out", "TimeoutError"));
-    }, timeoutMs);
-  }
-  return {
-    signal,
-    async run(operation) {
-      try {
-        if (cause === "caller")
-          throw cancellationError(cause);
-        return await operation(signal);
-      } catch (error) {
-        if (cause)
-          throw cancellationError(cause);
-        throw error;
-      } finally {
-        if (timer !== undefined)
-          clearTimeout(timer);
-        caller?.removeEventListener("abort", abortFromCaller);
-      }
-    }
-  };
-}
-function cancellationError(cause) {
-  return new RequestCancellationError(cause);
-}
-
-// src/browser/http.ts
-import ky, {
-  isHTTPError,
-  isNetworkError,
-  isTimeoutError
-} from "ky";
-
-// src/internal/random-hex.ts
-function randomHex(bytes) {
-  const arr = new Uint8Array(bytes);
-  crypto.getRandomValues(arr);
-  let hex = "";
-  for (const byte of arr)
-    hex += byte.toString(16).padStart(2, "0");
-  return hex;
-}
-
-// src/observability/trace.ts
-var TRACEPARENT_RE = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(.*)$/i;
-function createTraceContext() {
-  return { traceId: randomHex(16), spanId: randomHex(8) };
-}
-function parseTraceparent(header) {
-  if (!header)
-    return null;
-  const match = TRACEPARENT_RE.exec(header.trim());
-  if (!match?.[1] || !match[2] || !match[3] || !match[4] || match[5] === undefined)
-    return null;
-  const version = match[1].toLowerCase();
-  if (version === "ff")
-    return null;
-  const suffix = match[5];
-  if (version === "00" ? suffix !== "" : suffix !== "" && !/^(?:-[0-9a-f]{2,})+$/i.test(suffix)) {
-    return null;
-  }
-  const traceId = match[2].toLowerCase();
-  const parentSpanId = match[3].toLowerCase();
-  const traceFlags = match[4].toLowerCase();
-  if (/^0+$/.test(traceId) || /^0+$/.test(parentSpanId))
-    return null;
-  return { traceId, spanId: randomHex(8), parentSpanId, traceFlags };
-}
-function formatTraceparent(ctx) {
-  return `00-${ctx.traceId}-${ctx.spanId}-${ctx.traceFlags ?? "01"}`;
-}
-function childSpan(parent) {
-  return {
-    traceId: parent.traceId,
-    spanId: randomHex(8),
-    parentSpanId: parent.spanId,
-    ...parent.tracestate !== undefined && { tracestate: parent.tracestate },
-    ...parent.baggage !== undefined && { baggage: parent.baggage },
-    ...parent.traceFlags !== undefined && { traceFlags: parent.traceFlags }
-  };
-}
-var encoder = new TextEncoder;
-
-// src/browser/request-id.ts
-var REQUEST_ID_HEADER = "x-request-id";
-function responseTraceId(response) {
-  return response?.headers.get(REQUEST_ID_HEADER) ?? undefined;
-}
-
-// src/browser/http.ts
-var API_ERROR_BRAND = Symbol.for("stitchkit.ApiError");
-function messageForCode(code, message) {
-  return message !== undefined && message.length > 0 ? message : `${code} (no message supplied)`;
-}
-
-class ApiError extends Error {
-  code;
-  status;
-  details;
-  hint;
-  traceId;
-  constructor(code, status = 0, details, message, hint, traceId, options) {
-    super(messageForCode(code, message), options);
-    this.code = code;
-    this.status = status;
-    this.details = details;
-    this.hint = hint;
-    this.traceId = traceId;
-    this.name = "ApiError";
-    Object.defineProperty(this, API_ERROR_BRAND, { value: true });
-  }
-  static is(error) {
-    return typeof error === "object" && error !== null && API_ERROR_BRAND in error;
-  }
-}
-function refuseLocally(path, message) {
-  return new ApiError("VALIDATION_ERROR", 0, { issues: [{ path, code: "invalid_type", message }] }, message);
-}
-function shouldRetryBunNetworkError(error) {
-  if (ApiError.is(error) || isHTTPError(error) || isNetworkError(error) || isTimeoutError(error) || error instanceof RequestCancellationError || error instanceof DOMException && (error.name === "AbortError" || error.name === "TimeoutError")) {
-    return;
-  }
-  if (!(error instanceof Error))
-    return;
-  const code = Object.getOwnPropertyDescriptor(error, "code");
-  return code && "value" in code && code.value === "ConnectionRefused" ? true : undefined;
-}
-function parseApiErrorBody(body) {
-  if (!isRecord(body) || !isRecord(body.error))
-    return null;
-  const error = body.error;
-  if (typeof error.code !== "string")
-    return null;
-  return {
-    code: error.code,
-    message: typeof error.message === "string" ? error.message : undefined,
-    details: error.details,
-    hint: typeof error.hint === "string" ? error.hint : undefined
-  };
-}
-function createRetryAwareFetch(transportFetch, unix) {
-  const runtimeFetch = transportFetch;
-  let attempt = 0;
-  return (input, init) => {
-    attempt += 1;
-    if (unix === undefined && attempt === 1) {
-      return runtimeFetch(input, init);
-    }
-    if (!(input instanceof Request)) {
-      if (unix === undefined)
-        return runtimeFetch(input, init);
-      const unixInit = { ...init, unix };
-      return runtimeFetch(input, unixInit);
-    }
-    const streamedBody = input.body ? { body: input.body, duplex: "half" } : {};
-    const materialized = {
-      ...init,
-      ...unix !== undefined && { unix },
-      method: input.method,
-      headers: input.headers,
-      ...streamedBody,
-      cache: input.cache,
-      credentials: input.credentials,
-      integrity: input.integrity,
-      keepalive: input.keepalive,
-      mode: input.mode,
-      redirect: input.redirect,
-      referrer: input.referrer,
-      referrerPolicy: input.referrerPolicy,
-      signal: input.signal
-    };
-    return runtimeFetch(input.url, materialized);
-  };
-}
-function createHttpClient(config) {
-  if (config.fetch && config.unix) {
-    throw new TypeError("HttpClientConfig.fetch and unix are mutually exclusive");
-  }
-  if (config.unix !== undefined) {
-    if (!config.unix.startsWith("/") || config.unix.includes("\x00")) {
-      throw new TypeError("HttpClientConfig.unix must be an absolute Unix socket path");
-    }
-    if (typeof Reflect.get(globalThis, "Bun") !== "object") {
-      throw new TypeError("HttpClientConfig.unix requires Bun; on Bun or Node use createUnixClientTransport().fetch for an explicit portable transport");
-    }
-  }
-  let ssrCookies = null;
-  let isLoggedOut = false;
-  const listeners = new Set;
-  const suppressUnauthorizedFor = config.suppressUnauthorizedFor ?? [];
-  const parseError = config.parseError ?? parseApiErrorBody;
-  function emit(event) {
-    for (const fn of listeners) {
-      try {
-        fn(event);
-      } catch {}
-    }
-  }
-  const client = ky.create({
-    prefix: config.baseUrl,
-    credentials: config.credentials ?? "include",
-    timeout: false,
-    retry: {
-      limit: config.retry?.limit ?? 2,
-      methods: config.retry?.methods ?? ["get"],
-      statusCodes: config.retry?.statusCodes ?? [],
-      shouldRetry: ({ error }) => shouldRetryBunNetworkError(error)
-    },
-    hooks: {
-      beforeRequest: [
-        ({ request: request2 }) => {
-          if (ssrCookies) {
-            request2.headers.set("Cookie", ssrCookies);
-          }
-          const extra = typeof config.headers === "function" ? config.headers() : config.headers;
-          if (extra) {
-            for (const [key, value] of Object.entries(extra)) {
-              request2.headers.set(key, value);
-            }
-          }
-          if (config.trace && !request2.headers.has("traceparent")) {
-            request2.headers.set("traceparent", formatTraceparent(createTraceContext()));
-          }
-        }
-      ],
-      afterResponse: [
-        async ({ request: request2, response }) => {
-          if (response.status === 401) {
-            const url = new URL(request2.url).pathname;
-            if (!isLoggedOut && !suppressUnauthorizedFor.some((matches) => matches(url))) {
-              isLoggedOut = true;
-              emit({ type: "unauthorized" });
-            }
-          }
-          if (!response.ok) {
-            const body = await response.clone().json().catch(() => null);
-            if (body) {
-              const parsed = parseError(body);
-              if (parsed) {
-                throw new ApiError(parsed.code, response.status, parsed.details, parsed.message, parsed.hint, responseTraceId(response));
-              }
-            }
-          }
-        }
-      ]
-    }
-  });
-  async function request(method, url, data, options = {}) {
-    const cancellation = createRequestCancellation(options.signal, options.timeout ?? config.timeout ?? 30000);
-    const kyOptions = {
-      fetch: createRetryAwareFetch(config.fetch ?? globalThis.fetch.bind(globalThis), config.unix),
-      timeout: false,
-      signal: cancellation.signal
-    };
-    if (options.params) {
-      const searchParams = new URLSearchParams;
-      for (const [key, value] of Object.entries(options.params)) {
-        if (value === undefined)
-          continue;
-        if (Array.isArray(value)) {
-          for (const item of value)
-            searchParams.append(key, String(item));
-        } else {
-          searchParams.set(key, String(value));
-        }
-      }
-      if (searchParams.size > 0) {
-        kyOptions.searchParams = searchParams;
-      }
-    }
-    if (data instanceof FormData) {
-      kyOptions.body = data;
-    } else if (data !== undefined) {
-      kyOptions.json = data;
-    }
-    try {
-      return await cancellation.run(async () => {
-        if (options.responseType === "blob") {
-          return transportResult(await client[method](url, kyOptions).blob());
-        }
-        if (options.responseType === "response") {
-          return transportResult(await client[method](url, kyOptions));
-        }
-        const response = await client[method](url, kyOptions);
-        if (options.responseType === "void") {
-          const text = await response.text();
-          if (text.length > 0) {
-            throw new Error("Server returned data for an endpoint with no output contract");
-          }
-        }
-        if (options.responseType === "void" || response.status === 204 || response.headers.get("content-length") === "0") {
-          return transportResult(undefined);
-        }
-        return await response.json();
-      });
-    } catch (error) {
-      if (error instanceof RequestCancellationError) {
-        throw new ApiError(error.cause === "caller" ? "REQUEST_ABORTED" : "REQUEST_TIMEOUT", 0, undefined, error.message);
-      }
-      if (ApiError.is(error))
-        throw error;
-      emit({ type: "network_error" });
-      const response = isHTTPError(error) ? error.response : undefined;
-      const status = response?.status ?? 0;
-      const msg = error instanceof Error ? error.message : undefined;
-      throw new ApiError("UNKNOWN_ERROR", status, msg ? { message: msg } : undefined, msg, undefined, responseTraceId(response), { cause: error });
-    }
-  }
-  return {
-    baseUrl: config.baseUrl,
-    get: (url, options) => request("get", url, undefined, options),
-    head: (url, options) => request("head", url, undefined, options),
-    post: (url, data, options) => request("post", url, data, options),
-    put: (url, data, options) => request("put", url, data, options),
-    patch: (url, data, options) => request("patch", url, data, options),
-    delete: (url, options) => request("delete", url, undefined, options),
-    setServerContext(cookies) {
-      ssrCookies = cookies;
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    logout() {
-      isLoggedOut = true;
-      emit({ type: "logout" });
-    },
-    resetLogoutState() {
-      isLoggedOut = false;
-    }
-  };
-}
-
-// src/browser/client-multipart.ts
-function isFileDescriptor(value) {
-  return typeof value === "object" && value !== null && !(value instanceof Blob) && "uri" in value && typeof value.uri === "string" && "name" in value && typeof value.name === "string" && "type" in value && typeof value.type === "string";
-}
-function isMultipartFile(value) {
-  return value instanceof Blob || isFileDescriptor(value);
-}
-function appendMultipartFile(form, field, file) {
-  const sink = form;
-  sink.append(field, file);
-}
-function appendFormFields(formData, values, skipKeys) {
-  for (const [key, value] of Object.entries(values)) {
-    if (skipKeys.has(key) || value === undefined || value === null)
-      continue;
-    formData.append(key, typeof value === "string" ? value : JSON.stringify(value));
-  }
-}
-function buildMultipartForm(descriptor, values) {
-  const formData = new FormData;
-  const fileFields = new Set(Object.keys(descriptor.files));
-  for (const [field, policy] of Object.entries(descriptor.files)) {
-    const value = values[field];
-    if (value === undefined) {
-      if (policy.required !== false) {
-        throw refuseLocally(field, `Missing multipart file field: ${field}`);
-      }
-      continue;
-    }
-    if (policy.multiple === true) {
-      if (!Array.isArray(value) || value.length === 0) {
-        throw refuseLocally(field, `Multipart file field "${field}" must be a non-empty array`);
-      }
-      for (const file of value) {
-        if (!isMultipartFile(file)) {
-          throw refuseLocally(field, `Invalid multipart file field: ${field}`);
-        }
-        appendMultipartFile(formData, field, file);
-      }
-      continue;
-    }
-    if (!isMultipartFile(value)) {
-      throw refuseLocally(field, `Invalid multipart file field: ${field}`);
-    }
-    appendMultipartFile(formData, field, value);
-  }
-  appendFormFields(formData, values, fileFields);
-  return formData;
-}
-
-// src/internal/http-input.ts
-function inputIsQuery(method) {
-  return method === "GET" || method === "DELETE";
-}
-
-// src/browser/client-url.ts
-function isParamArray(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string" || typeof item === "number");
-}
-function collectQueryParams(args, endpoint) {
-  const params = {};
-  let hasParams = false;
-  for (const [key, value] of Object.entries(args)) {
-    if (value === undefined || value === null)
-      continue;
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || isParamArray(value)) {
-      params[key] = value;
-      hasParams = true;
-      continue;
-    }
-    const what = Array.isArray(value) ? "an array with non-primitive items" : typeof value === "object" ? "a nested object" : `a ${typeof value}`;
-    throw refuseLocally(key, `${endpoint.method} ${endpoint.path}: input field "${key}" is ${what} — it cannot ` + "travel as a query parameter. GET / DELETE input must be flat (string / number / " + "boolean, or an array of string / number); flatten the field or move the " + "operation to a body verb (POST).");
-  }
-  return hasParams ? params : undefined;
-}
-function hasStringKeys(args, keys) {
-  for (const key of keys) {
-    if (typeof args[key] !== "string")
-      return false;
-  }
-  return true;
-}
-function resolvePathPrefix(config, args) {
-  if (!config?.pathPrefix)
-    return "";
-  if (typeof config.pathPrefix === "string")
-    return config.pathPrefix;
-  const keys = config.stripPrefixKeys ?? [];
-  if (!hasStringKeys(args, keys)) {
-    const missing = keys.find((key) => typeof args[key] !== "string");
-    throw refuseLocally(String(missing), `Missing path prefix key: ${missing}`);
-  }
-  return config.pathPrefix(args);
-}
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function decodePathSegment(value) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-function createClientRouteMatcher(endpoint, contractPrefix, config) {
-  if (typeof config?.pathPrefix === "function" && (!config.stripPrefixKeys || config.stripPrefixKeys.length === 0)) {
-    throw new Error("Dynamic pathPrefix matchers require stripPrefixKeys");
-  }
-  const markerByKey = {};
-  for (const [index, key] of (config?.stripPrefixKeys ?? []).entries()) {
-    markerByKey[key] = `__stitch_scope_${index}__`;
-  }
-  const pathPrefix = resolvePathPrefix(config, markerByKey);
-  const route = [pathPrefix, contractPrefix, endpoint.path === "/" ? "" : endpoint.path].filter(Boolean).join("/");
-  const patternSegments = route.split("/").filter(Boolean);
-  const wildcard = patternSegments.at(-1)?.startsWith("*") === true;
-  const fixedCount = wildcard ? patternSegments.length - 1 : patternSegments.length;
-  const markers = Object.values(markerByKey);
-  return (pathname) => {
-    const actualSegments = pathname.split("/").filter(Boolean).map(decodePathSegment);
-    if (wildcard ? actualSegments.length < fixedCount : actualSegments.length !== fixedCount) {
-      return false;
-    }
-    for (let index = 0;index < fixedCount; index += 1) {
-      const pattern = patternSegments[index];
-      const actual = actualSegments[index];
-      if (!pattern || actual === undefined)
-        return false;
-      if (pattern.startsWith(":"))
-        continue;
-      let source = escapeRegex(pattern);
-      for (const marker of markers) {
-        source = source.replaceAll(escapeRegex(marker), "[^/]+");
-      }
-      if (!new RegExp(`^${source}$`).test(actual))
-        return false;
-    }
-    return true;
-  };
-}
-function extractParamNames(path) {
-  const matches = path.match(/:(\w+)/g);
-  const names = matches ? matches.map((match) => match.slice(1)) : [];
-  const wildcard = parseTrailingWildcard(path);
-  if (wildcard)
-    names.push(wildcard.name);
-  return names;
-}
-function fillPathParams(path, args) {
-  const wildcard = parseTrailingWildcard(path);
-  let filled = path.replace(/:(\w+)/g, (_, key) => {
-    const value = args[key];
-    if (value === undefined || value === null) {
-      throw refuseLocally(String(key), `Missing path param: ${key}`);
-    }
-    return encodeURIComponent(String(value));
-  });
-  if (!wildcard)
-    return filled;
-  const wildcardValue = args[wildcard.name];
-  if (wildcardValue === undefined || wildcardValue === null) {
-    throw refuseLocally(wildcard.name, `Missing path param: ${wildcard.name}`);
-  }
-  const remainder = String(wildcardValue).split("/").map((segment) => encodeURIComponent(segment)).join("/");
-  filled = `${filled.slice(0, -(wildcard.name.length + 1))}${remainder}`;
-  return filled;
-}
-function stripConsumedArgs(args, path, scopeKeys) {
-  const consumed = new Set(scopeKeys);
-  for (const name of extractParamNames(path))
-    consumed.add(name);
-  const remaining = {};
-  for (const [key, value] of Object.entries(args)) {
-    if (!consumed.has(key) && value !== undefined)
-      remaining[key] = value;
-  }
-  return remaining;
-}
-function appendQuery(relativeUrl, params) {
-  if (!params)
-    return relativeUrl;
-  const search = new URLSearchParams;
-  for (const [key, value] of Object.entries(params)) {
-    if (Array.isArray(value)) {
-      for (const item of value)
-        search.append(key, String(item));
-    } else {
-      search.set(key, String(value));
-    }
-  }
-  return search.size > 0 ? `${relativeUrl}?${search}` : relativeUrl;
-}
-function planClientRequest(endpoint, contractPrefix, args, config) {
-  let pathPrefix = resolvePathPrefix(config, args);
-  if (pathPrefix && !pathPrefix.endsWith("/"))
-    pathPrefix += "/";
-  if (pathPrefix.startsWith("/"))
-    pathPrefix = pathPrefix.slice(1);
-  const endpointPath = endpoint.path === "/" ? "" : endpoint.path;
-  let relativeUrl = fillPathParams(`${pathPrefix}${contractPrefix}${endpointPath}`, args);
-  if (relativeUrl.endsWith("/"))
-    relativeUrl = relativeUrl.slice(0, -1);
-  const remainingArgs = stripConsumedArgs(args, endpoint.path, config?.stripPrefixKeys ?? []);
-  if (inputIsQuery(endpoint.method)) {
-    relativeUrl = appendQuery(relativeUrl, collectQueryParams(remainingArgs, endpoint));
-  }
-  return { relativeUrl, remainingArgs };
-}
-function joinClientBaseUrl(baseUrl, relativeUrl) {
-  const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-  const path = relativeUrl.startsWith("/") ? relativeUrl : `/${relativeUrl}`;
-  return `${base}${path}`;
-}
-
-// src/internal/bounded-lines.ts
-var DEFAULT_STREAM_LINE_BYTES = 1024 * 1024;
-function lineLimit(value) {
-  const resolved = value ?? DEFAULT_STREAM_LINE_BYTES;
-  if (!Number.isSafeInteger(resolved) || resolved <= 0) {
-    throw new TypeError("maxLineBytes must be a positive safe integer");
-  }
-  return resolved;
-}
-function joinBytes(left, right) {
-  if (left.byteLength === 0)
-    return right.slice();
-  const result = new Uint8Array(left.byteLength + right.byteLength);
-  result.set(left);
-  result.set(right, left.byteLength);
-  return result;
-}
-async function* readBoundedUtf8Lines(response, maxLineBytes, requireFinalNewline = false) {
-  const reader = response.body?.getReader();
-  if (!reader)
-    return;
-  const limit = lineLimit(maxLineBytes);
-  const decoder = new TextDecoder("utf-8", { fatal: true });
-  let pending = new Uint8Array;
-  try {
-    for (;; ) {
-      const chunk = await reader.read();
-      if (chunk.done)
-        break;
-      let start = 0;
-      for (let index = 0;index < chunk.value.byteLength; index += 1) {
-        if (chunk.value[index] !== 10)
-          continue;
-        const lineBytes = joinBytes(pending, chunk.value.slice(start, index));
-        if (lineBytes.byteLength > limit) {
-          throw new RangeError(`Stream line exceeds the ${limit} byte limit`);
-        }
-        yield decoder.decode(lineBytes);
-        pending = new Uint8Array;
-        start = index + 1;
-      }
-      pending = joinBytes(pending, chunk.value.slice(start));
-      if (pending.byteLength > limit) {
-        throw new RangeError(`Stream line exceeds the ${limit} byte limit`);
-      }
-    }
-    if (pending.byteLength > 0) {
-      if (requireFinalNewline) {
-        throw new SyntaxError("Stream ended with an unterminated final line");
-      }
-      yield decoder.decode(pending);
-    }
-  } finally {
-    await reader.cancel().catch(() => {
-      return;
-    });
-    reader.releaseLock();
-  }
-}
-
-// src/internal/errors.ts
-import { z } from "zod";
-function issuePath(path) {
-  return path.length > 0 ? path.map(String).join(".") : "(root)";
-}
-function formatZodError(error) {
-  const issues = error.issues.slice(0, 5);
-  const lines = issues.map((issue) => `${issuePath(issue.path)}: ${issue.message}`);
-  const suffix = error.issues.length > 5 ? `
-...and ${error.issues.length - 5} more issues` : "";
-  return lines.join(`
-`) + suffix;
-}
-function zodIssues(error) {
-  return error.issues.map((issue) => ({
-    path: issuePath(issue.path),
-    code: issue.code,
-    message: issue.message
-  }));
-}
-
-// src/server/stream.ts
-async function* parseSSE(response, options) {
-  try {
-    for await (const rawLine of readBoundedUtf8Lines(response, options?.maxLineBytes ?? DEFAULT_STREAM_LINE_BYTES)) {
-      const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-      if (!line.startsWith("data:"))
-        continue;
-      const data = line.slice(5).replace(/^ /, "");
-      if (data === "[DONE]")
-        return;
-      try {
-        yield JSON.parse(data);
-      } catch (error) {
-        const failure = error instanceof Error ? error : new Error(String(error));
-        if (!options?.onParseError)
-          throw failure;
-        options.onParseError(data, failure);
-      }
-    }
-  } catch (error) {
-    const failure = error instanceof Error ? error : new Error(String(error));
-    if (!options?.onParseError)
-      throw failure;
-    options.onParseError("", failure);
-  }
-}
-// src/browser/stream.ts
-function parseFailure(raw, error, onParseError) {
-  const failure = error instanceof Error ? error : new Error(String(error));
-  if (!onParseError)
-    throw failure;
-  onParseError(raw, failure);
-}
-async function* parseNDJSON(response, options) {
-  try {
-    for await (const rawLine of readBoundedUtf8Lines(response, options?.maxLineBytes ?? DEFAULT_STREAM_LINE_BYTES, options?.finalLine === "require-newline")) {
-      const line = (rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine).trim();
-      if (line === "")
-        continue;
-      try {
-        yield JSON.parse(line);
-      } catch (error) {
-        parseFailure(line, error, options?.onParseError);
-      }
-    }
-  } catch (error) {
-    parseFailure("", error, options?.onParseError);
-  }
-}
-
-// src/browser/contract-stream.ts
-function sourceFor(response, descriptor) {
-  const options = {
-    maxLineBytes: descriptor.maxFrameBytes ?? DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
-    finalLine: descriptor.finalLine
-  };
-  return descriptor.format === "sse" ? parseSSE(response, options) : parseNDJSON(response, options);
-}
-async function* readContractStream(response, descriptor, abort) {
-  let ended = false;
-  let terminalSeen = descriptor.terminal === undefined;
-  const source = sourceFor(response, descriptor);
-  try {
-    for (;; ) {
-      const next = await source.next();
-      if (next.done)
-        break;
-      let candidate = next.value;
-      if (descriptor.framing !== "item") {
-        const parsedFrame = ContractStreamFrameSchema.safeParse(candidate);
-        if (!parsedFrame.success) {
-          throw new ApiError("STREAM_PROTOCOL_ERROR", 0, undefined, "Stream frame did not match the protocol envelope");
-        }
-        const frame = parsedFrame.data;
-        if (frame.type === "error") {
-          throw new ApiError(frame.error.code, 0, frame.error.details, frame.error.message, frame.error.hint);
-        }
-        if (frame.type === "end") {
-          if (!terminalSeen) {
-            throw new ApiError("STREAM_TERMINAL_MISSING", 0, undefined, "Stream completed before its declared terminal item");
-          }
-          ended = true;
-          return;
-        }
-        candidate = frame.data;
-      }
-      const parsedItem = descriptor.item.safeParse(candidate);
-      if (!parsedItem.success) {
-        throw new ApiError("STREAM_ITEM_INVALID", 0, undefined, "Stream item did not match its contract");
-      }
-      const item = parsedItem.data;
-      const terminal = descriptor.terminal?.safeParse(item).success ?? false;
-      if (terminal)
-        terminalSeen = true;
-      if (terminal && descriptor.completion === "terminal") {
-        abort();
-        await source.return(undefined);
-        ended = true;
-      }
-      yield item;
-      if (ended)
-        return;
-    }
-    if (descriptor.framing === "item") {
-      if (terminalSeen)
-        return;
-      throw new ApiError("STREAM_TERMINAL_MISSING", 0, undefined, "Stream completed before its declared terminal item");
-    }
-    if (!ended) {
-      throw new ApiError("STREAM_TRUNCATED", 0, undefined, "Stream ended without its protocol terminal frame");
-    }
-  } finally {
-    abort();
-    await source.return(undefined);
-  }
-}
-
-class OwnedContractStream {
-  #inner;
-  #abort;
-  constructor(inner, abort) {
-    this.#inner = inner;
-    this.#abort = abort;
-  }
-  [Symbol.asyncIterator]() {
-    return this;
-  }
-  next() {
-    return this.#inner.next();
-  }
-  return() {
-    this.#abort();
-    return this.#inner.return(undefined);
-  }
-  throw(error) {
-    this.#abort();
-    return this.#inner.throw(error);
-  }
-}
-function parseContractStream(response, descriptor, abort) {
-  return new OwnedContractStream(readContractStream(response, descriptor, abort), abort);
-}
-
-// src/browser/client.ts
-function withTimeout(options, endpoint) {
-  const responseType = endpoint.rawResponse || "stream" in endpoint ? "response" : endpoint.output ? undefined : "void";
-  if (endpoint.timeout === undefined && responseType === undefined)
-    return options;
-  return {
-    ...options,
-    ...endpoint.timeout !== undefined && { timeout: endpoint.timeout },
-    ...responseType && { responseType }
-  };
-}
-function withOutput(endpoint, result, abortStream) {
-  if (endpoint.rawResponse)
-    return result;
-  if ("stream" in endpoint && endpoint.stream) {
-    return result.then((value) => {
-      if (!(value instanceof Response)) {
-        abortStream?.();
-        throw new Error("Streaming endpoint did not return a Response");
-      }
-      return parseContractStream(value, endpoint.stream, abortStream ?? (() => {
-        return;
-      }));
-    }, (error) => {
-      abortStream?.();
-      throw error;
-    });
-  }
-  const schema = endpoint.output;
-  return result.then((value) => {
-    if (!schema) {
-      if (value === undefined || value === null)
-        return;
-      throw new Error("Server returned data for an endpoint with no output contract");
-    }
-    if (value === undefined) {
-      throw new Error("Server returned no body for an endpoint with an output contract");
-    }
-    return schema.parse(value);
-  });
-}
-function contractEndpointMatchers(contract, endpointNames, contractConfig) {
-  const selected = endpointNames ? new Set(endpointNames) : null;
-  const matchers = [];
-  for (const [key, endpoint] of typedEntries(contract.endpoints)) {
-    if (selected && !selected.has(key))
-      continue;
-    if (endpoint.expose && !endpoint.expose.includes("HTTP")) {
-      if (selected) {
-        throw new Error(`Cannot create an HTTP route matcher for non-HTTP endpoint: ${String(key)}`);
-      }
-      continue;
-    }
-    matchers.push(createClientRouteMatcher(endpoint, contract.meta.prefix, contractConfig));
-  }
-  if (selected && matchers.length !== selected.size) {
-    throw new Error("Cannot create an HTTP route matcher for an unknown endpoint");
-  }
-  return matchers;
-}
-function createClient(contract, configOrClient, contractConfig) {
-  const client = {};
-  const makeExecutor = isHttpAdapter(configOrClient) ? (endpoint) => createHttpExecutor(endpoint, contract.meta.prefix, configOrClient, contractConfig) : (endpoint) => createFetchExecutor(endpoint, contract.meta.prefix, configOrClient, contractConfig);
-  for (const [key, endpoint] of typedEntries(contract.endpoints)) {
-    if (endpoint.expose && !endpoint.expose.includes("HTTP"))
-      continue;
-    setClientMethod(client, key, createEndpointMethod(endpoint, makeExecutor(endpoint), contractConfig));
-  }
-  return client;
-}
-function createClients(contracts, configOrClient, contractConfig) {
-  return mapObject(contracts, (_key, contract) => createClient(contract, configOrClient, contractConfig));
-}
-function buildScopedRegistry(contracts, scopeConfigs, surfaceName, build) {
-  const registry = {};
-  for (const [namespace, value] of Object.entries(contracts)) {
-    const list = Array.isArray(value) ? value : [value];
-    const surface = {};
-    for (const contract of list) {
-      const scope = contract.meta.scope;
-      if (!scope) {
-        throw new Error(`Contract in ${surfaceName} namespace "${namespace}" has no scope`);
-      }
-      const scopeConfig = scopeConfigs[scope];
-      if (!scopeConfig) {
-        throw new Error(`Missing ${surfaceName} config for scope: ${scope}`);
-      }
-      for (const [methodName, method] of Object.entries(build(contract, scopeConfig))) {
-        if (Object.hasOwn(surface, methodName)) {
-          throw new Error(`${surfaceName[0]?.toUpperCase()}${surfaceName.slice(1)} namespace "${namespace}" has duplicate method: ${methodName}`);
-        }
-        surface[methodName] = method;
-      }
-    }
-    registry[namespace] = surface;
-  }
-  return registry;
-}
-function createScopedClients(contracts, configOrClient, scopeConfigs) {
-  return buildScopedRegistry(contracts, scopeConfigs, "client", (contract, config) => createClient(contract, configOrClient, config));
-}
-function isHttpAdapter(value) {
-  return typeof value === "object" && "get" in value && typeof value.get === "function";
-}
-function setClientMethod(target, key, method) {
-  target[key] = method;
-}
-function createEndpointMethod(endpoint, execute, contractConfig) {
-  const hasScopedArguments = (contractConfig?.stripPrefixKeys?.length ?? 0) > 0;
-  if (endpointHasArguments(endpoint) || hasScopedArguments) {
-    const method2 = (requestArgs) => settle(execute, readClientRequestArgs(requestArgs), undefined);
-    return Object.assign(method2, {
-      withOptions: (...args) => {
-        refuseExtraWithOptionsArguments(endpoint, args.length, 2);
-        return settle(execute, readClientRequestArgs(args[0]), readClientRequestOptions(args[1]));
-      }
-    });
-  }
-  const method = () => settle(execute, {}, undefined);
-  return Object.assign(method, {
-    withOptions: (...args) => {
-      refuseExtraWithOptionsArguments(endpoint, args.length, 1);
-      return settle(execute, {}, readClientRequestOptions(args[0]));
-    }
-  });
-}
-function settle(execute, requestArgs, options) {
-  try {
-    return execute(requestArgs, options);
-  } catch (error) {
-    return Promise.reject(error);
-  }
-}
-function refuseExtraWithOptionsArguments(endpoint, received, expected) {
-  if (received <= expected)
-    return;
-  const shape = expected === 1 ? "withOptions(options)" : "withOptions(args, options)";
-  throw new TypeError(`${endpoint.method} ${endpoint.path}: this endpoint declares ${expected === 1 ? "no input" : "an input"}, so its method is ${shape} — it received ${received} arguments. ` + "An extra argument here is dropped, and a request options object in the dropped position " + "sends the request without them: an abort signal placed there never reaches the server.");
-}
-function createHttpExecutor(endpoint, prefix, client, config) {
-  const httpMethod = endpoint.method.toLowerCase();
-  return (requestArgs, options) => {
-    const plan = planClientRequest(endpoint, prefix, requestArgs, config);
-    const streamAbort = "stream" in endpoint ? new AbortController : undefined;
-    const requestOptions = streamAbort ? {
-      ...options,
-      signal: options?.signal ? AbortSignal.any([options.signal, streamAbort.signal]) : streamAbort.signal
-    } : options;
-    const finishStream = streamAbort ? () => streamAbort.abort() : undefined;
-    if (endpoint.multipart) {
-      if (httpMethod === "get" || httpMethod === "head" || httpMethod === "delete") {
-        throw new Error(`Multipart endpoint ${endpoint.method} ${endpoint.path} must be POST / PUT / PATCH`);
-      }
-      const formData = buildMultipartForm(endpoint.multipart, plan.remainingArgs);
-      return withOutput(endpoint, client[httpMethod](plan.relativeUrl, formData, withTimeout(requestOptions, endpoint)), finishStream);
-    }
-    if (httpMethod === "get" || httpMethod === "head") {
-      return withOutput(endpoint, client[httpMethod](plan.relativeUrl, withTimeout(requestOptions, endpoint)), finishStream);
-    }
-    if (httpMethod === "delete") {
-      return withOutput(endpoint, client.delete(plan.relativeUrl, withTimeout(requestOptions, endpoint)), finishStream);
-    }
-    return withOutput(endpoint, client[httpMethod](plan.relativeUrl, Object.keys(plan.remainingArgs).length > 0 ? plan.remainingArgs : undefined, withTimeout(requestOptions, endpoint)), finishStream);
-  };
-}
-function createFetchExecutor(endpoint, prefix, config, contractConfig) {
-  const executeFetch = config.fetch ?? globalThis.fetch;
-  return async (requestArgs, options) => {
-    const plan = planClientRequest(endpoint, prefix, requestArgs, contractConfig);
-    const url = joinClientBaseUrl(config.baseUrl, plan.relativeUrl);
-    const headers = {
-      Accept: "application/json",
-      ...typeof config.headers === "function" ? config.headers() : config.headers
-    };
-    const streamAbort = "stream" in endpoint ? new AbortController : undefined;
-    const requestSignal = streamAbort ? options?.signal ? AbortSignal.any([options.signal, streamAbort.signal]) : streamAbort.signal : options?.signal;
-    const openTimeoutMs = endpoint.timeout ?? config.timeout ?? 30000;
-    const cancellation = streamAbort ? {
-      signal: requestSignal,
-      async run(operation) {
-        let timedOut = false;
-        const timer = setTimeout(() => {
-          timedOut = true;
-          streamAbort.abort(new DOMException("Request timed out", "TimeoutError"));
-        }, openTimeoutMs);
-        try {
-          if (options?.signal?.aborted)
-            throw new RequestCancellationError("caller");
-          return await operation(requestSignal);
-        } catch (error) {
-          if (timedOut)
-            throw new RequestCancellationError("timeout");
-          if (options?.signal?.aborted)
-            throw new RequestCancellationError("caller");
-          throw error;
-        } finally {
-          clearTimeout(timer);
-        }
-      }
-    } : createRequestCancellation(requestSignal, openTimeoutMs);
-    const hasBody = endpoint.method !== "GET" && endpoint.method !== "HEAD" && endpoint.method !== "DELETE" && !endpoint.multipart && endpoint.input && Object.keys(plan.remainingArgs).length > 0;
-    if (hasBody)
-      headers["Content-Type"] = "application/json";
-    try {
-      return await cancellation.run(async (signal) => {
-        const body = endpoint.multipart ? buildMultipartForm(endpoint.multipart, plan.remainingArgs) : hasBody ? JSON.stringify(plan.remainingArgs) : undefined;
-        const res = await executeFetch(url, {
-          method: endpoint.method,
-          headers,
-          credentials: config.credentials,
-          signal,
-          ...body !== undefined && { body }
-        });
-        if (!res.ok) {
-          await throwForErrorResponse(res, config, { error: res.statusText });
-        }
-        if (endpoint.rawResponse)
-          return res;
-        if ("stream" in endpoint && endpoint.stream) {
-          return parseContractStream(res, endpoint.stream, () => streamAbort?.abort());
-        }
-        if (!endpoint.output) {
-          const text = await res.text();
-          if (text.length > 0) {
-            throw new Error("Server returned data for an endpoint with no output contract");
-          }
-          return;
-        }
-        return endpoint.output.parse(await res.json());
-      });
-    } catch (error) {
-      if (error instanceof RequestCancellationError) {
-        throw new ApiError(error.cause === "caller" ? "REQUEST_ABORTED" : "REQUEST_TIMEOUT", 0, undefined, error.message);
-      }
-      if (ApiError.is(error))
-        throw error;
-      const message = error instanceof Error ? error.message : undefined;
-      throw new ApiError("UNKNOWN_ERROR", 0, message ? { message } : undefined, message, undefined, undefined, { cause: error });
-    }
-  };
-}
-function endpointHasArguments(endpoint) {
-  return Boolean(endpoint.params || endpoint.input || endpoint.multipart);
-}
-function readClientRequestArgs(requestArgs) {
-  if (requestArgs !== undefined && !isRecord(requestArgs)) {
-    throw new TypeError("Endpoint arguments must be an object");
-  }
-  return requestArgs ?? {};
-}
-function readClientRequestOptions(value) {
-  if (!isRecord(value))
-    throw new TypeError("Client request options must be an object");
-  const signal = value.signal;
-  if (signal === undefined)
-    return {};
-  if (!isAbortSignal(signal)) {
-    throw new TypeError("Client request signal must be an AbortSignal");
-  }
-  return { signal };
-}
-function isAbortSignal(value) {
-  return typeof value === "object" && value !== null && "aborted" in value && typeof value.aborted === "boolean" && "addEventListener" in value && typeof value.addEventListener === "function" && "removeEventListener" in value && typeof value.removeEventListener === "function";
-}
-async function throwForErrorResponse(res, config, fallbackBody) {
-  const body = await res.json().catch(() => fallbackBody);
-  config.onError?.(res.status, body);
-  const parsed = parseApiErrorBody(body);
-  if (parsed) {
-    throw new ApiError(parsed.code, res.status, parsed.details, parsed.message, parsed.hint, responseTraceId(res));
-  }
-  throw new ApiError("HTTP_ERROR", res.status, { body }, undefined, undefined, responseTraceId(res));
-}
-function createUrlBuilder(contract, source, contractConfig) {
-  const builder = {};
-  for (const [key, endpoint] of typedEntries(contract.endpoints)) {
-    if (endpoint.expose && !endpoint.expose.includes("HTTP"))
-      continue;
-    setClientMethod(builder, key, (args) => {
-      const plan = planClientRequest(endpoint, contract.meta.prefix, args ?? {}, contractConfig);
-      if (endpoint.method !== "GET" && endpoint.method !== "DELETE" && Object.keys(plan.remainingArgs).length > 0) {
-        const fields = Object.keys(plan.remainingArgs).join(", ");
-        throw new Error(`URL builder for ${endpoint.method} ${endpoint.path} received non-URL fields: ${fields}`);
-      }
-      return joinClientBaseUrl(source.baseUrl, plan.relativeUrl);
-    });
-  }
-  return builder;
-}
-function createUrlBuilders(contracts, source, contractConfig) {
-  return mapObject(contracts, (_key, contract) => createUrlBuilder(contract, source, contractConfig));
-}
-function createScopedUrlBuilders(contracts, source, scopeConfigs) {
-  return buildScopedRegistry(contracts, scopeConfigs, "URL builder", (contract, config) => createUrlBuilder(contract, source, config));
-}
-// src/browser/resumable.ts
-import { z as z2 } from "zod";
-var PositiveSafeIntegerSchema = z2.number().int().positive().safe();
-var BackoffPolicySchema = z2.object({
-  minDelayMs: PositiveSafeIntegerSchema,
-  maxDelayMs: PositiveSafeIntegerSchema,
-  jitter: z2.number().min(0).max(1)
-}).strict().readonly().refine((policy) => policy.maxDelayMs >= policy.minDelayMs, {
-  message: "maxDelayMs must be at least minDelayMs"
-});
-function createBackoff(policy, random = Math.random) {
-  const { minDelayMs, maxDelayMs, jitter } = BackoffPolicySchema.parse(policy);
-  let attempt = 0;
-  return {
-    next() {
-      const exponential = Math.min(maxDelayMs, minDelayMs * 2 ** attempt);
-      attempt += 1;
-      const spread = exponential * jitter * random();
-      return Math.max(1, Math.round(exponential - spread));
-    },
-    reset() {
-      attempt = 0;
-    }
-  };
-}
-var DEFAULT_RETRY = { minDelayMs: 100, maxDelayMs: 30000, jitter: 0.5 };
-
-class ResumableAbortError extends Error {
-  constructor() {
-    super("Resumable iterator was aborted");
-    this.name = "ResumableAbortError";
-  }
-}
-function sleep(ms, signal) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    function onAbort() {
-      clearTimeout(timer);
-      reject(new ResumableAbortError);
-    }
-    if (signal?.aborted) {
-      clearTimeout(timer);
-      reject(new ResumableAbortError);
-      return;
-    }
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-async function* resumableIterator(config) {
-  const backoff = createBackoff(config.retry ?? DEFAULT_RETRY, config.random);
-  let cursor;
-  let attempt = 0;
-  for (;; ) {
-    if (config.signal?.aborted)
-      return;
-    try {
-      const source = await config.open(cursor);
-      for await (const item of source) {
-        if (config.signal?.aborted)
-          return;
-        attempt = 0;
-        backoff.reset();
-        cursor = config.advance(item, cursor);
-        yield item;
-        if (config.isTerminal?.(item))
-          return;
-      }
-      throw new Error("Resumable source ended without a terminal item");
-    } catch (error) {
-      if (config.signal?.aborted || error instanceof ResumableAbortError)
-        return;
-      attempt += 1;
-      const delayMs = backoff.next();
-      config.onAttempt?.({ number: attempt, delayMs, error });
-      try {
-        await sleep(delayMs, config.signal);
-      } catch {
-        return;
-      }
-    }
-  }
-}
-// 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/request.ts
-import { z as z3 } from "zod";
-var RealtimeRequestPhaseSchema = z3.enum([
-  "engine-handoff",
-  "engine-ack-received",
-  "settled",
-  "timeout",
-  "disconnected"
-]);
-var RealtimeRequestPhaseEventSchema = z3.object({
-  requestId: z3.string().min(1),
-  event: z3.string().min(1),
-  phase: RealtimeRequestPhaseSchema,
-  elapsedMs: z3.number().finite().nonnegative()
-}).strict();
-
-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;
-  }
-}
-
-class RealtimeRequestRejectedError extends Error {
-  code = "REALTIME_REQUEST_REJECTED";
-  event;
-  reason;
-  issues;
-  constructor(event, reason, detail, issues) {
-    super(`Realtime request "${event}" was rejected by the peer (${reason}): ${detail}`);
-    this.name = "RealtimeRequestRejectedError";
-    this.event = event;
-    this.reason = reason;
-    this.issues = issues;
-  }
-}
-
-// 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/realtime/rejection.ts
-import { z as z4 } from "zod";
-function realtimeContractViolation(options) {
-  const issues = options.cause instanceof z4.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;
-    }
-  };
-}
-
+} from "./index-0w9abg87.js";
+import"./index-kzfs85xp.js";
+import"./index-77fekveh.js";
 // src/retained.ts
 function createRetainedTopics() {
   const last = {};
@@ -2066,26 +563,6 @@ function createSocketIOClientInternal(config, onRequestPhase) {
     }
   };
 }
-// src/realtime/contract.ts
-import { z as z5 } from "zod";
-function defineRealtimeContract(contract) {
-  return contract;
-}
-var RealtimeRejectDirectionSchema = z5.enum([
-  "client-inbound",
-  "client-outbound",
-  "server-inbound",
-  "server-outbound"
-]);
-var RealtimeRejectPhaseSchema = z5.enum(["arguments", "acknowledgement"]);
-var RealtimeRejectReasonSchema = z5.enum([
-  "unknown-event",
-  "invalid-arguments",
-  "invalid-acknowledgement-value",
-  "missing-acknowledgement",
-  "rejected-by-peer"
-]);
-var RealtimeRejectFaultSchema = z5.enum(["peer", "local"]);
 export {
   zodIssues,
   unauthorized,