create-surf-app 0.1.5 → 0.1.7

package/dist/chunk-AMAMASIV.js

@@ -0,0 +1,1016 @@
+// src/index.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+
+// src/api-codegen.ts
+var INTERNAL_SWAGGER_BASE = process.env.HERMOD_INTERNAL_URL ?? "http://hermod-api.app.svc.cluster.local:8080";
+var BLOCKED_PATHS = /* @__PURE__ */ new Set(["/gateway/v1/onchain/sql"]);
+var TAG_ORDER = [
+  "Market",
+  "Project",
+  "Wallet",
+  "Token",
+  "Social",
+  "News",
+  "Onchain",
+  "Web",
+  "Fund",
+  "Search",
+  "Prediction Market",
+  "Exchange"
+];
+var CATEGORY_SET = new Set(TAG_ORDER);
+var TYPE_MAP = {
+  string: "string",
+  integer: "number",
+  number: "number",
+  boolean: "boolean",
+  object: "any"
+};
+var FALLBACK_API_TS = `/**
+ * Crypto API client helpers (fallback \u2014 swagger fetch failed).
+ */
+
+export { API_BASE, normalizeProxyPath, fetchWithRetry, proxyGet, proxyPost } from './fetch'
+
+export interface ApiResponse<T> {
+  data: T[]
+  meta?: { total?: number; limit?: number; offset?: number }
+  error?: { code: string; message: string }
+}
+
+export interface ApiObjectResponse<T> {
+  data: T
+  meta?: { total?: number; limit?: number; offset?: number }
+  error?: { code: string; message: string }
+}
+
+export interface CursorMeta {
+  has_more: boolean
+  next_cursor?: string
+  limit?: number
+  cached?: boolean
+  credits_used?: number
+}
+
+export interface ApiCursorResponse<T> {
+  data: T[]
+  meta: CursorMeta
+  error?: { code: string; message: string }
+}
+`;
+function getSwaggerUrl(override) {
+  if (override) return override;
+  if (process.env.HERMOD_SWAGGER_URL) return process.env.HERMOD_SWAGGER_URL;
+  return `${INTERNAL_SWAGGER_BASE.replace(/\/$/, "")}/gateway/openapi.json`;
+}
+async function fetchSwaggerDocument(swaggerUrl) {
+  const url = getSwaggerUrl(swaggerUrl);
+  const response = await fetch(url, {
+    headers: { Accept: "application/json" }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch swagger from ${url}: ${response.status} ${response.statusText}`);
+  }
+  return await response.json();
+}
+function resolveRef(ref) {
+  return ref.split("/").pop() ?? ref;
+}
+function tsInterfaceName(defName) {
+  const name = defName.split(".").pop() ?? defName;
+  return name ? name[0].toUpperCase() + name.slice(1) : name;
+}
+function tagSlug(tag) {
+  return tag.toLowerCase().replaceAll(" ", "-");
+}
+function isSchemaType(schema, checkType) {
+  const type = schema?.type;
+  if (Array.isArray(type)) return type.includes(checkType);
+  return type === checkType;
+}
+function extractAllRefs(schema) {
+  if (!schema || typeof schema !== "object") return [];
+  if (typeof schema.$ref === "string") return [schema.$ref];
+  const refs = [];
+  if (schema.items) refs.push(...extractAllRefs(schema.items));
+  for (const key of ["allOf", "anyOf", "oneOf"]) {
+    for (const sub of schema[key] ?? []) refs.push(...extractAllRefs(sub));
+  }
+  if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    refs.push(...extractAllRefs(schema.additionalProperties));
+  }
+  for (const propSchema of Object.values(schema.properties ?? {})) {
+    refs.push(...extractAllRefs(propSchema));
+  }
+  return refs;
+}
+function needsQuoting(name) {
+  return Boolean(name) && (name.includes("-") || name.includes(" ") || /^\d/.test(name));
+}
+function openApiPropToTs(prop, definitions) {
+  if (prop.$ref) return tsInterfaceName(resolveRef(prop.$ref));
+  if (Array.isArray(prop.allOf) && prop.allOf.length > 0) {
+    return prop.allOf.map((sub) => openApiPropToTs(sub, definitions)).join(" & ");
+  }
+  for (const key of ["anyOf", "oneOf"]) {
+    if (Array.isArray(prop[key]) && prop[key].length > 0) {
+      return prop[key].map((sub) => openApiPropToTs(sub, definitions)).join(" | ");
+    }
+  }
+  if (Array.isArray(prop.enum) && prop.enum.length > 0) {
+    return prop.enum.map((value) => typeof value === "string" ? `'${value}'` : String(value)).join(" | ");
+  }
+  let type = prop.type ?? "unknown";
+  let nullable = Boolean(prop.nullable);
+  if (Array.isArray(type)) {
+    nullable = nullable || type.includes("null");
+    type = type.find((value) => value !== "null") ?? "unknown";
+  }
+  if (type === "array") {
+    const itemType = openApiPropToTs(prop.items ?? {}, definitions);
+    const base = `${itemType}[]`;
+    return nullable ? `${base} | null` : base;
+  }
+  if (type === "object") {
+    let base = "Record<string, unknown>";
+    if (prop.additionalProperties && typeof prop.additionalProperties === "object") {
+      base = `Record<string, ${openApiPropToTs(prop.additionalProperties, definitions)}>`;
+    } else if (prop.properties && typeof prop.properties === "object") {
+      const required = new Set(prop.required ?? []);
+      const fields = Object.entries(prop.properties).map(([name, schema]) => {
+        const key = needsQuoting(name) ? `'${name}'` : name;
+        const optional = required.has(name) ? "" : "?";
+        return `${key}${optional}: ${openApiPropToTs(schema, definitions)}`;
+      });
+      base = `{ ${fields.join("; ")} }`;
+    }
+    return nullable ? `${base} | null` : base;
+  }
+  const tsType = TYPE_MAP[String(type)] ?? "unknown";
+  return nullable ? `${tsType} | null` : tsType;
+}
+function schemaToTsInterface(name, schema, definitions) {
+  const tsName = tsInterfaceName(name);
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    const values = schema.enum.map((value) => typeof value === "string" ? `'${value}'` : String(value)).join(" | ");
+    return `export type ${tsName} = ${values}
+`;
+  }
+  const properties = { ...schema.properties ?? {} };
+  const extendsParts = [];
+  const required = new Set(schema.required ?? []);
+  for (const sub of schema.allOf ?? []) {
+    if (sub.$ref) {
+      extendsParts.push(tsInterfaceName(resolveRef(sub.$ref)));
+      continue;
+    }
+    Object.assign(properties, sub.properties ?? {});
+    for (const item of sub.required ?? []) required.add(item);
+  }
+  if (Object.keys(properties).length === 0) {
+    let nullable = Boolean(schema.nullable);
+    let schemaType = schema.type;
+    if (Array.isArray(schemaType)) {
+      nullable = nullable || schemaType.includes("null");
+      schemaType = schemaType.find((value) => value !== "null");
+    }
+    const nullSuffix = nullable ? " | null" : "";
+    if (extendsParts.length > 0) {
+      return `export type ${tsName} = ${extendsParts.join(" & ")}${nullSuffix}
+`;
+    }
+    if (isSchemaType(schema, "array")) {
+      const itemType = openApiPropToTs(schema.items ?? {}, definitions);
+      return `export type ${tsName} = ${itemType}[]${nullSuffix}
+`;
+    }
+    if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+      const valueType = openApiPropToTs(schema.additionalProperties, definitions);
+      return `export type ${tsName} = Record<string, ${valueType}>${nullSuffix}
+`;
+    }
+    if (typeof schemaType === "string" && TYPE_MAP[schemaType] && schemaType !== "object") {
+      return `export type ${tsName} = ${TYPE_MAP[schemaType]}${nullSuffix}
+`;
+    }
+    return `export type ${tsName} = Record<string, unknown>${nullSuffix}
+`;
+  }
+  const extendsClause = extendsParts.length > 0 ? ` extends ${extendsParts.join(", ")}` : "";
+  const lines = [`export interface ${tsName}${extendsClause} {`];
+  for (const [propName, propSchema] of Object.entries(properties)) {
+    if (propName === "$schema") continue;
+    const description = propSchema.description;
+    if (description) lines.push(`  /** ${String(description).replaceAll("\n", " ").trim()} */`);
+    const key = needsQuoting(propName) ? `'${propName}'` : propName;
+    const optional = required.has(propName) ? "" : "?";
+    lines.push(`  ${key}${optional}: ${openApiPropToTs(propSchema, definitions)}`);
+  }
+  lines.push("}");
+  return `${lines.join("\n")}
+`;
+}
+function isDataTypeRef(refName) {
+  if (refName.startsWith("DataResponse") || refName.startsWith("DataObjectResponse") || refName.startsWith("SimpleListResponse") || refName.startsWith("CursorDataResponse") || refName.endsWith("InputBody") || ["DataAPIError", "ResponseMeta", "ObjectResponseMeta", "OffsetMeta", "CursorMeta"].includes(refName)) {
+    return false;
+  }
+  return true;
+}
+function isTypedResponse(refName) {
+  return !refName.includes("RawJSON") && !refName.includes("MapStringInterface");
+}
+function getResponseModel(pathSpec) {
+  const schema = pathSpec.responses?.["200"]?.content?.["application/json"]?.schema ?? pathSpec.responses?.["200"]?.schema ?? {};
+  if (schema.$ref) {
+    const refName = resolveRef(schema.$ref);
+    return [refName, isTypedResponse(refName)];
+  }
+  return [null, false];
+}
+function isObjectResponse(respModel) {
+  return Boolean(respModel && respModel.startsWith("DataObjectResponse"));
+}
+function isCursorResponse(respModel) {
+  return Boolean(respModel && respModel.startsWith("CursorDataResponse"));
+}
+function isArrayResponse(respModel) {
+  return respModel.startsWith("DataResponse") || respModel.startsWith("SimpleListResponse") || respModel.startsWith("CursorDataResponse");
+}
+function extractDataItemDefName(respModel, definitions) {
+  if (!respModel) return null;
+  const objectResponse = respModel.startsWith("DataObjectResponse");
+  const arrayResponse = isArrayResponse(respModel) && !objectResponse;
+  if (!objectResponse && !arrayResponse) return null;
+  const modelDef = definitions[respModel] ?? {};
+  const dataProp = modelDef.properties?.data ?? {};
+  if (objectResponse) {
+    if (dataProp.$ref) {
+      const refName2 = resolveRef(dataProp.$ref);
+      return isTypedResponse(refName2) ? refName2 : null;
+    }
+    return null;
+  }
+  const itemRef = dataProp.items?.$ref;
+  if (!itemRef) return null;
+  const refName = resolveRef(itemRef);
+  return isTypedResponse(refName) ? refName : null;
+}
+function extractDataItemType(respModel, definitions) {
+  const defName = extractDataItemDefName(respModel, definitions);
+  return defName ? tsInterfaceName(defName) : null;
+}
+function getBodyParam(params, spec) {
+  for (const param of params) {
+    if (param.in === "body") return param;
+  }
+  const schema = spec?.requestBody?.content?.["application/json"]?.schema;
+  if (schema) return { in: "body", schema };
+  return null;
+}
+function buildParamsInterface(params) {
+  const result = [];
+  for (const param of params) {
+    if (param.in === "body") continue;
+    const schema = param.schema ?? {};
+    let paramType = param.type ?? schema.type ?? "string";
+    const enumValues = schema.enum;
+    let tsType = "string";
+    if (Array.isArray(enumValues) && enumValues.length > 0) {
+      tsType = enumValues.map((value) => typeof value === "string" ? `'${value}'` : String(value)).join(" | ");
+    } else {
+      if (Array.isArray(paramType)) {
+        paramType = paramType.find((value) => value !== "null") ?? "string";
+      }
+      tsType = TYPE_MAP[String(paramType)] ?? "string";
+    }
+    result.push({
+      name: param.name,
+      type: tsType,
+      required: Boolean(param.required),
+      in: param.in ?? "query",
+      description: schema.description ?? param.description,
+      default: schema.default ?? param.default,
+      minimum: schema.minimum,
+      maximum: schema.maximum
+    });
+  }
+  return result;
+}
+function collectRefsFromSchema(schema, refs) {
+  for (const ref of extractAllRefs(schema)) refs.add(tsInterfaceName(resolveRef(ref)));
+}
+function collectBodyTypeRefs(spec) {
+  const refs = /* @__PURE__ */ new Set();
+  const bodyParam = getBodyParam(spec.parameters ?? [], spec);
+  if (!bodyParam) return refs;
+  const bodySchema = bodyParam.schema ?? {};
+  const definition = bodySchema.$ref ? bodySchema : bodySchema;
+  collectRefsFromSchema(definition, refs);
+  return refs;
+}
+function collectSubRefs(names, definitions) {
+  const queue = [...names];
+  while (queue.length > 0) {
+    const defName = queue.pop();
+    const schema = definitions[defName] ?? {};
+    for (const refString of extractAllRefs(schema)) {
+      const refName = resolveRef(refString);
+      if (isDataTypeRef(refName) && !names.has(refName) && definitions[refName]) {
+        names.add(refName);
+        queue.push(refName);
+      }
+    }
+  }
+}
+function categorizeSchemas(definitions, paths) {
+  const tagSchemas = /* @__PURE__ */ new Map();
+  for (const routePath of Object.keys(paths).sort()) {
+    const methods = paths[routePath] ?? {};
+    for (const [method, spec] of Object.entries(methods)) {
+      if (!["get", "post", "put", "delete"].includes(method)) continue;
+      const tags = spec.tags ?? [];
+      if (!tags[0] || !CATEGORY_SET.has(tags[0])) continue;
+      const tag = tags[0];
+      const [respModel] = getResponseModel(spec);
+      const itemDef = extractDataItemDefName(respModel, definitions);
+      if (itemDef && isDataTypeRef(itemDef)) {
+        if (!tagSchemas.has(tag)) tagSchemas.set(tag, /* @__PURE__ */ new Set());
+        tagSchemas.get(tag).add(itemDef);
+      }
+      const bodyParam = getBodyParam(spec.parameters ?? [], spec);
+      if (bodyParam) {
+        const bodySchema = bodyParam.schema ?? {};
+        const bodyDef = bodySchema.$ref ? definitions[resolveRef(bodySchema.$ref)] ?? {} : bodySchema;
+        for (const refString of extractAllRefs(bodyDef)) {
+          const refName = resolveRef(refString);
+          if (!isDataTypeRef(refName)) continue;
+          if (!tagSchemas.has(tag)) tagSchemas.set(tag, /* @__PURE__ */ new Set());
+          tagSchemas.get(tag).add(refName);
+        }
+      }
+    }
+  }
+  const result = {};
+  for (const [tag, names] of tagSchemas.entries()) {
+    collectSubRefs(names, definitions);
+    result[tag] = [...names].sort();
+  }
+  return result;
+}
+function topoSortSchemas(names, definitions) {
+  const nameSet = new Set(names);
+  const deps = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const schema = definitions[name] ?? {};
+    const refs = /* @__PURE__ */ new Set();
+    for (const propSchema of Object.values(schema.properties ?? {})) {
+      for (const refString of extractAllRefs(propSchema)) {
+        const refName = resolveRef(refString);
+        if (nameSet.has(refName) && refName !== name) refs.add(refName);
+      }
+    }
+    deps.set(name, refs);
+  }
+  const dependents = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    dependents.set(name, /* @__PURE__ */ new Set());
+    inDegree.set(name, 0);
+  }
+  for (const [name, nameDeps] of deps.entries()) {
+    for (const dep of nameDeps) {
+      dependents.get(dep)?.add(name);
+      inDegree.set(name, (inDegree.get(name) ?? 0) + 1);
+    }
+  }
+  const queue = names.filter((name) => (inDegree.get(name) ?? 0) === 0).sort();
+  const result = [];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    result.push(name);
+    for (const dependent of [...dependents.get(name) ?? []].sort()) {
+      const next = (inDegree.get(dependent) ?? 0) - 1;
+      inDegree.set(dependent, next);
+      if (next === 0) queue.push(dependent);
+    }
+  }
+  for (const name of [...names].sort()) {
+    if (!result.includes(name)) result.push(name);
+  }
+  return result;
+}
+function buildTypesCommon() {
+  return `/**
+ * Common types \u2014 auto-generated from hermod OpenAPI spec.
+ */
+
+export interface ResponseMeta {
+  total?: number
+  limit?: number
+  offset?: number
+  cached?: boolean
+  credits_used?: number
+}
+
+export interface ApiResponse<T> {
+  data: T[]
+  meta?: ResponseMeta
+  error?: { code: string; message: string }
+}
+
+export interface ApiObjectResponse<T> {
+  data: T
+  meta?: ResponseMeta
+  error?: { code: string; message: string }
+}
+
+export interface CursorMeta {
+  has_more: boolean
+  next_cursor?: string
+  limit?: number
+  cached?: boolean
+  credits_used?: number
+}
+
+export interface ApiCursorResponse<T> {
+  data: T[]
+  meta: CursorMeta
+  error?: { code: string; message: string }
+}
+`;
+}
+function buildTypesCategory(tag, schemaNames, definitions) {
+  const lines = ["/**", ` * ${tag} types \u2014 auto-generated from hermod OpenAPI spec.`, " */", ""];
+  for (const name of schemaNames) lines.push(schemaToTsInterface(name, definitions[name] ?? {}, definitions));
+  return lines.join("\n");
+}
+function funcNameFromPath(routePath) {
+  const clean = routePath.replace("/gateway/v1/", "").replace("/v1/", "");
+  const parts = [];
+  for (const segment of clean.split("/")) {
+    if (segment.startsWith("{") && segment.endsWith("}")) continue;
+    parts.push(segment);
+  }
+  const name = parts.flatMap((part) => part.split("-")).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  return `fetch${name}`;
+}
+function hookNameFromFunc(funcName) {
+  return `use${funcName.slice(5)}`;
+}
+function swaggerTypeToTs(prop) {
+  if (prop.$ref) return tsInterfaceName(resolveRef(prop.$ref));
+  if (isSchemaType(prop, "array")) return `${swaggerTypeToTs(prop.items ?? {})}[]`;
+  let type = prop.type ?? "any";
+  if (Array.isArray(type)) type = type.find((value) => value !== "null") ?? "any";
+  return TYPE_MAP[String(type)] ?? "any";
+}
+function buildApiCore(tagsWithContent, typesTags, forBackend = false) {
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const lines = [
+    "/**",
+    " * Crypto API client \u2014 auto-generated from hermod OpenAPI spec.",
+    ` * Generated at: ${generatedAt}`,
+    " *",
+    ...forBackend ? [
+      " * Backend-only: CommonJS fetch functions, no React Query hooks.",
+      " * Usage: const { fetchMarketPrice } = require('./api')"
+    ] : [
+      " * Core helpers + barrel re-exports from per-category modules.",
+      " * Usage: import { useMarketPrice, proxyGet } from '@/lib/api'"
+    ],
+    " */",
+    ""
+  ];
+  if (forBackend) {
+    lines.push(
+      "const DATA_PROXY_BASE = process.env.DATA_PROXY_BASE || 'http://127.0.0.1:9999/proxy'",
+      "",
+      "function normalizeProxyPath(path) {",
+      "  const trimmed = String(path || '').replace(/^\\/+/, '')",
+      "  return trimmed.replace(/^(?:proxy\\/)+/, '')",
+      "}",
+      "",
+      "async function fetchWithRetry(url, init, retries = 1) {",
+      "  for (let attempt = 0; attempt <= retries; attempt++) {",
+      "    const res = await fetch(url, init)",
+      "    const text = await res.text()",
+      "    if (text) return JSON.parse(text)",
+      "    if (attempt < retries) await new Promise(resolve => setTimeout(resolve, 1000))",
+      "  }",
+      "  throw new Error(`Empty response from ${url.replace(DATA_PROXY_BASE, '')}`)",
+      "}",
+      "",
+      "async function proxyGet(path, params) {",
+      "  const qs = params ? '?' + new URLSearchParams(params).toString() : ''",
+      "  return fetchWithRetry(`${DATA_PROXY_BASE}/${normalizeProxyPath(path)}${qs}`)",
+      "}",
+      "",
+      "async function proxyPost(path, body) {",
+      "  return fetchWithRetry(`${DATA_PROXY_BASE}/${normalizeProxyPath(path)}`, {",
+      "    method: 'POST',",
+      "    headers: { 'Content-Type': 'application/json' },",
+      "    body: body ? JSON.stringify(body) : undefined,",
+      "  })",
+      "}",
+      "",
+      "module.exports.DATA_PROXY_BASE = DATA_PROXY_BASE",
+      "module.exports.normalizeProxyPath = normalizeProxyPath",
+      "module.exports.fetchWithRetry = fetchWithRetry",
+      "module.exports.proxyGet = proxyGet",
+      "module.exports.proxyPost = proxyPost",
+      ""
+    );
+    for (const tag of tagsWithContent) {
+      lines.push(`Object.assign(module.exports, require('./api-${tagSlug(tag)}'))`);
+    }
+    return lines.join("\n");
+  }
+  lines.push("export { API_BASE, normalizeProxyPath, fetchWithRetry, proxyGet, proxyPost } from './fetch'", "");
+  lines.push("export * from './types-common'");
+  for (const tag of typesTags) lines.push(`export * from './types-${tagSlug(tag)}'`);
+  lines.push("");
+  for (const tag of tagsWithContent) lines.push(`export * from './api-${tagSlug(tag)}'`);
+  return lines.join("\n");
+}
+function buildApiIndex(tagPaths, definitions, forBackend = false) {
+  const lines = ["# API Index", ""];
+  const ext = forBackend ? "js" : "ts";
+  lines.push(`Read \`api-{category}.${ext}\` for full signatures and types.`, "");
+  for (const tag of TAG_ORDER) {
+    const endpoints = tagPaths[tag] ?? [];
+    if (endpoints.length === 0) continue;
+    lines.push(`## ${tag} \u2014 \`api-${tagSlug(tag)}.${ext}\``);
+    for (const [, routePath, spec] of endpoints) {
+      const funcName = funcNameFromPath(routePath);
+      const params = buildParamsInterface(spec.parameters ?? []);
+      const bodyParam = getBodyParam(spec.parameters ?? [], spec);
+      const required = params.filter((param) => param.required).map((param) => param.name);
+      if (bodyParam?.schema?.$ref) {
+        const bodyDef = definitions[resolveRef(bodyParam.schema.$ref)] ?? {};
+        required.push(...Object.keys(bodyDef.properties ?? {}).filter((name) => (bodyDef.required ?? []).includes(name)));
+      }
+      const signature = required.length > 0 ? `(${required.join(", ")})` : "()";
+      const description = spec.description || spec.summary;
+      lines.push(`- \`${funcName}${signature}\`${description ? ` \u2014 ${description}` : ""}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function buildQueryKey(funcName) {
+  const parts = funcName.slice(5);
+  const tokens = [];
+  let current = "";
+  for (const char of parts) {
+    if (/[A-Z]/.test(char) && current) {
+      tokens.push(current.toLowerCase());
+      current = char;
+      continue;
+    }
+    current += char;
+  }
+  if (current) tokens.push(current.toLowerCase());
+  return tokens;
+}
+function buildQueryAssignments(queryOnly, paramsOptional) {
+  const lines = [];
+  for (const param of queryOnly) {
+    if (param.required) {
+      lines.push(`  qs['${param.name}'] = String(params.${param.name})`);
+      continue;
+    }
+    if (param.default !== void 0) {
+      const defaultLiteral = typeof param.default === "string" ? `'${param.default}'` : JSON.stringify(param.default);
+      lines.push(`  qs['${param.name}'] = String(params?.${param.name} ?? ${defaultLiteral})`);
+      continue;
+    }
+    lines.push(`  if (params?.${param.name} !== undefined) qs['${param.name}'] = String(params.${param.name})`);
+  }
+  return lines;
+}
+function buildApiCategory(tag, endpoints, definitions, availableTypes, includeHooks = true) {
+  const isBackend = !includeHooks;
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const lines = [
+    "/**",
+    ` * ${tag} API \u2014 auto-generated from hermod OpenAPI spec.`,
+    ` * Generated at: ${generatedAt}`,
+    " */",
+    ""
+  ];
+  const usedTypes = /* @__PURE__ */ new Set();
+  let hasApiResponse = false;
+  let hasApiObjectResponse = false;
+  let hasApiCursorResponse = false;
+  for (const [, , spec] of endpoints) {
+    const [respModel] = getResponseModel(spec);
+    const itemType = extractDataItemType(respModel, definitions);
+    if (itemType && availableTypes.has(itemType)) {
+      usedTypes.add(itemType);
+      if (isObjectResponse(respModel)) hasApiObjectResponse = true;
+      else if (isCursorResponse(respModel)) hasApiCursorResponse = true;
+      else hasApiResponse = true;
+    }
+    for (const ref of collectBodyTypeRefs(spec)) {
+      if (availableTypes.has(ref)) usedTypes.add(ref);
+    }
+  }
+  if (isBackend) {
+    lines.push("'use strict'", "", "const { proxyGet, proxyPost } = require('./api')", "");
+  } else {
+    const imports = ["proxyGet", "proxyPost"];
+    const typeImports = [];
+    if (hasApiResponse) typeImports.push("ApiResponse");
+    if (hasApiObjectResponse) typeImports.push("ApiObjectResponse");
+    if (hasApiCursorResponse) typeImports.push("ApiCursorResponse");
+    for (const typeName of [...usedTypes].sort()) typeImports.push(typeName);
+    const allImports = [
+      ...imports,
+      ...typeImports.map((typeName) => `type ${typeName}`)
+    ];
+    lines.push(`import { ${allImports.join(", ")} } from './api'`);
+    if (includeHooks) {
+      lines.push(
+        "import { useInfiniteQuery, useQuery, type UseInfiniteQueryOptions, type UseQueryOptions } from '@tanstack/react-query'"
+      );
+    }
+    lines.push("");
+  }
+  const generatedFuncs = [];
+  for (const [httpMethod, routePath, spec] of endpoints) {
+    const funcName = funcNameFromPath(routePath);
+    const params = buildParamsInterface(spec.parameters ?? []);
+    const bodyParam = getBodyParam(spec.parameters ?? [], spec);
+    const pathParams = params.filter((param) => param.in === "path");
+    const queryOnly = params.filter((param) => param.in === "query");
+    const hasRequired = params.some((param) => param.required);
+    const hasBody = bodyParam !== null;
+    const paramsOptional = !hasRequired && !hasBody;
+    const [respModel, typedResponse] = getResponseModel(spec);
+    const itemType = extractDataItemType(respModel, definitions);
+    const isCursor = isCursorResponse(respModel);
+    let returnType = "any";
+    if (typedResponse && itemType && availableTypes.has(itemType)) {
+      if (isObjectResponse(respModel)) returnType = `ApiObjectResponse<${itemType}>`;
+      else if (isCursor) returnType = `ApiCursorResponse<${itemType}>`;
+      else returnType = `ApiResponse<${itemType}>`;
+    }
+    const bodyFields = [];
+    const bodyRequired = /* @__PURE__ */ new Set();
+    if (hasBody) {
+      const bodySchema = bodyParam?.schema ?? {};
+      const bodyDefinition = bodySchema.$ref ? definitions[resolveRef(bodySchema.$ref)] ?? {} : bodySchema;
+      for (const field of bodyDefinition.required ?? []) bodyRequired.add(field);
+      for (const [name, schema] of Object.entries(bodyDefinition.properties ?? {})) {
+        if (name === "$schema") continue;
+        bodyFields.push([name, schema]);
+      }
+    }
+    const paramFields = [];
+    for (const param of params) {
+      const optional = param.required ? "" : "?";
+      paramFields.push(`${param.name}${optional}: ${param.type}`);
+    }
+    for (const [name, schema] of bodyFields) {
+      const optional = bodyRequired.has(name) ? "" : "?";
+      paramFields.push(`${name}${optional}: ${swaggerTypeToTs(schema)}`);
+    }
+    lines.push(`/** ${spec.description || spec.summary || funcName} */`);
+    if (isBackend) {
+      if (paramFields.length > 0) lines.push(`async function ${funcName}(params) {`);
+      else lines.push(`async function ${funcName}() {`);
+    } else {
+      if (paramFields.length > 0) {
+        const paramsType = `{ ${paramFields.join("; ")} }`;
+        lines.push(`export async function ${funcName}(params${paramsOptional ? "?" : ""}: ${paramsType}) {`);
+      } else {
+        lines.push(`export async function ${funcName}() {`);
+      }
+    }
+    for (const param of queryOnly.filter((param2) => param2.minimum !== void 0 || param2.maximum !== void 0)) {
+      const accessor = `params${paramsOptional ? "?" : ""}.${param.name}`;
+      let expr = accessor;
+      if (param.minimum !== void 0 && param.maximum !== void 0) {
+        expr = `Math.max(${param.minimum}, Math.min(${param.maximum}, ${accessor}))`;
+      } else if (param.minimum !== void 0) {
+        expr = `Math.max(${param.minimum}, ${accessor})`;
+      } else if (param.maximum !== void 0) {
+        expr = `Math.min(${param.maximum}, ${accessor})`;
+      }
+      if (param.required) lines.push(`  params.${param.name} = ${expr}`);
+      else lines.push(`  if (${accessor} !== undefined) params.${param.name} = ${expr}`);
+    }
+    let proxyPath = routePath.replace("/gateway/v1/", "").replace("/v1/", "");
+    for (const param of pathParams) {
+      proxyPath = proxyPath.replace(`{${param.name}}`, `\${encodeURIComponent(params.${param.name})}`);
+    }
+    if (httpMethod === "POST" || httpMethod === "PUT") {
+      let bodyExpr = "params";
+      if (queryOnly.length > 0 && bodyFields.length > 0) {
+        lines.push(`  const { ${queryOnly.map((param) => param.name).join(", ")}, ...body } = params`);
+        bodyExpr = "body";
+      }
+      if (queryOnly.length > 0) {
+        lines.push(isBackend ? "  const qs = {}" : "  const qs: Record<string, string> = {}");
+        lines.push(...buildQueryAssignments(queryOnly, paramsOptional));
+        lines.push(
+          isBackend ? `  return proxyPost(\`${proxyPath}?\${new URLSearchParams(qs)}\`${bodyFields.length > 0 ? `, ${bodyExpr}` : ""})` : `  return proxyPost<${returnType}>(\`${proxyPath}?\${new URLSearchParams(qs)}\`${bodyFields.length > 0 ? `, ${bodyExpr}` : ""})`
+        );
+      } else if (bodyFields.length > 0) {
+        lines.push(isBackend ? `  return proxyPost(\`${proxyPath}\`, params)` : `  return proxyPost<${returnType}>(\`${proxyPath}\`, params)`);
+      } else {
+        lines.push(isBackend ? `  return proxyPost(\`${proxyPath}\`)` : `  return proxyPost<${returnType}>(\`${proxyPath}\`)`);
+      }
+    } else {
+      if (queryOnly.length > 0) {
+        lines.push(isBackend ? "  const qs = {}" : "  const qs: Record<string, string> = {}");
+        lines.push(...buildQueryAssignments(queryOnly, paramsOptional));
+        lines.push(
+          isBackend ? `  return proxyGet(\`${proxyPath}\`, qs)` : `  return proxyGet<${returnType}>(\`${proxyPath}\`, qs)`
+        );
+      } else {
+        lines.push(isBackend ? `  return proxyGet(\`${proxyPath}\`)` : `  return proxyGet<${returnType}>(\`${proxyPath}\`)`);
+      }
+    }
+    lines.push("}", "");
+    const isMutation = (httpMethod === "POST" || httpMethod === "PUT") && (tag === "Onchain" || tag === "Web");
+    const queryParamNames = new Set(queryOnly.map((param) => param.name));
+    let paginationType = null;
+    if (!isMutation && respModel && isArrayResponse(respModel)) {
+      if (isCursor && queryParamNames.has("cursor")) paginationType = "cursor";
+      else if (queryParamNames.has("limit") && queryParamNames.has("offset")) paginationType = "offset";
+    }
+    generatedFuncs.push({
+      funcName,
+      hasParams: paramFields.length > 0,
+      paramsOptional,
+      returnType,
+      isQuery: !isMutation,
+      paginationType,
+      summary: spec.summary ?? ""
+    });
+  }
+  if (isBackend) {
+    lines.push("module.exports = {");
+    for (const generated of generatedFuncs) lines.push(`  ${generated.funcName},`);
+    lines.push("}", "");
+    return lines.join("\n");
+  }
+  const queryFuncs = generatedFuncs.filter((generated) => generated.isQuery);
+  if (includeHooks && queryFuncs.length > 0) {
+    lines.push("// Hooks", "");
+    lines.push("type QueryOpts<T> = Omit<UseQueryOptions<T, Error>, 'queryKey' | 'queryFn'>", "");
+    for (const generated of queryFuncs) {
+      const hookName = hookNameFromFunc(generated.funcName);
+      const keyTokens = buildQueryKey(generated.funcName).map((token) => `'${token}'`).join(", ");
+      if (generated.hasParams) {
+        lines.push(`export function ${hookName}(params${generated.paramsOptional ? "?" : ""}: Parameters<typeof ${generated.funcName}>[0], opts?: QueryOpts<${generated.returnType}>) {`);
+        lines.push(`  return useQuery({ queryKey: [${keyTokens}, params], queryFn: () => ${generated.funcName}(params${generated.paramsOptional ? "" : "!"}), ...opts })`);
+      } else {
+        lines.push(`export function ${hookName}(opts?: QueryOpts<${generated.returnType}>) {`);
+        lines.push(`  return useQuery({ queryKey: [${keyTokens}], queryFn: () => ${generated.funcName}(), ...opts })`);
+      }
+      lines.push("}", "");
+    }
+    const paginated = queryFuncs.filter((generated) => generated.paginationType !== null);
+    if (paginated.length > 0) {
+      lines.push("// Infinite query hooks", "");
+      if (paginated.some((generated) => generated.paginationType === "offset")) {
+        lines.push("type OffsetInfiniteOpts<T> = Omit<UseInfiniteQueryOptions<T, Error, T, T, unknown[], number>, 'queryKey' | 'queryFn' | 'initialPageParam' | 'getNextPageParam'>");
+      }
+      if (paginated.some((generated) => generated.paginationType === "cursor")) {
+        lines.push("type CursorInfiniteOpts<T> = Omit<UseInfiniteQueryOptions<T, Error, T, T, unknown[], string>, 'queryKey' | 'queryFn' | 'initialPageParam' | 'getNextPageParam'>");
+      }
+      lines.push("");
+      for (const generated of paginated) {
+        const hookName = hookNameFromFunc(generated.funcName).replace(/^use/, "useInfinite");
+        const keyTokens = buildQueryKey(generated.funcName).map((token) => `'${token}'`).join(", ");
+        if (generated.paginationType === "cursor") {
+          lines.push(`export function ${hookName}(params${generated.paramsOptional ? "?" : ""}: Omit<Parameters<typeof ${generated.funcName}>[0], 'cursor'>, opts?: CursorInfiniteOpts<${generated.returnType}>) {`);
+          lines.push("  return useInfiniteQuery({");
+          lines.push(`    queryKey: [${keyTokens}, 'infinite', params],`);
+          lines.push(`    queryFn: ({ pageParam }) => ${generated.funcName}({ ...params${generated.paramsOptional ? "" : "!"}, ...(pageParam ? { cursor: pageParam } : {}) }),`);
+          lines.push("    initialPageParam: '',");
+          lines.push("    getNextPageParam: (lastPage) => {");
+          lines.push("      const meta = (lastPage as any)?.meta");
+          lines.push("      if (!meta?.has_more || !meta?.next_cursor) return undefined");
+          lines.push("      return meta.next_cursor");
+          lines.push("    },");
+          lines.push("    ...opts,");
+          lines.push("  })");
+          lines.push("}", "");
+        } else {
+          lines.push(`export function ${hookName}(params${generated.paramsOptional ? "?" : ""}: Omit<Parameters<typeof ${generated.funcName}>[0], 'offset'>, opts?: OffsetInfiniteOpts<${generated.returnType}>) {`);
+          lines.push("  return useInfiniteQuery({");
+          lines.push(`    queryKey: [${keyTokens}, 'infinite', params],`);
+          lines.push(`    queryFn: ({ pageParam = 0 }) => ${generated.funcName}({ ...params${generated.paramsOptional ? "" : "!"}, offset: pageParam }),`);
+          lines.push("    initialPageParam: 0,");
+          lines.push("    getNextPageParam: (lastPage) => {");
+          lines.push("      const meta = (lastPage as any)?.meta");
+          lines.push("      if (!meta?.total || !meta?.limit) return undefined");
+          lines.push("      const next = (meta.offset ?? 0) + meta.limit");
+          lines.push("      return next < meta.total ? next : undefined");
+          lines.push("    },");
+          lines.push("    ...opts,");
+          lines.push("  })");
+          lines.push("}", "");
+        }
+      }
+    }
+  }
+  return lines.join("\n");
+}
+async function generateApiFiles({
+  swaggerUrl,
+  logger = () => {
+  }
+} = {}) {
+  const doc = await fetchSwaggerDocument(swaggerUrl);
+  const definitions = doc.components?.schemas ?? {};
+  const paths = doc.paths ?? {};
+  const tagPaths = {};
+  for (const routePath of Object.keys(paths).sort()) {
+    const methods = paths[routePath] ?? {};
+    for (const [method, spec] of Object.entries(methods)) {
+      if (!["get", "post", "put", "delete"].includes(method)) continue;
+      const tags = spec.tags ?? [];
+      if (!tags[0] || !CATEGORY_SET.has(tags[0])) continue;
+      if (BLOCKED_PATHS.has(routePath)) continue;
+      if (!tagPaths[tags[0]]) tagPaths[tags[0]] = [];
+      tagPaths[tags[0]].push([method.toUpperCase(), routePath, spec]);
+    }
+  }
+  const categorySchemas = categorizeSchemas(definitions, paths);
+  const availableTypes = /* @__PURE__ */ new Set();
+  for (const names of Object.values(categorySchemas)) {
+    for (const name of names) availableTypes.add(tsInterfaceName(name));
+  }
+  const categoryFiles = {};
+  const tagsWithContent = [];
+  for (const tag of TAG_ORDER) {
+    const endpoints = tagPaths[tag] ?? [];
+    if (endpoints.length === 0) continue;
+    tagsWithContent.push(tag);
+    categoryFiles[`api-${tagSlug(tag)}.ts`] = buildApiCategory(tag, endpoints, definitions, availableTypes, true);
+  }
+  const typesTags = [];
+  const result = {
+    "types-common.ts": buildTypesCommon()
+  };
+  for (const tag of TAG_ORDER) {
+    const schemaNames = categorySchemas[tag] ?? [];
+    if (schemaNames.length === 0) continue;
+    typesTags.push(tag);
+    result[`types-${tagSlug(tag)}.ts`] = buildTypesCategory(
+      tag,
+      topoSortSchemas(schemaNames, definitions),
+      definitions
+    );
+  }
+  result["api.ts"] = buildApiCore(tagsWithContent, typesTags, false);
+  result["API_INDEX.md"] = buildApiIndex(tagPaths, definitions, false);
+  Object.assign(result, categoryFiles);
+  result["backend/api.js"] = buildApiCore(tagsWithContent, typesTags, true);
+  result["backend/API_INDEX.md"] = buildApiIndex(tagPaths, definitions, true);
+  for (const tag of TAG_ORDER) {
+    const endpoints = tagPaths[tag] ?? [];
+    if (endpoints.length === 0) continue;
+    result[`backend/api-${tagSlug(tag)}.js`] = buildApiCategory(tag, endpoints, definitions, availableTypes, false);
+  }
+  logger(`  generated ${Object.keys(result).length} API files from ${getSwaggerUrl(swaggerUrl)}`);
+  return result;
+}
+
+// src/index.ts
+var DEFAULT_FRONTEND_PORT = "5173";
+var DEFAULT_BACKEND_PORT = "3001";
+var DEFAULT_TEMPLATE = "default";
+async function createSurfApp({
+  projectName = ".",
+  frontendPort = process.env.VITE_PORT || DEFAULT_FRONTEND_PORT,
+  backendPort = process.env.VITE_BACKEND_PORT || DEFAULT_BACKEND_PORT,
+  previewBase = process.env.VITE_BASE,
+  swaggerUrl,
+  logger = console.log
+} = {}) {
+  const root = path.resolve(projectName);
+  const name = path.basename(root);
+  const validatedFrontendPort = validatePort("frontend", frontendPort);
+  const validatedBackendPort = validatePort("backend", backendPort);
+  const templateDir = resolveTemplateDir(DEFAULT_TEMPLATE);
+  logger(`
+  Creating Surf app in ${root}
+`);
+  fs.mkdirSync(root, { recursive: true });
+  copyDir(templateDir, root, root, logger);
+  writeEnvFiles(root, validatedFrontendPort, validatedBackendPort, previewBase);
+  await generateAndWriteApiFiles(root, swaggerUrl, logger);
+  logger(`
+Done! Next steps:
+
+  cd ${name}
+  cd backend && npm install && cd ..
+  cd frontend && npm install && cd ..
+
+  # Start backend
+  cd backend && PORT=${validatedBackendPort} npm run dev &
+
+  # Start frontend
+  cd frontend && npm run dev
+
+  Open http://localhost:${validatedFrontendPort}
+`);
+  return root;
+}
+function resolveTemplateDir(templateName) {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path.join(here, "templates", templateName),
+    path.join(here, "..", "templates", templateName)
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  throw new Error(`Could not find template "${templateName}" near ${here}`);
+}
+function copyDir(src, dest, root, logger) {
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      fs.mkdirSync(destPath, { recursive: true });
+      copyDir(srcPath, destPath, root, logger);
+      continue;
+    }
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.writeFileSync(destPath, fs.readFileSync(srcPath));
+    logger(`  ${path.relative(root, destPath)}`);
+  }
+}
+function validatePort(label, value) {
+  const port = Number.parseInt(value, 10);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid ${label} port: ${value}`);
+  }
+  return String(port);
+}
+function writeEnvFiles(root, frontendPort, backendPort, previewBase) {
+  const backendEnvPath = path.join(root, "backend", ".env");
+  const frontendEnvPath = path.join(root, "frontend", ".env");
+  fs.writeFileSync(backendEnvPath, `PORT=${backendPort}${os.EOL}`);
+  let frontendEnv = `VITE_PORT=${frontendPort}${os.EOL}VITE_BACKEND_PORT=${backendPort}${os.EOL}`;
+  if (previewBase) {
+    frontendEnv += `VITE_BASE=${previewBase}${os.EOL}`;
+  }
+  fs.writeFileSync(frontendEnvPath, frontendEnv);
+}
+async function generateAndWriteApiFiles(root, swaggerUrl, logger) {
+  const frontendLibDir = path.join(root, "frontend", "src", "lib");
+  const backendLibDir = path.join(root, "backend", "lib");
+  fs.mkdirSync(frontendLibDir, { recursive: true });
+  fs.mkdirSync(backendLibDir, { recursive: true });
+  removeGeneratedApiFiles(frontendLibDir, backendLibDir);
+  try {
+    const apiFiles = await generateApiFiles({ swaggerUrl, logger });
+    for (const [filename, content] of Object.entries(apiFiles)) {
+      if (filename.startsWith("backend/")) {
+        const relPath = filename.slice("backend/".length);
+        const filePath = path.join(backendLibDir, relPath);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, content);
+      } else {
+        const filePath = path.join(frontendLibDir, filename);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, content);
+      }
+    }
+  } catch (error) {
+    logger(`  failed to generate API files from swagger, using fallback: ${String(error)}`);
+    fs.writeFileSync(path.join(frontendLibDir, "api.ts"), FALLBACK_API_TS);
+  }
+}
+function removeGeneratedApiFiles(frontendLibDir, backendLibDir) {
+  if (fs.existsSync(frontendLibDir)) {
+    for (const entry of fs.readdirSync(frontendLibDir)) {
+      if (entry === "fetch.ts" || entry === "utils.ts") continue;
+      if (entry === "api.ts" || entry === "API_INDEX.md" || /^api-.*\.ts$/.test(entry) || /^types-.*\.ts$/.test(entry)) {
+        fs.rmSync(path.join(frontendLibDir, entry), { force: true, recursive: true });
+      }
+    }
+  }
+  if (fs.existsSync(backendLibDir)) {
+    for (const entry of fs.readdirSync(backendLibDir)) {
+      if (entry === "db.js") continue;
+      if (entry === "api.js" || entry === "API_INDEX.md" || /^api-.*\.js$/.test(entry)) {
+        fs.rmSync(path.join(backendLibDir, entry), { force: true, recursive: true });
+      }
+    }
+  }
+}
+
+export {
+  createSurfApp
+};