stitchkit 0.93.0 → 0.94.1

package/dist/index-ham5sz8m.js

@@ -0,0 +1,734 @@
+import {
+  inputIsQuery
+} from "./index-48ffdxgk.js";
+import {
+  ContractStreamFrameSchema,
+  DEFAULT_CONTRACT_STREAM_FRAME_BYTES
+} from "./index-wqgjfstn.js";
+import {
+  ApiError,
+  RequestCancellationError,
+  createRequestCancellation,
+  parseApiErrorBody,
+  refuseLocally,
+  responseTraceId
+} from "./index-v260df89.js";
+import {
+  parseTrailingWildcard
+} from "./index-4gcnakhx.js";
+import {
+  isRecord,
+  mapObject,
+  typedEntries
+} from "./index-hffjpmq9.js";
+
+// 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/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);
+  }
+}
+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/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/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/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-executors.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 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 });
+    }
+  };
+}
+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));
+}
+
+// src/browser/client.ts
+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 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";
+}
+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));
+}
+
+export { parseNDJSON, parseSSE, contractEndpointMatchers, createClient, createClients, createScopedClients, createUrlBuilder, createUrlBuilders, createScopedUrlBuilders };