@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-7H4SVNC4.cjs

@@ -0,0 +1,700 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkQISW423Scjs = require('./chunk-QISW423S.cjs');
+
+
+var _chunkBTZ5O6VMcjs = require('./chunk-BTZ5O6VM.cjs');
+
+// src/openapi/generator.ts
+var allowedType = /* @__PURE__ */ new Set(["string", "number", "boolean", "array", "object"]);
+var zodTypeNameKinds = {
+  ZodArray: "array",
+  ZodBoolean: "boolean",
+  ZodDefault: "default",
+  ZodEnum: "enum",
+  ZodLiteral: "literal",
+  ZodNullable: "nullable",
+  ZodNumber: "number",
+  ZodObject: "object",
+  ZodOptional: "optional",
+  ZodRecord: "record",
+  ZodString: "string",
+  ZodTuple: "tuple",
+  ZodUnion: "union"
+};
+function getZodKind(schema) {
+  if (!schema || typeof schema !== "object") return void 0;
+  const definition = schema._def;
+  if (!definition || typeof definition !== "object") return void 0;
+  if (typeof definition.type === "string") return definition.type;
+  return typeof definition.typeName === "string" ? zodTypeNameKinds[definition.typeName] : void 0;
+}
+function getZodObjectShape(schema) {
+  if (getZodKind(schema) !== "object") return void 0;
+  const candidate = _nullishCoalesce(schema.shape, () => ( _optionalChain([schema, 'access', _ => _._def, 'optionalAccess', _2 => _2.shape])));
+  const shape = typeof candidate === "function" ? candidate() : candidate;
+  return shape && typeof shape === "object" ? shape : void 0;
+}
+function isStandardSchema(schema) {
+  return !!schema && typeof schema === "object" && typeof _optionalChain([schema, 'access', _3 => _3["~standard"], 'optionalAccess', _4 => _4.validate]) === "function";
+}
+function openAPITypeForLiteralValues(values) {
+  if (values.length === 0) return "string";
+  const jsType = typeof values[0];
+  if (!values.every((value) => typeof value === jsType)) return "string";
+  switch (jsType) {
+    case "number":
+      return "number";
+    case "bigint":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return "string";
+  }
+}
+var OpenAPIGenerator = class {
+  constructor(appDir, config, context = {}) {
+    this.appDir = appDir;
+    this.config = config;
+    this.context = context;
+  }
+  /**
+   * Get type from Zod type
+   */
+  getTypeFromZodType(zodType) {
+    const tag = getZodKind(zodType);
+    return typeof tag === "string" && allowedType.has(tag) ? tag : "string";
+  }
+  /**
+   * Whether a schema field must be supplied by the caller. A field with a
+   * default is supplied by the server when omitted, so — like an explicitly
+   * optional field — it is not required. Only ZodOptional was excluded before,
+   * which documented every `.default()` field as required.
+   */
+  isRequiredField(value) {
+    const kind = getZodKind(value);
+    return kind !== "optional" && kind !== "default";
+  }
+  /**
+   * Process Zod type to OpenAPI schema
+   */
+  processZodType(zodType) {
+    const kind = getZodKind(zodType);
+    const definition = _optionalChain([zodType, 'optionalAccess', _5 => _5._def]);
+    if (!kind) {
+      return isStandardSchema(zodType) ? { description: "Schema metadata is unavailable for this Standard Schema validator." } : { description: "Schema metadata is unavailable." };
+    }
+    if (kind === "optional") {
+      return this.processZodType(definition.innerType);
+    }
+    if (kind === "nullable") {
+      const innerType = definition.innerType;
+      const innerSchema = this.processZodType(innerType);
+      return {
+        ...innerSchema,
+        nullable: true
+      };
+    }
+    if (kind === "default") {
+      return this.processZodType(definition.innerType);
+    }
+    if (kind === "object") {
+      const shape = getZodObjectShape(zodType);
+      if (shape) {
+        const properties = {};
+        const required = [];
+        Object.entries(shape).forEach(([key, value]) => {
+          if (getZodKind(value) || isStandardSchema(value)) {
+            properties[key] = this.processZodType(value);
+            if (this.isRequiredField(value)) {
+              required.push(key);
+            }
+          }
+        });
+        return {
+          type: "object",
+          properties,
+          ...required.length > 0 ? { required } : {},
+          description: zodType.description
+        };
+      }
+    }
+    if (kind === "array") {
+      return {
+        type: "array",
+        items: this.processZodType(
+          _nullishCoalesce(definition.element, () => ( (typeof definition.type === "object" ? definition.type : void 0)))
+        ),
+        description: zodType.description
+      };
+    }
+    if (kind === "enum") {
+      const options = _nullishCoalesce(zodType.options, () => ( (definition.entries ? Object.values(definition.entries) : definition.values)));
+      return {
+        type: "string",
+        enum: options,
+        description: zodType.description
+      };
+    }
+    if (kind === "literal") {
+      const values = _nullishCoalesce(definition.values, () => ( (Object.prototype.hasOwnProperty.call(definition, "value") ? [definition.value] : [])));
+      return {
+        type: openAPITypeForLiteralValues(values),
+        ...values.length > 0 ? { enum: [...values] } : {},
+        description: zodType.description
+      };
+    }
+    if (kind === "union") {
+      const options = _nullishCoalesce(definition.options, () => ( []));
+      return {
+        oneOf: options.map((option) => this.processZodType(option)),
+        description: zodType.description
+      };
+    }
+    if (kind === "record") {
+      return {
+        type: "object",
+        additionalProperties: this.processZodType(definition.valueType),
+        description: zodType.description
+      };
+    }
+    if (kind === "tuple") {
+      const items = _nullishCoalesce(definition.items, () => ( []));
+      const rest = definition.rest;
+      const itemSchemas = [...items, ...rest ? [rest] : []].map(
+        (item) => this.processZodType(item)
+      );
+      const tupleSchema = {
+        type: "array",
+        items: itemSchemas.length === 1 ? itemSchemas[0] : { oneOf: itemSchemas },
+        description: zodType.description
+      };
+      if (!rest) {
+        tupleSchema.minItems = items.length;
+        tupleSchema.maxItems = items.length;
+      }
+      return tupleSchema;
+    }
+    const baseSchema = {
+      type: this.getTypeFromZodType(zodType),
+      description: zodType.description
+    };
+    const constraints = [
+      ["minLength", zodType.minLength],
+      ["maxLength", zodType.maxLength],
+      ["minimum", zodType.minValue],
+      ["maximum", zodType.maxValue]
+    ];
+    for (const check of _nullishCoalesce(definition.checks, () => ( []))) {
+      if (_optionalChain([check, 'optionalAccess', _6 => _6.kind]) === "min") {
+        constraints.push([kind === "string" ? "minLength" : "minimum", check.value]);
+      } else if (_optionalChain([check, 'optionalAccess', _7 => _7.kind]) === "max") {
+        constraints.push([kind === "string" ? "maxLength" : "maximum", check.value]);
+      }
+    }
+    for (const [key, value] of constraints) {
+      if (Number.isFinite(value) && Math.abs(value) !== Number.MAX_SAFE_INTEGER) {
+        baseSchema[key] = value;
+      }
+    }
+    return baseSchema;
+  }
+  getResponses(metadata) {
+    const responses = Object.entries(_nullishCoalesce(metadata.responses, () => ( {}))).filter(
+      (entry) => entry[1] !== void 0
+    );
+    if (responses.length === 0) {
+      return {
+        default: {
+          description: "Response metadata is unavailable."
+        }
+      };
+    }
+    return Object.fromEntries(
+      responses.map(([status, response]) => [status, this.getResponse(response)])
+    );
+  }
+  getResponse(response) {
+    if (response.body === "empty") {
+      return {
+        description: _nullishCoalesce(response.description, () => ( "Empty response"))
+      };
+    }
+    if (response.body === "binary") {
+      return {
+        description: _nullishCoalesce(response.description, () => ( "Binary response")),
+        content: {
+          [_nullishCoalesce(response.contentType, () => ( "application/octet-stream"))]: {
+            schema: { type: "string", format: "binary" }
+          }
+        }
+      };
+    }
+    const contentType = response.body === "json" ? _nullishCoalesce(response.contentType, () => ( "application/json")) : response.contentType;
+    return {
+      description: _nullishCoalesce(response.description, () => ( (response.body === "json" ? "JSON response" : "Streaming response"))),
+      content: {
+        [contentType]: response.schema ? { schema: response.schema } : {}
+      }
+    };
+  }
+  /**
+   * Generate OpenAPI spec from API routes
+   */
+  async generateSpec(routes, requestOrigin) {
+    var _a, _b;
+    const spec = {
+      openapi: "3.0.3",
+      info: {
+        title: this.config.title || "API Documentation",
+        description: this.config.description || "Auto-generated API documentation",
+        version: this.config.version || "1.0.0",
+        ...this.config.contact && { contact: this.config.contact },
+        ...this.config.license && { license: this.config.license }
+      },
+      servers: this.resolveServers(requestOrigin),
+      paths: {},
+      components: {
+        schemas: {},
+        securitySchemes: {
+          bearerAuth: {
+            type: "http",
+            scheme: "bearer",
+            description: "Bearer token authentication"
+          },
+          apiKeyCookie: {
+            type: "apiKey",
+            in: "cookie",
+            name: "session",
+            description: "API Key authentication via cookie"
+          }
+        }
+      }
+    };
+    const routeGroups = /* @__PURE__ */ new Map();
+    for (const route of routes) {
+      const key = route.path;
+      if (!routeGroups.has(key)) {
+        routeGroups.set(key, []);
+      }
+      routeGroups.get(key).push(route);
+    }
+    for (const [path, routeList] of routeGroups) {
+      for (const variant of this.getOpenAPIPathVariants(path)) {
+        _nullishCoalesce((_a = spec.paths)[_b = variant.path], () => ( (_a[_b] = {})));
+        for (const route of routeList) {
+          for (const method of route.methods) {
+            if (variant.operationIdSuffix === "base") {
+              const existingOperation = method === "QUERY" ? _optionalChain([spec, 'access', _8 => _8.paths, 'access', _9 => _9[variant.path], 'access', _10 => _10["x-oai-additionalOperations"], 'optionalAccess', _11 => _11.QUERY]) : spec.paths[variant.path][method.toLowerCase()];
+              if (existingOperation) continue;
+            }
+            const operation = await this.generateOperation(
+              route,
+              method,
+              variant.path,
+              variant.operationIdSuffix
+            );
+            if (method === "QUERY") {
+              const additionalOperations = _nullishCoalesce(spec.paths[variant.path]["x-oai-additionalOperations"], () => ( {}));
+              additionalOperations.QUERY = operation;
+              spec.paths[variant.path]["x-oai-additionalOperations"] = additionalOperations;
+            } else {
+              spec.paths[variant.path][method.toLowerCase()] = operation;
+            }
+          }
+        }
+      }
+    }
+    return spec;
+  }
+  /**
+   * Resolve server entries in decreasing order of authority: explicit OpenAPI
+   * servers, Farm's public API base, the current development request origin,
+   * and finally a mode-appropriate default.
+   */
+  resolveServers(requestOrigin) {
+    if (this.config.servers !== void 0) return this.config.servers;
+    const apiBaseURL = this.context.apiBaseURL || "/api";
+    if (/^https?:\/\//i.test(apiBaseURL)) {
+      return [{ url: apiBaseURL, description: "Farm API server" }];
+    }
+    if (requestOrigin) {
+      return [
+        {
+          url: new URL(apiBaseURL, `${requestOrigin.replace(/\/$/, "")}/`).toString(),
+          description: "Current development server"
+        }
+      ];
+    }
+    if (this.context.mode === "production") {
+      return [{ url: apiBaseURL, description: "Same-origin API server" }];
+    }
+    return [
+      {
+        url: new URL(apiBaseURL, "http://localhost:3000/").toString(),
+        description: "Development server"
+      }
+    ];
+  }
+  /**
+   * Convert a Farm.js API path to OpenAPI path format.
+   *
+   * Strips the `/api` prefix and rewrites dynamic segments to OpenAPI's
+   * `{name}` templating: `[id]` -> `{id}`, `[...slug]` -> `{slug}`, and
+   * `[[...slug]]` -> `{slug}`. Leaving the bracket form produces a path key that
+   * is invalid OpenAPI, which breaks "try it" and any generated client.
+   */
+  convertToOpenAPIPath(path) {
+    const converted = path.replace(/^\/api/, "").replace(/\[\[\.\.\.([^\]]+)\]\]/g, "{$1}").replace(/\[\.\.\.([^\]]+)\]/g, "{$1}").replace(/\[([^\]]+)\]/g, "{$1}");
+    return converted || "/";
+  }
+  /**
+   * OpenAPI does not permit optional path parameters. An optional catch-all
+   * therefore becomes two concrete paths: the empty base path and the
+   * parameterized catch-all path.
+   */
+  getOpenAPIPathVariants(path) {
+    if (!/\/\[\[\.\.\.[^\]]+\]\]/.test(path)) {
+      return [{ path: this.convertToOpenAPIPath(path) }];
+    }
+    const basePath = path.replace(/\/\[\[\.\.\.[^\]]+\]\]/g, "") || "/api";
+    return [
+      { path: this.convertToOpenAPIPath(basePath), operationIdSuffix: "base" },
+      { path: this.convertToOpenAPIPath(path) }
+    ];
+  }
+  /**
+   * Path parameters implied by a Farm.js API path's dynamic segments. Every
+   * path parameter is `required: true` per the OpenAPI spec (a path parameter
+   * cannot be optional), including catch-all segments.
+   */
+  getPathParameters(openAPIPath) {
+    return [...openAPIPath.matchAll(/\{([^}]+)\}/g)].map((match) => ({
+      name: match[1],
+      in: "path",
+      required: true,
+      schema: { type: "string" }
+    }));
+  }
+  /**
+   * Extract request body schema from endpoint
+   */
+  async getRequestBody(route, method) {
+    if (!["QUERY", "POST", "PUT", "PATCH", "DELETE"].includes(method)) {
+      return void 0;
+    }
+    try {
+      const modulePath = route.filePath;
+      const routeModule = await import(
+        /* @vite-ignore */
+        modulePath
+      );
+      const handler = routeModule[method];
+      const bodySchema = _nullishCoalesce(_optionalChain([handler, 'optionalAccess', _12 => _12.__types, 'optionalAccess', _13 => _13.body]), () => ( _optionalChain([handler, 'optionalAccess', _14 => _14._type, 'optionalAccess', _15 => _15.body])));
+      if (bodySchema) {
+        return {
+          required: this.isRequiredField(bodySchema),
+          content: {
+            "application/json": {
+              schema: this.processZodType(bodySchema)
+            }
+          }
+        };
+      }
+      return void 0;
+    } catch (error) {
+      console.warn(`Could not extract schema from ${route.filePath}:`, error);
+      return {
+        required: false,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              description: "Request body"
+            }
+          }
+        }
+      };
+    }
+  }
+  /**
+   * Extract query parameters from endpoint
+   */
+  async getParameters(route, method) {
+    const parameters = [];
+    try {
+      const modulePath = route.filePath;
+      const routeModule = await import(
+        /* @vite-ignore */
+        modulePath
+      );
+      const handler = routeModule[method];
+      const querySchema = _nullishCoalesce(_optionalChain([handler, 'optionalAccess', _16 => _16.__types, 'optionalAccess', _17 => _17.query]), () => ( _optionalChain([handler, 'optionalAccess', _18 => _18._type, 'optionalAccess', _19 => _19.query])));
+      const shape = getZodObjectShape(querySchema);
+      if (shape) {
+        Object.entries(shape).forEach(([key, value]) => {
+          if (getZodKind(value) || isStandardSchema(value)) {
+            parameters.push({
+              name: key,
+              in: "query",
+              required: this.isRequiredField(value),
+              schema: this.processZodType(value)
+            });
+          }
+        });
+      }
+    } catch (error) {
+      console.warn(`Could not extract query params from ${route.filePath}:`, error);
+    }
+    return parameters;
+  }
+  /**
+   * Generate OpenAPI operation from route info
+   */
+  async generateOperation(route, method, openAPIPath = this.convertToOpenAPIPath(route.path), operationIdSuffix) {
+    const metadata = await this.getEndpointOpenAPIMetadata(route, method);
+    const security = this.getSecurityRequirements(
+      _nullishCoalesce(_nullishCoalesce(metadata.security, () => ( this.config.security)), () => ( "public"))
+    );
+    const operation = {
+      summary: this.generateSummary(route.path, method),
+      description: this.generateDescription(route.path, method),
+      operationId: this.generateOperationId(route.path, method, operationIdSuffix),
+      tags: this.generateTags(route.path),
+      ...security ? { security } : {},
+      responses: this.getResponses(metadata)
+    };
+    const parameters = [
+      ...this.getPathParameters(openAPIPath),
+      ...await this.getParameters(route, method)
+    ];
+    if (parameters.length > 0) {
+      operation.parameters = parameters;
+    }
+    if (["QUERY", "POST", "PUT", "PATCH", "DELETE"].includes(method)) {
+      const requestBody = await this.getRequestBody(route, method);
+      if (requestBody) {
+        operation.requestBody = requestBody;
+      }
+    }
+    return operation;
+  }
+  async getEndpointOpenAPIMetadata(route, method) {
+    try {
+      const routeModule = await import(
+        /* @vite-ignore */
+        route.filePath
+      );
+      return _nullishCoalesce(_optionalChain([routeModule, 'access', _20 => _20[method], 'optionalAccess', _21 => _21.__openapi]), () => ( {}));
+    } catch (e) {
+      return {};
+    }
+  }
+  getSecurityRequirements(mode) {
+    if (mode === "public") return void 0;
+    if (mode === "bearer") return [{ bearerAuth: [] }];
+    if (mode === "cookie") return [{ apiKeyCookie: [] }];
+    return [{ bearerAuth: [] }, { apiKeyCookie: [] }];
+  }
+  /**
+   * Generate operation summary
+   */
+  generateSummary(path, method) {
+    const cleanPath = path.replace(/^\/api\//, "");
+    const pathParts = cleanPath.split("/");
+    const lastPart = pathParts[pathParts.length - 1];
+    const action = method === "GET" ? "Get" : method === "QUERY" ? "Query" : method === "POST" ? "Create" : method === "PUT" ? "Update" : method === "DELETE" ? "Delete" : method === "PATCH" ? "Update" : method;
+    return `${action} ${lastPart}`;
+  }
+  /**
+   * Generate operation description
+   */
+  generateDescription(path, method) {
+    const cleanPath = path.replace(/^\/api\//, "");
+    return `${method} ${cleanPath} endpoint`;
+  }
+  /**
+   * Generate operation ID
+   */
+  generateOperationId(path, method, suffix) {
+    const cleanPath = path.replace(/^\/api\//, "").replace(/\//g, "_");
+    return `${method.toLowerCase()}_${cleanPath}${suffix ? `_${suffix}` : ""}`;
+  }
+  /**
+   * Generate tags for grouping operations
+   */
+  generateTags(path) {
+    const cleanPath = path.replace(/^\/api\//, "");
+    const pathParts = cleanPath.split("/");
+    if (pathParts.length > 1) {
+      return [pathParts[0]];
+    }
+    return ["default"];
+  }
+  /**
+   * Generate OpenAPI spec file
+   */
+  async generateSpecFile(routes, outputPath) {
+    const spec = await this.generateSpec(routes);
+    const fs = _chunkBTZ5O6VMcjs.__require.call(void 0, "fs");
+    const path = _chunkBTZ5O6VMcjs.__require.call(void 0, "path");
+    const dir = path.dirname(outputPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(outputPath, JSON.stringify(spec, null, 2));
+  }
+};
+
+// src/openapi/scalar-assets.ts
+var SCALAR_API_REFERENCE_VERSION = "1.38.1";
+var SCALAR_CDN_BASE = `https://cdn.jsdelivr.net/npm/@scalar/api-reference@${SCALAR_API_REFERENCE_VERSION}`;
+var SCALAR_API_REFERENCE_SCRIPT = {
+  url: `${SCALAR_CDN_BASE}/dist/browser/standalone.js`,
+  integrity: "sha384-87uSxO5SeoAG+4aLsnXHJWpb9Gx1biSeaI0O4O5z9OBFe7ZaEJ1LlvVGBo2CkcSO"
+};
+var SCALAR_API_REFERENCE_STYLES = {
+  url: `${SCALAR_CDN_BASE}/dist/style.css`,
+  integrity: "sha384-D1NAbn/NwPaQ5LosRasICtufkVzdUvZZ4+PuXyFYOuR/AzPE0G5BOkXqju29Np+S"
+};
+
+// src/openapi/manager.ts
+function escapeHTML(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function renderOpenAPIReferenceHTML(spec, config) {
+  return `
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>${escapeHTML(config.title || "API Documentation")}</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <link rel="icon" href="data:," />
+  </head>
+  <body>
+    <script
+      id="api-reference"
+      data-url="data:application/json;base64,${Buffer.from(JSON.stringify(spec)).toString("base64")}"
+    ></script>
+    <script
+      src="${SCALAR_API_REFERENCE_SCRIPT.url}"
+      integrity="${SCALAR_API_REFERENCE_SCRIPT.integrity}"
+      crossorigin="anonymous"
+    ></script>
+  </body>
+</html>
+    `;
+}
+var OpenAPIManager = class {
+  constructor(appDir, config, context = {}) {
+    this.specCache = null;
+    const appDirs = Array.isArray(appDir) ? [...appDir] : [appDir];
+    this.appDir = appDirs[appDirs.length - 1];
+    this.config = config;
+    this.generator = new OpenAPIGenerator(this.appDir, config, context);
+    this.apiTypeGenerator = new (0, _chunkQISW423Scjs.APITypeGenerator)(appDirs);
+  }
+  /**
+   * Generate OpenAPI spec from API routes
+   */
+  async generateSpec() {
+    try {
+      const routes = this.apiTypeGenerator.scanAPIRoutes();
+      const spec = await this.generator.generateSpec(routes);
+      this.specCache = spec;
+      return spec;
+    } catch (error) {
+      console.error("Failed to generate OpenAPI spec:", error);
+      return null;
+    }
+  }
+  /**
+   * Get cached spec or generate new one
+   */
+  async getSpec(requestOrigin) {
+    const spec = await _asyncNullishCoalesce(this.specCache, async () => ( await this.generateSpec()));
+    if (!requestOrigin || !spec) return spec;
+    return {
+      ...spec,
+      servers: this.generator.resolveServers(requestOrigin)
+    };
+  }
+  /**
+   * Generate and save OpenAPI spec file
+   */
+  async generateSpecFile() {
+    try {
+      const routes = this.apiTypeGenerator.scanAPIRoutes();
+      const outputPath = `${this.appDir}/lib/openapi.spec.json`;
+      await this.generator.generateSpecFile(routes, outputPath);
+      console.log("\u2705 OpenAPI spec generated at:", outputPath);
+    } catch (error) {
+      console.error("Failed to generate OpenAPI spec file:", error);
+    }
+  }
+  /**
+   * Invalidate cache and regenerate spec
+   */
+  async invalidateCache() {
+    this.specCache = null;
+    await this.generateSpec();
+  }
+  /**
+   * Get the docs route handler
+   */
+  getDocsRouteHandler(requestOrigin) {
+    return async (req, res) => {
+      try {
+        const method = String(req.method || "GET").toUpperCase();
+        if (method !== "GET" && method !== "HEAD") {
+          res.statusCode = 405;
+          res.setHeader("Allow", "GET, HEAD");
+          res.setHeader("Content-Type", "text/plain; charset=utf-8");
+          res.end("Method Not Allowed");
+          return;
+        }
+        const spec = await this.getSpec(requestOrigin);
+        if (!spec) {
+          res.statusCode = 500;
+          res.setHeader("Content-Type", "text/html");
+          res.end(`
+            <html>
+              <body>
+                <h1>Error</h1>
+                <p>Failed to generate OpenAPI specification</p>
+              </body>
+            </html>
+          `);
+          return;
+        }
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        res.setHeader("Cache-Control", "public, max-age=0, must-revalidate");
+        res.setHeader("X-Content-Type-Options", "nosniff");
+        res.end(method === "HEAD" ? void 0 : renderOpenAPIReferenceHTML(spec, this.config));
+      } catch (error) {
+        console.error("Error serving docs route:", error);
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "text/html");
+        res.end(`
+          <html>
+            <body>
+              <h1>Error</h1>
+              <p>Failed to load API documentation</p>
+            </body>
+          </html>
+        `);
+      }
+    };
+  }
+};
+
+
+
+
+
+
+
+exports.OpenAPIGenerator = OpenAPIGenerator; exports.SCALAR_API_REFERENCE_SCRIPT = SCALAR_API_REFERENCE_SCRIPT; exports.SCALAR_API_REFERENCE_STYLES = SCALAR_API_REFERENCE_STYLES; exports.renderOpenAPIReferenceHTML = renderOpenAPIReferenceHTML; exports.OpenAPIManager = OpenAPIManager;