@temporary-name/server 0.0.1-alpha.0cb08cf84b740850e7d8dcd1d8b87f78af26071b

package/dist/index.mjs

@@ -0,0 +1,831 @@
+import { U as UnauthorizedError, z as zEmptyObject, w as wrapShape, I as InternalServerError, N as NotFoundError, F as ForbiddenError, B as BadRequestError, p as parseEndpointDefinition, u as unlazyResources } from './shared/server.D7jtfDRy.mjs';
+export { A as ApiError, j as BadGatewayError, C as ConflictError, c as ContentTooLargeError, G as GatewayTimeoutError, M as MethodNotAllowedError, b as NotAcceptableError, h as NotImplementedError, P as PreconditionFailedError, R as RequestTimeoutError, S as ServiceUnavailableError, T as TooManyRequestsError, f as UnprocessableContentError, d as UnsupportedMediaTypeError, V as ValidationError, a as apiResource, e as encodeError, m as endpointRegex, g as getDynamicParams, k as isApiErrorStatus, n as isDevelopment, i as isLazyResource, l as lazyResource, s as standardizeHTTPPath, t as toApiError, v as validateLazyLoadedResource } from './shared/server.D7jtfDRy.mjs';
+import * as z from '@temporary-name/zod';
+import { KrustyObject } from '@temporary-name/zod';
+import { assertNever, splitFirst, isObject, toArray, guard, isTypescriptObject, isPropertyKey, clone } from '@temporary-name/shared';
+export { AsyncIteratorClass, EventPublisher, asyncIteratorToStream as eventIteratorToStream, streamToAsyncIteratorClass as streamToEventIterator } from '@temporary-name/shared';
+import { g as getCookie } from './shared/server.C1RJffw4.mjs';
+export { S as StandardHandler, a as StandardOpenAPIMatcher, c as callMethod, d as decode, b as decodeParams, e as encode, g as getEndpointId, m as mergeContext, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from './shared/server.JwVIEHL6.mjs';
+import { J as JsonSchemaXNativeType, d as getNamesByAuthConfig } from './shared/server.RQr7F4gX.mjs';
+export { z as JSON_SCHEMA_INPUT_REGISTRY, A as JSON_SCHEMA_OUTPUT_REGISTRY, y as JSON_SCHEMA_REGISTRY, Z as ZodToJsonSchemaConverter, w as eventIterator, x as getEventIteratorSchemaDetails } from './shared/server.RQr7F4gX.mjs';
+import z$1 from 'zod';
+import '@temporary-name/interop/json-schema-typed/draft-2020-12';
+export { getEventMeta, withEventMeta } from '@temporary-name/standard-server';
+import 'cookie';
+import '@temporary-name/server';
+import 'neoqs';
+import 'rou3';
+import '@temporary-name/server/openapi';
+import 'zod/v4/core';
+
+function validateTokenPrefix(prefix, token) {
+  if (prefix && !token.startsWith(prefix)) {
+    throw new UnauthorizedError({ message: `Invalid auth token. It must start with "${prefix}"` });
+  }
+}
+function validateTokenAuth(config, token, options) {
+  const { tokenPrefix, validate } = config;
+  validateTokenPrefix(tokenPrefix, token);
+  return validate(token, options);
+}
+function runAuth(config, options) {
+  switch (config.type) {
+    case "header": {
+      const authHeader = options.request.headers.get(config.name);
+      return authHeader ? validateTokenAuth(config, authHeader, options) : void 0;
+    }
+    case "query": {
+      const { name, tokenPrefix, validate } = config;
+      const query = options.request.url.searchParams;
+      const token = query.get(name);
+      if (!token) return void 0;
+      validateTokenPrefix(tokenPrefix, token);
+      return validate(token, options);
+    }
+    case "cookie": {
+      const cookie = getCookie(options.request.headers, config.name);
+      return cookie ? validateTokenAuth(config, cookie, options) : void 0;
+    }
+    case "bearer": {
+      const authHeader = options.request.headers.get("Authorization");
+      if (!authHeader) return void 0;
+      const [authType, bearer] = splitFirst(authHeader, " ");
+      return authType === "Bearer" ? validateTokenAuth(config, bearer, options) : void 0;
+    }
+    case "basic": {
+      const authHeader = options.request.headers.get("Authorization");
+      if (!authHeader) return void 0;
+      const [authType, encoded] = splitFirst(authHeader, " ");
+      if (authType !== "Basic") return void 0;
+      const decoded = Buffer.from(encoded, "base64").toString("utf-8");
+      const [username, password] = splitFirst(decoded, ":");
+      validateTokenPrefix(config.tokenPrefix, password);
+      return config.validate(username, password, options);
+    }
+    case "none": {
+      return false;
+    }
+    default: {
+      assertNever(config);
+    }
+  }
+}
+function authDescription(config) {
+  const { type } = config;
+  return type === "basic" ? "a Basic Authentication header" : type === "bearer" ? "a Bearer Authentication header" : type === "header" ? `a header named "${config.name}"` : type === "query" ? `a query parameter named "${config.name}"` : type === "cookie" ? `a cookie named "${config.name}"` : type === "none" ? "no authentication" : assertNever(type);
+}
+
+function mergeMeta(meta1, meta2) {
+  return { ...meta1, ...meta2 };
+}
+
+class Contract {
+  /**
+   * The contract definition
+   */
+  "~def";
+  constructor(def) {
+    this["~def"] = def;
+  }
+}
+class DecoratedContract extends Contract {
+  implement(handler) {
+    return new Method(this["~def"], handler);
+  }
+}
+class Method extends Contract {
+  handler;
+  constructor(def, handler) {
+    super(def);
+    this.handler = handler;
+  }
+}
+
+const defaultMiddlewareSchemas = {
+  pathSchema: zEmptyObject,
+  querySchema: zEmptyObject,
+  headersSchema: zEmptyObject,
+  // Body is special because the schema doesn't have to be an object. We don't want a default middleware to
+  // fail validation if a method has a non-object body schema. So the default schema here just gives the
+  // middleware an empty object regardless of what the body actually is.
+  bodySchema: z.transform(() => ({}))
+};
+class Middleware {
+  "~def";
+  handler;
+  constructor(options) {
+    let realOptions;
+    if (typeof options === "function") {
+      this.handler = options;
+      this["~def"] = {
+        schemas: defaultMiddlewareSchemas
+      };
+    } else {
+      this.handler = options.handler;
+      realOptions = options;
+      this["~def"] = {
+        schemas: {
+          pathSchema: wrapShape(realOptions.path ?? defaultMiddlewareSchemas.pathSchema),
+          querySchema: wrapShape(
+            realOptions.query ?? defaultMiddlewareSchemas.querySchema
+          ),
+          headersSchema: wrapShape(
+            realOptions.headers ?? defaultMiddlewareSchemas.headersSchema
+          ),
+          bodySchema: wrapShape(realOptions.body ?? defaultMiddlewareSchemas.bodySchema)
+        }
+      };
+    }
+  }
+}
+
+function onStart(callback) {
+  return async (options) => {
+    await callback(options);
+    return await options.next();
+  };
+}
+function onSuccess(callback) {
+  return async (options) => {
+    const result = await options.next();
+    await callback(result.response, options);
+    return result;
+  };
+}
+function onError(callback) {
+  return async (options) => {
+    try {
+      return await options.next();
+    } catch (error) {
+      await callback(error, options);
+      throw error;
+    }
+  };
+}
+function onFinish(callback) {
+  return async (options) => {
+    let state;
+    try {
+      const result = await options.next();
+      state = [void 0, result.response, true];
+      return result;
+    } catch (error) {
+      state = [error, void 0, false];
+      throw error;
+    } finally {
+      await callback(state, options);
+    }
+  };
+}
+
+const VERSION_HEADER_DEFAULT = "Api-Version";
+
+class Builder {
+  #def;
+  z;
+  constructor(def) {
+    this.#def = def;
+    this.z = new z.SchemaClass();
+  }
+  #getMiddlewareOnlyKeys(schemas, schemaType) {
+    const middlewareOnlyKeys = /* @__PURE__ */ new Set();
+    const methodSchema = schemas[schemaType];
+    if (!(methodSchema instanceof z.core.$ZodObject)) {
+      return middlewareOnlyKeys;
+    }
+    const catchallType = methodSchema._zod.def.catchall?._zod.def.type;
+    if (catchallType && catchallType !== "never") {
+      return middlewareOnlyKeys;
+    }
+    const methodShape = methodSchema._zod.def.shape;
+    for (const middleware of this.#def.middlewares) {
+      const middlewareSchema = middleware["~def"].schemas[schemaType];
+      if (middlewareSchema instanceof z.core.$ZodObject) {
+        for (const key in middlewareSchema._zod.def.shape) {
+          if (!Object.hasOwn(methodShape, key)) {
+            middlewareOnlyKeys.add(key);
+          }
+        }
+      }
+    }
+    return middlewareOnlyKeys;
+  }
+  /**
+   * Adds context fields to the builder that will be passed to middleware and the handler. These fields
+   * (unless already provided by earlier middleware) are passed in when calling `handle` on the server adapter
+   * (e.g. `NodeHttpHandler`).
+   *
+   * When calling `use` with a middleware that has required context, the builder must already have that
+   * context, either by calling `requireContext` or by using another middleware that provides it.
+   */
+  // NB: The CompatibleContext constraint ensures that any overlapping fields between U and TCurrentContext
+  // are compatible. This is necessary because fields in TInitialContext can get overwritten in middleware
+  // by fields in TCurrentContext.
+  requireContext() {
+    return this;
+  }
+  /**
+   * Creates a middleware.
+   */
+  middleware(options) {
+    return new Middleware(options);
+  }
+  /**
+   * Sets or updates the metadata for the contract.
+   * The provided metadata is spared-merged with any existing metadata in the contract.
+   */
+  meta(meta) {
+    return new Builder({
+      ...this.#def,
+      meta: mergeMeta(this.#def.meta, meta)
+    });
+  }
+  /**
+   * Returns a builder that adds the given prefix to all methods.
+   * The prefix is post-appended to any existing prefix.
+   */
+  prefix(prefix) {
+    return new this.constructor({
+      ...this.#def,
+      prefix: this.#def.prefix ? `${this.#def.prefix}${prefix}` : prefix
+    });
+  }
+  method(endpoint, options) {
+    return this.contract(
+      endpoint,
+      options
+    ).implement(options.handler);
+  }
+  contract(endpoint, options) {
+    const { method, path, pathSchema } = parseEndpointDefinition(endpoint, options.path);
+    const prefixedPath = (this.#def.prefix ?? "") + path;
+    const schemas = {
+      pathSchema,
+      querySchema: wrapShape(options.query ?? zEmptyObject),
+      headersSchema: wrapShape(options.headers ?? zEmptyObject),
+      bodySchema: wrapShape(options.body ?? zEmptyObject),
+      responseSchema: wrapShape(options.response)
+    };
+    return new DecoratedContract({
+      ...this.#def,
+      methodConfig: { ...options, method, path: prefixedPath },
+      schemas,
+      middlewareOnlyKeys: {
+        query: this.#getMiddlewareOnlyKeys(schemas, "querySchema"),
+        body: this.#getMiddlewareOnlyKeys(schemas, "bodySchema")
+      }
+    });
+  }
+  /**
+   * Adds a middleware to the pipeline. This builder's current context must satisfy the middleware's required
+   * context. If it doesn't, you can call `requireContext` on the builder to add it, or call `use` with
+   * another middleware that provides it.
+   */
+  // Implementation note: We could automatically add any context from the middleware that's missing in the
+  // builder to TInitialContext here, but we don't because:
+  //
+  // 1. The caller might be expecting that the context is already satisfied. The current design immediately
+  // surfaces that as a type error, whereas automatic merging would result in a distant type error at the
+  // server's entrypoint where `.handle()` (on NodeHttpHandler or equivalent) is called, and it could be a
+  // pain to track that down to the individual middleware that added it (especially if that middleware comes
+  // from a third-party library).
+  //
+  // 2. This approach is more explicit, and results in all the required context generally being added in a
+  // a single location (whereever the main `api` builder is created).
+  //
+  // 3. There are some tricky type safety issues around automatically merging contexts, because fields on
+  // TInitialContext can be overwritten by other middleware. There are ways to make it work but this is much
+  // simpler.
+  use(middleware) {
+    const instance = middleware instanceof Middleware ? middleware : new Middleware(middleware);
+    return new this.constructor({
+      ...this.#def,
+      middlewares: [...this.#def.middlewares, instance]
+    });
+  }
+  useErrors(errorMap) {
+    return new this.constructor({
+      ...this.#def,
+      errorMap: { ...this.#def.errorMap, ...errorMap }
+    });
+  }
+  // The default of false for ValidatedAuthContext is used when you pass in the type 'none'. We use false
+  // because we can't use null or undefined (see ValidatedAuthContext) but we still want it to be falsy.
+  useAuth(config) {
+    const middleware = this.middleware(async (options) => {
+      const { next, context } = options;
+      const contextAuth = context.auth;
+      if (contextAuth) return next();
+      const auth = await runAuth(config, options);
+      if (auth === void 0) {
+        const { authConfigs } = options.method["~def"];
+        if (contextAuth !== false && config === authConfigs.at(-1)) {
+          let authDescriptions = authConfigs.map(authDescription).join(", ");
+          if (authConfigs.length > 1) {
+            authDescriptions = `one of: ${authDescriptions}`;
+          }
+          throw new UnauthorizedError({
+            message: `Authentication required. You must provide ${authDescriptions}`
+          });
+        }
+        return next();
+      }
+      return next({ context: { auth } });
+    });
+    return new this.constructor({
+      ...this.#def,
+      authConfigs: [...this.#def.authConfigs, config],
+      middlewares: [...this.#def.middlewares, middleware]
+    });
+  }
+  useVersioning(config) {
+    const versionHeaderName = config?.headerName ?? VERSION_HEADER_DEFAULT;
+    const validate = config && "validate" in config && config.validate ? config.validate : (version) => {
+      if (config && "versions" in config && config.versions && !config.versions.includes(version)) {
+        throw new BadRequestError({
+          code: "version_header",
+          message: `Version header '${versionHeaderName}: ${version}' is unknown. Known versions are ${config.versions.map((version2) => JSON.stringify(version2)).join(", ")}`
+        });
+      }
+      return version;
+    };
+    const middleware = this.middleware({
+      headers: { [versionHeaderName]: z.string() },
+      handler: async (options) => {
+        const { next, headers } = options;
+        const versionHeaderValue = headers[versionHeaderName];
+        const version = await validate(versionHeaderValue, options);
+        return next({ context: { version } });
+      }
+    });
+    return new this.constructor({
+      ...this.#def,
+      middlewares: [...this.#def.middlewares, middleware]
+    });
+  }
+  useGating(gates, isGateEnabled) {
+    return this.use(({ next, context }) => {
+      return z.gatingContext.run(
+        (gate) => isGateEnabled(gate, context),
+        () => next({ context: { isGateEnabled } })
+      );
+    });
+  }
+}
+const baseApi = new Builder({
+  meta: {},
+  errorMap: { BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, InternalServerError },
+  middlewares: [],
+  authConfigs: []
+}).use(
+  onError((error, _options) => {
+    console.dir(error, { depth: null });
+  })
+);
+
+const FLEXIBLE_DATE_FORMAT_REGEX = /^[^-]+-[^-]+-[^-]+$/;
+class experimental_JsonSchemaCoercer {
+  coerce(schema, value, options = {}) {
+    const [, coerced] = this.#coerce(schema, value, options);
+    return coerced;
+  }
+  #coerce(schema, originalValue, options) {
+    if (typeof schema === "boolean") {
+      return [schema, originalValue];
+    }
+    if (Array.isArray(schema.type)) {
+      return this.#coerce(
+        {
+          anyOf: schema.type.map((type) => ({ ...schema, type }))
+        },
+        originalValue,
+        options
+      );
+    }
+    let coerced = originalValue;
+    let satisfied = true;
+    if (typeof schema.$ref === "string") {
+      const refSchema = options?.components?.[schema.$ref];
+      if (refSchema !== void 0) {
+        const [subSatisfied, subCoerced] = this.#coerce(refSchema, coerced, options);
+        coerced = subCoerced;
+        satisfied = subSatisfied;
+      }
+    }
+    const enumValues = schema.const !== void 0 ? [schema.const] : schema.enum;
+    if (enumValues !== void 0 && !enumValues.includes(coerced)) {
+      if (typeof coerced === "string") {
+        const numberValue = this.#stringToNumber(coerced);
+        if (enumValues.includes(numberValue)) {
+          coerced = numberValue;
+        } else {
+          const booleanValue = this.#stringToBoolean(coerced);
+          if (enumValues.includes(booleanValue)) {
+            coerced = booleanValue;
+          } else {
+            satisfied = false;
+          }
+        }
+      } else {
+        satisfied = false;
+      }
+    }
+    if (typeof schema.type === "string") {
+      switch (schema.type) {
+        case "null": {
+          if (coerced !== null) {
+            satisfied = false;
+          }
+          break;
+        }
+        case "string": {
+          if (typeof coerced !== "string") {
+            satisfied = false;
+          }
+          break;
+        }
+        case "number": {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToNumber(coerced);
+          }
+          if (typeof coerced !== "number") {
+            satisfied = false;
+          }
+          break;
+        }
+        case "integer": {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToInteger(coerced);
+          }
+          if (typeof coerced !== "number" || !Number.isInteger(coerced)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case "boolean": {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToBoolean(coerced);
+          }
+          if (typeof coerced !== "boolean") {
+            satisfied = false;
+          }
+          break;
+        }
+        case "array": {
+          if (Array.isArray(coerced)) {
+            const prefixItemSchemas = "prefixItems" in schema ? toArray(schema.prefixItems) : Array.isArray(schema.items) ? schema.items : [];
+            const itemSchema = Array.isArray(schema.items) ? schema.additionalItems : schema.items;
+            let shouldUseCoercedItems = false;
+            const coercedItems = coerced.map((item, i) => {
+              const subSchema = prefixItemSchemas[i] ?? itemSchema;
+              if (subSchema === void 0) {
+                satisfied = false;
+                return item;
+              }
+              const [subSatisfied, subCoerced] = this.#coerce(subSchema, item, options);
+              if (!subSatisfied) {
+                satisfied = false;
+              }
+              if (subCoerced !== item) {
+                shouldUseCoercedItems = true;
+              }
+              return subCoerced;
+            });
+            if (coercedItems.length < prefixItemSchemas.length) {
+              satisfied = false;
+            }
+            if (shouldUseCoercedItems) {
+              coerced = coercedItems;
+            }
+          } else {
+            satisfied = false;
+          }
+          break;
+        }
+        case "object": {
+          if (Array.isArray(coerced)) {
+            coerced = { ...coerced };
+          }
+          if (isObject(coerced)) {
+            let shouldUseCoercedItems = false;
+            const coercedItems = {};
+            const patternProperties = Object.entries(schema.patternProperties ?? {}).map(
+              ([key, value]) => [new RegExp(key), value]
+            );
+            for (const key in coerced) {
+              const value = coerced[key];
+              const subSchema = schema.properties?.[key] ?? patternProperties.find(([pattern]) => pattern.test(key))?.[1] ?? schema.additionalProperties;
+              if (value === void 0 && !schema.required?.includes(key)) {
+                coercedItems[key] = value;
+              } else if (subSchema === void 0) {
+                coercedItems[key] = value;
+                satisfied = false;
+              } else {
+                const [subSatisfied, subCoerced] = this.#coerce(subSchema, value, options);
+                coercedItems[key] = subCoerced;
+                if (!subSatisfied) {
+                  satisfied = false;
+                }
+                if (subCoerced !== value) {
+                  shouldUseCoercedItems = true;
+                }
+              }
+            }
+            if (schema.required?.some((key) => !Object.hasOwn(coercedItems, key))) {
+              satisfied = false;
+            }
+            if (shouldUseCoercedItems) {
+              coerced = coercedItems;
+            }
+          } else {
+            satisfied = false;
+          }
+          break;
+        }
+      }
+    }
+    if ("x-native-type" in schema && typeof schema["x-native-type"] === "string") {
+      switch (schema["x-native-type"]) {
+        case JsonSchemaXNativeType.Date: {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToDate(coerced);
+          }
+          if (!(coerced instanceof Date)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.BigInt: {
+          switch (typeof coerced) {
+            case "string":
+              coerced = this.#stringToBigInt(coerced);
+              break;
+            case "number":
+              coerced = this.#numberToBigInt(coerced);
+              break;
+          }
+          if (typeof coerced !== "bigint") {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.RegExp: {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToRegExp(coerced);
+          }
+          if (!(coerced instanceof RegExp)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.Url: {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToURL(coerced);
+          }
+          if (!(coerced instanceof URL)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.Set: {
+          if (Array.isArray(coerced)) {
+            coerced = this.#arrayToSet(coerced);
+          }
+          if (!(coerced instanceof Set)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.Map: {
+          if (Array.isArray(coerced)) {
+            coerced = this.#arrayToMap(coerced);
+          }
+          if (!(coerced instanceof Map)) {
+            satisfied = false;
+          }
+          break;
+        }
+      }
+    }
+    if (schema.allOf) {
+      for (const subSchema of schema.allOf) {
+        const [subSatisfied, subCoerced] = this.#coerce(subSchema, coerced, options);
+        coerced = subCoerced;
+        if (!subSatisfied) {
+          satisfied = false;
+        }
+      }
+    }
+    for (const key of ["anyOf", "oneOf"]) {
+      if (schema[key]) {
+        let bestOptions;
+        for (const subSchema of schema[key]) {
+          const [subSatisfied, subCoerced] = this.#coerce(subSchema, coerced, options);
+          if (subSatisfied) {
+            if (!bestOptions || subCoerced === coerced) {
+              bestOptions = { coerced: subCoerced, satisfied: subSatisfied };
+            }
+            if (subCoerced === coerced) {
+              break;
+            }
+          }
+        }
+        coerced = bestOptions ? bestOptions.coerced : coerced;
+        satisfied = bestOptions ? bestOptions.satisfied : false;
+      }
+    }
+    if (typeof schema.not !== "undefined") {
+      const [notSatisfied] = this.#coerce(schema.not, coerced, options);
+      if (notSatisfied) {
+        satisfied = false;
+      }
+    }
+    return [satisfied, coerced];
+  }
+  #stringToNumber(value) {
+    const num = Number.parseFloat(value);
+    if (Number.isNaN(num) || num !== Number(value)) {
+      return value;
+    }
+    return num;
+  }
+  #stringToInteger(value) {
+    const num = Number.parseInt(value);
+    if (Number.isNaN(num) || num !== Number(value)) {
+      return value;
+    }
+    return num;
+  }
+  #stringToBoolean(value) {
+    const lower = value.toLowerCase();
+    if (lower === "false" || lower === "off") {
+      return false;
+    }
+    if (lower === "true" || lower === "on") {
+      return true;
+    }
+    return value;
+  }
+  #stringToBigInt(value) {
+    return guard(() => BigInt(value)) ?? value;
+  }
+  #numberToBigInt(value) {
+    return guard(() => BigInt(value)) ?? value;
+  }
+  #stringToDate(value) {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()) || !FLEXIBLE_DATE_FORMAT_REGEX.test(value)) {
+      return value;
+    }
+    return date;
+  }
+  #stringToRegExp(value) {
+    const match = value.match(/^\/(.*)\/([a-z]*)$/);
+    if (match) {
+      const [, pattern, flags] = match;
+      return guard(() => new RegExp(pattern, flags)) ?? value;
+    }
+    return value;
+  }
+  #stringToURL(value) {
+    return guard(() => new URL(value)) ?? value;
+  }
+  #arrayToSet(value) {
+    const set = new Set(value);
+    if (set.size !== value.length) {
+      return value;
+    }
+    return set;
+  }
+  #arrayToMap(value) {
+    if (value.some((item) => !Array.isArray(item) || item.length !== 2)) {
+      return value;
+    }
+    const result = new Map(value);
+    if (result.size !== value.length) {
+      return value;
+    }
+    return result;
+  }
+}
+
+function isSchemaIssue(issue) {
+  if (!isTypescriptObject(issue) || typeof issue.message !== "string") {
+    return false;
+  }
+  if (issue.path !== void 0) {
+    if (!Array.isArray(issue.path)) {
+      return false;
+    }
+    if (!issue.path.every(
+      (segment) => isPropertyKey(segment) || isTypescriptObject(segment) && isPropertyKey(segment.key)
+    )) {
+      return false;
+    }
+  }
+  return true;
+}
+
+async function generateStainlessConfig(resources, baseConfig) {
+  const config = Object.assign(
+    { $schema: "https://app.stainless.com/config-internal.schema.json", resources: {} },
+    clone(baseConfig)
+  );
+  const inputResources = await unlazyResources(resources);
+  for (const inputResource of inputResources) {
+    const configResource = getResourceFromName(inputResource.name, config.resources);
+    Object.assign(configResource, inputResource.config);
+    for (const [methodName, contract] of Object.entries(inputResource.methods)) {
+      const def = contract["~def"];
+      const methods = configResource.methods ??= {};
+      if (methods[methodName] !== void 0) {
+        throw new Error(
+          `The baseConfig passed to generateStainlessConfig must not specify resource methods. Those should be configured when building the method`
+        );
+      }
+      methods[methodName] = makeMethodConfig(def);
+    }
+  }
+  const allContracts = inputResources.flatMap((r) => Object.values(r.methods));
+  if (!config.client_settings?.opts) {
+    const namesByAuthConfig = getNamesByAuthConfig(allContracts);
+    if (namesByAuthConfig.size > 0) {
+      config.client_settings ||= {};
+      config.client_settings.opts = {
+        api_key: {
+          type: "string",
+          auth: {
+            security_scheme: namesByAuthConfig.values().next().value
+          }
+        }
+      };
+    }
+  }
+  if (!config.readme && allContracts.length > 0) {
+    const firstContract = allContracts[0];
+    config.readme = {
+      example_requests: {
+        default: makeExampleRequest(firstContract["~def"]),
+        headline: makeExampleRequest(firstContract["~def"])
+      }
+    };
+  }
+  return config;
+}
+function makeExampleRequest(contract) {
+  const schema = {};
+  if (contract.schemas.pathSchema instanceof KrustyObject) {
+    Object.assign(schema, contract.schemas.pathSchema.shape);
+  }
+  if (contract.schemas.querySchema instanceof KrustyObject) {
+    Object.assign(schema, contract.schemas.querySchema.shape);
+  }
+  if (contract.schemas.bodySchema instanceof KrustyObject) {
+    Object.assign(schema, contract.schemas.bodySchema.shape);
+  }
+  const params = Object.fromEntries(
+    Object.entries(schema).map(([key, value]) => [key, makeExampleParam(value)])
+  );
+  return {
+    type: "request",
+    endpoint: `${contract.methodConfig.method.toLowerCase()} ${contract.methodConfig.path}`,
+    params
+  };
+}
+function makeExampleParam(type) {
+  if (type instanceof z$1.core.$ZodString) {
+    return "string";
+  } else if (type instanceof z$1.core.$ZodNumber) {
+    return 0;
+  } else if (type instanceof z$1.core.$ZodBoolean) {
+    return true;
+  } else if (type instanceof z$1.core.$ZodObject) {
+    return Object.fromEntries(
+      Object.entries(type._zod.def.shape).map(([key, value]) => [key, makeExampleParam(value)])
+    );
+  } else if (type instanceof z$1.core.$ZodArray) {
+    return [makeExampleParam(type._zod.def.element)];
+  } else {
+    return null;
+  }
+}
+function getResourceFromName(name, resources) {
+  const nameParts = name.split(".");
+  let i = 0;
+  for (; i < nameParts.length - 1; i++) {
+    resources = (resources[nameParts[i]] ??= {}).subresources ??= {};
+  }
+  const finalPart = nameParts[i];
+  const existingResource = resources[finalPart];
+  if (existingResource?.methods !== void 0) {
+    throw new Error(`Multiple ApiResources have the same name: "${name}"`);
+  }
+  resources[finalPart] = existingResource ?? {};
+  return resources[finalPart];
+}
+function makeMethodConfig(def) {
+  const { methodConfig } = def;
+  return `${methodConfig.method?.toLowerCase()} ${methodConfig.path}`;
+}
+
+export { BadRequestError, Builder, Contract, DecoratedContract, ForbiddenError, InternalServerError, JsonSchemaXNativeType, Method, Middleware, NotFoundError, UnauthorizedError, baseApi, defaultMiddlewareSchemas, experimental_JsonSchemaCoercer, generateStainlessConfig, isSchemaIssue, mergeMeta, onError, onFinish, onStart, onSuccess, parseEndpointDefinition, unlazyResources, wrapShape, zEmptyObject };