@hyperfixi/server-bridge 2.0.0

package/dist/index.cjs

@@ -0,0 +1,1426 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DjangoGenerator: () => DjangoGenerator,
+  ExpressGenerator: () => ExpressGenerator,
+  FastAPIGenerator: () => FastAPIGenerator,
+  HonoGenerator: () => HonoGenerator,
+  OpenAPIGenerator: () => OpenAPIGenerator,
+  createManifest: () => createManifest,
+  detectConflicts: () => detectConflicts,
+  diffRoutes: () => diffRoutes,
+  extractFormBodies: () => extractFormBodies,
+  extractFormFields: () => extractFormFields,
+  extractHtmxRoutes: () => extractHtmxRoutes,
+  extractHyperscriptRoutes: () => extractHyperscriptRoutes,
+  extractPathParams: () => extractPathParams,
+  extractQueryParams: () => extractQueryParams,
+  formatConflicts: () => formatConflicts,
+  generate: () => generate,
+  inferConventions: () => inferConventions,
+  loadManifest: () => loadManifest,
+  normalizeUrl: () => normalizeUrl,
+  saveManifest: () => saveManifest,
+  scanDirectory: () => scanDirectory,
+  scanRoutes: () => scanRoutes,
+  selectGenerator: () => selectGenerator,
+  urlToHandlerName: () => urlToHandlerName
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/conventions/url-patterns.ts
+function extractPathParams(url) {
+  const params = [];
+  for (const match of url.matchAll(/:(\w+)/g)) {
+    params.push(match[1]);
+  }
+  for (const match of url.matchAll(/\{(\w+)\}/g)) {
+    if (!params.includes(match[1])) {
+      params.push(match[1]);
+    }
+  }
+  return params;
+}
+function normalizeUrl(url) {
+  let normalized = url.split("?")[0].split("#")[0];
+  normalized = normalized.replace(/\{(\w+)\}/g, ":$1");
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function urlToHandlerName(url, method) {
+  const prefix = method.toLowerCase();
+  const segments = url.replace(/^\//, "").split("/").map((segment) => {
+    if (segment.startsWith(":")) {
+      const param = segment.slice(1);
+      return "By" + capitalize(param);
+    }
+    return segment.split(/[-_]/).map(capitalize).join("");
+  });
+  return prefix + segments.join("");
+}
+function extractQueryParams(url) {
+  const queryIndex = url.indexOf("?");
+  if (queryIndex === -1) return [];
+  const queryString = url.slice(queryIndex + 1).split("#")[0];
+  if (!queryString) return [];
+  const params = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pair of queryString.split("&")) {
+    const eqIndex = pair.indexOf("=");
+    const rawName = eqIndex === -1 ? pair : pair.slice(0, eqIndex);
+    if (!rawName) continue;
+    let name;
+    try {
+      name = decodeURIComponent(rawName);
+    } catch {
+      name = rawName;
+    }
+    if (seen.has(name)) continue;
+    seen.add(name);
+    params.push({ name, type: "string", required: true });
+  }
+  return params;
+}
+function capitalize(s) {
+  if (!s) return "";
+  return s[0].toUpperCase() + s.slice(1);
+}
+
+// src/conventions/convention-engine.ts
+function inferConventions(url, context = {}) {
+  const notes = [];
+  let method;
+  if (context.explicitMethod) {
+    method = context.explicitMethod.toUpperCase();
+  } else if (context.elementTag === "form") {
+    method = "POST";
+    notes.push("Inferred POST from <form> context");
+  } else {
+    method = "GET";
+  }
+  let responseFormat;
+  if (context.fetchResponseType) {
+    const fmt = context.fetchResponseType.toLowerCase();
+    if (fmt === "json" || fmt === "html" || fmt === "text") {
+      responseFormat = fmt;
+    } else {
+      responseFormat = "json";
+      notes.push(`Unknown response type "${context.fetchResponseType}", defaulting to json`);
+    }
+  } else if (url.endsWith(".html") || url.includes("/pages/") || url.includes("/partials/")) {
+    responseFormat = "html";
+    notes.push("Inferred html response from URL pattern");
+  } else {
+    responseFormat = "json";
+  }
+  const handlerName = urlToHandlerName(url, method);
+  return { method, responseFormat, handlerName, notes };
+}
+
+// src/scanner/hyperscript-extractor.ts
+var ATTR_PATTERNS = [
+  /_\s*=\s*"([^"]+)"/g,
+  /_\s*=\s*'([^']+)'/g,
+  /_\s*=\s*`([^`]+)`/g,
+  /_=\{`([^`]+)`\}/g,
+  // JSX template literal
+  /_=\{['"]([^'"]+)['"]\}/g
+  // JSX string
+];
+var SCRIPT_PATTERN = /<script[^>]*type=["']?text\/hyperscript["']?[^>]*>([\s\S]*?)<\/script>/gi;
+var FETCH_COMMAND = /\bfetch\s+['"]?([^\s'"]+)['"]?(?:\s+as\s+(\w+))?(?:\s+via\s+(\w+))?/gi;
+var SEND_FORM = /\bsend\s+(?:the\s+)?form\s+to\s+['"]?([^\s'"]+)['"]?(?:\s+as\s+(\w+))?/gi;
+function extractHyperscriptRoutes(content, options) {
+  const routes = [];
+  const seen = /* @__PURE__ */ new Set();
+  const regions = extractHyperscriptRegions(content);
+  for (const region of regions) {
+    for (const match of region.code.matchAll(FETCH_COMMAND)) {
+      const rawUrl = match[1];
+      const responseType = match[2];
+      const method = match[3];
+      addRoute(routes, seen, rawUrl, {
+        file: options.file,
+        line: region.line,
+        kind: "fetch",
+        raw: match[0],
+        explicitMethod: method,
+        fetchResponseType: responseType
+      });
+    }
+    for (const match of region.code.matchAll(SEND_FORM)) {
+      const rawUrl = match[1];
+      const responseType = match[2];
+      addRoute(routes, seen, rawUrl, {
+        file: options.file,
+        line: region.line,
+        kind: "fetch",
+        raw: match[0],
+        explicitMethod: "POST",
+        fetchResponseType: responseType
+      });
+    }
+  }
+  return routes;
+}
+function extractHyperscriptRegions(content) {
+  const regions = [];
+  const lines = content.split("\n");
+  for (const pattern of ATTR_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match2;
+    while ((match2 = pattern.exec(content)) !== null) {
+      const line = lineNumberAt(content, match2.index);
+      regions.push({ code: match2[1], line });
+    }
+  }
+  SCRIPT_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = SCRIPT_PATTERN.exec(content)) !== null) {
+    const line = lineNumberAt(content, match.index);
+    regions.push({ code: match[1], line });
+  }
+  return regions;
+}
+function lineNumberAt(content, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < content.length; i++) {
+    if (content[i] === "\n") line++;
+  }
+  return line;
+}
+function addRoute(routes, seen, rawUrl, options) {
+  if (rawUrl.startsWith("http://") || rawUrl.startsWith("https://")) {
+    return;
+  }
+  if (rawUrl.startsWith("{{") || rawUrl.startsWith("${")) {
+    return;
+  }
+  if (!rawUrl.startsWith("/") && !rawUrl.includes("/")) {
+    return;
+  }
+  const queryParams = extractQueryParams(rawUrl);
+  const path = normalizeUrl(rawUrl);
+  const conventions = inferConventions(path, {
+    explicitMethod: options.explicitMethod,
+    fetchResponseType: options.fetchResponseType
+  });
+  const key = `${conventions.method}:${path}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  routes.push({
+    path,
+    method: conventions.method,
+    responseFormat: conventions.responseFormat,
+    source: {
+      file: options.file,
+      line: options.line,
+      kind: options.kind,
+      raw: options.raw
+    },
+    pathParams: extractPathParams(path),
+    ...queryParams.length > 0 ? { queryParams } : {},
+    handlerName: conventions.handlerName,
+    notes: conventions.notes
+  });
+}
+
+// src/scanner/htmx-extractor.ts
+var HTMX_REQUEST_PATTERN = /\b(hx-get|hx-post|hx-put|hx-patch|hx-delete)\s*=\s*["']([^"']+)["']/gi;
+var FIXI_ACTION_PATTERN = /\bfx-action\s*=\s*["']([^"']+)["']/gi;
+var FIXI_METHOD_PATTERN = /\bfx-method\s*=\s*["'](GET|POST|PUT|PATCH|DELETE)["']/gi;
+var HTMX_METHOD_MAP = {
+  "hx-get": "GET",
+  "hx-post": "POST",
+  "hx-put": "PUT",
+  "hx-patch": "PATCH",
+  "hx-delete": "DELETE"
+};
+function extractHtmxRoutes(content, options) {
+  const routes = [];
+  const seen = /* @__PURE__ */ new Set();
+  HTMX_REQUEST_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = HTMX_REQUEST_PATTERN.exec(content)) !== null) {
+    const attrName = match[1].toLowerCase();
+    const rawUrl = match[2];
+    const method = HTMX_METHOD_MAP[attrName];
+    if (!method) continue;
+    addRoute2(routes, seen, rawUrl, {
+      file: options.file,
+      line: lineNumberAt2(content, match.index),
+      kind: "hx-attr",
+      raw: `${match[1]}="${match[2]}"`,
+      explicitMethod: method,
+      // htmx default response is html (server-rendered partials)
+      fetchResponseType: "html"
+    });
+  }
+  const fxMethods = collectFxMethods(content);
+  FIXI_ACTION_PATTERN.lastIndex = 0;
+  while ((match = FIXI_ACTION_PATTERN.exec(content)) !== null) {
+    const rawUrl = match[1];
+    const line = lineNumberAt2(content, match.index);
+    const nearbyMethod = findNearbyFxMethod(content, match.index, fxMethods);
+    addRoute2(routes, seen, rawUrl, {
+      file: options.file,
+      line,
+      kind: "fx-attr",
+      raw: `fx-action="${match[1]}"`,
+      explicitMethod: nearbyMethod
+    });
+  }
+  return routes;
+}
+function lineNumberAt2(content, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < content.length; i++) {
+    if (content[i] === "\n") line++;
+  }
+  return line;
+}
+function collectFxMethods(content) {
+  const methods = [];
+  FIXI_METHOD_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = FIXI_METHOD_PATTERN.exec(content)) !== null) {
+    methods.push({ method: match[1], index: match.index });
+  }
+  return methods;
+}
+function findNearbyFxMethod(content, actionIndex, fxMethods) {
+  for (const fm of fxMethods) {
+    if (Math.abs(fm.index - actionIndex) < 300) {
+      return fm.method;
+    }
+  }
+  return void 0;
+}
+function addRoute2(routes, seen, rawUrl, options) {
+  if (rawUrl.startsWith("http://") || rawUrl.startsWith("https://")) {
+    return;
+  }
+  const queryParams = extractQueryParams(rawUrl);
+  const path = normalizeUrl(rawUrl);
+  const conventions = inferConventions(path, {
+    explicitMethod: options.explicitMethod,
+    fetchResponseType: options.fetchResponseType
+  });
+  const key = `${conventions.method}:${path}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  routes.push({
+    path,
+    method: conventions.method,
+    responseFormat: conventions.responseFormat,
+    source: {
+      file: options.file,
+      line: options.line,
+      kind: options.kind,
+      raw: options.raw
+    },
+    pathParams: extractPathParams(path),
+    ...queryParams.length > 0 ? { queryParams } : {},
+    handlerName: conventions.handlerName,
+    notes: conventions.notes
+  });
+}
+
+// src/scanner/form-scanner.ts
+var FORM_BLOCK = /<form\b[^>]*>([\s\S]*?)<\/form>/gi;
+var NAMED_FIELD = /<(input|select|textarea)\b([^>]*)\bname\s*=\s*["']([^"']+)["']([^>]*)>/gi;
+var TYPE_ATTR = /\btype\s*=\s*["']([^"']+)["']/i;
+var REQUIRED_ATTR = /\brequired\b/i;
+var TYPE_MAP = {
+  text: "string",
+  email: "string",
+  password: "string",
+  tel: "string",
+  url: "string",
+  search: "string",
+  hidden: "string",
+  color: "string",
+  date: "string",
+  "datetime-local": "string",
+  month: "string",
+  week: "string",
+  time: "string",
+  number: "number",
+  range: "number",
+  checkbox: "boolean",
+  file: "file"
+};
+function extractFormFields(formInnerHtml) {
+  const fields = [];
+  const seen = /* @__PURE__ */ new Set();
+  NAMED_FIELD.lastIndex = 0;
+  let match;
+  while ((match = NAMED_FIELD.exec(formInnerHtml)) !== null) {
+    const tag = match[1].toLowerCase();
+    const attrsBefore = match[2];
+    const name = match[3];
+    const attrsAfter = match[4];
+    const allAttrs = attrsBefore + " " + attrsAfter;
+    if (seen.has(name)) continue;
+    seen.add(name);
+    let type = "string";
+    if (tag === "select" || tag === "textarea") {
+      type = "string";
+    } else {
+      const typeMatch = allAttrs.match(TYPE_ATTR);
+      const inputType = typeMatch ? typeMatch[1].toLowerCase() : "text";
+      type = TYPE_MAP[inputType] ?? "unknown";
+    }
+    const required = REQUIRED_ATTR.test(allAttrs);
+    fields.push({ name, type, required });
+  }
+  return fields;
+}
+function extractFormBodies(content) {
+  const result = /* @__PURE__ */ new Map();
+  FORM_BLOCK.lastIndex = 0;
+  let match;
+  while ((match = FORM_BLOCK.exec(content)) !== null) {
+    const formTag = content.slice(
+      match.index,
+      match.index + content.slice(match.index).indexOf(">") + 1
+    );
+    const formBody = match[1];
+    const url = extractFormUrl(formTag);
+    if (!url) continue;
+    const fields = extractFormFields(formBody);
+    if (fields.length > 0) {
+      result.set(url, fields);
+    }
+  }
+  return result;
+}
+function extractFormUrl(formTag) {
+  const hxMatch = formTag.match(/\bhx-(?:post|put|patch)\s*=\s*["']([^"']+)["']/i);
+  if (hxMatch) return hxMatch[1];
+  const fxMatch = formTag.match(/\bfx-action\s*=\s*["']([^"']+)["']/i);
+  if (fxMatch) return fxMatch[1];
+  const hsMatch = formTag.match(/\bsend\s+(?:the\s+)?form\s+to\s+['"]?([^\s'"]+)['"]?/i);
+  if (hsMatch) return hsMatch[1];
+  return void 0;
+}
+
+// src/scanner/route-scanner.ts
+var import_promises = require("fs/promises");
+var import_glob = require("glob");
+
+// src/scanner/conflict-detector.ts
+function detectConflicts(routes) {
+  const warnings = [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const key = `${route.method}:${route.path}`;
+    const existing = groups.get(key) ?? [];
+    existing.push(route);
+    groups.set(key, existing);
+  }
+  for (const [key, groupRoutes] of groups) {
+    if (groupRoutes.length < 2) continue;
+    const conflicts = [];
+    const formats = [...new Set(groupRoutes.map((r) => r.responseFormat))];
+    if (formats.length > 1) {
+      conflicts.push({
+        field: "responseFormat",
+        values: formats,
+        message: `Conflicting response formats: ${formats.join(" vs ")}`
+      });
+    }
+    if (["POST", "PUT", "PATCH"].includes(groupRoutes[0].method)) {
+      const bodySignatures = groupRoutes.map(
+        (r) => JSON.stringify((r.requestBody ?? []).map((f) => f.name).sort())
+      );
+      const uniqueSignatures = [...new Set(bodySignatures)];
+      if (uniqueSignatures.length > 1) {
+        conflicts.push({
+          field: "requestBody",
+          values: uniqueSignatures,
+          message: "Request body fields differ across declarations"
+        });
+      }
+    }
+    const querySignatures = groupRoutes.map(
+      (r) => JSON.stringify((r.queryParams ?? []).map((p) => p.name).sort())
+    );
+    const uniqueQuerySigs = [...new Set(querySignatures)];
+    if (uniqueQuerySigs.length > 1) {
+      conflicts.push({
+        field: "queryParams",
+        values: uniqueQuerySigs,
+        message: "Query parameters differ across declarations"
+      });
+    }
+    if (conflicts.length > 0) {
+      warnings.push({
+        routeKey: key,
+        conflicts,
+        sources: groupRoutes.map((r) => r.source)
+      });
+    }
+  }
+  return warnings;
+}
+function formatConflicts(warnings) {
+  const lines = [];
+  for (const warning of warnings) {
+    lines.push(`  ${warning.routeKey}:`);
+    for (const conflict of warning.conflicts) {
+      lines.push(`    - ${conflict.message}`);
+    }
+    lines.push(`    Sources:`);
+    for (const source of warning.sources) {
+      lines.push(`      ${source.file}:${source.line ?? "?"} (${source.kind})`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/scanner/route-scanner.ts
+var DEFAULT_INCLUDE = ["**/*.html", "**/*.htm"];
+var DEFAULT_EXCLUDE = ["**/node_modules/**", "**/dist/**", "**/.git/**"];
+function scanRoutes(content, file) {
+  const hsRoutes = extractHyperscriptRoutes(content, { file });
+  const htmxRoutes = extractHtmxRoutes(content, { file });
+  const all = [...hsRoutes, ...htmxRoutes];
+  const deduped = deduplicateRoutes(all);
+  const formBodies = extractFormBodies(content);
+  for (const route of deduped) {
+    if (["POST", "PUT", "PATCH"].includes(route.method)) {
+      const rawUrl = route.path;
+      const fields = formBodies.get(rawUrl);
+      if (fields && fields.length > 0) {
+        route.requestBody = fields;
+      }
+    }
+  }
+  return deduped;
+}
+async function scanDirectory(dir, options = {}) {
+  const include = options.include ?? DEFAULT_INCLUDE;
+  const exclude = options.exclude ?? DEFAULT_EXCLUDE;
+  const files = [];
+  for (const pattern of include) {
+    const matches = await (0, import_glob.glob)(pattern, {
+      cwd: dir,
+      absolute: true,
+      ignore: exclude
+    });
+    files.push(...matches);
+  }
+  const uniqueFiles = [...new Set(files)];
+  const allRoutes = [];
+  const errors = [];
+  for (const file of uniqueFiles) {
+    try {
+      const content = await (0, import_promises.readFile)(file, "utf-8");
+      const routes = scanRoutes(content, file);
+      allRoutes.push(...routes);
+    } catch (err) {
+      errors.push({
+        file,
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const conflicts = detectConflicts(allRoutes);
+  const deduped = deduplicateRoutes(allRoutes);
+  const ignored = options.ignore ?? [];
+  const filtered = deduped.filter(
+    (route) => !ignored.some((pattern) => matchIgnorePattern(route.path, pattern))
+  );
+  return {
+    routes: filtered,
+    filesScanned: uniqueFiles,
+    errors,
+    conflicts
+  };
+}
+function deduplicateRoutes(routes) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const key = `${route.method}:${route.path}`;
+    if (!seen.has(key)) {
+      seen.set(key, route);
+    }
+  }
+  return [...seen.values()];
+}
+function matchIgnorePattern(path, pattern) {
+  if (pattern.endsWith("/**")) {
+    const prefix = pattern.slice(0, -3);
+    return path.startsWith(prefix);
+  }
+  return path === pattern;
+}
+
+// src/generators/template-helpers.ts
+var ROUTE_MARKER = "// @serverbridge-route:";
+var USER_START = "// @serverbridge-user-start";
+var USER_END = "// @serverbridge-user-end";
+function routeMarker(route) {
+  return `${ROUTE_MARKER} ${route.method} ${route.path}`;
+}
+function todoBlock(route, indent = "  ") {
+  const lines = [];
+  lines.push(`${indent}// TODO: Implement ${route.method} ${route.path}`);
+  if (route.pathParams.length > 0) {
+    lines.push(`${indent}// Path params: ${route.pathParams.join(", ")}`);
+  }
+  if (route.queryParams && route.queryParams.length > 0) {
+    lines.push(`${indent}// Query params: ${route.queryParams.map((p) => p.name).join(", ")}`);
+  }
+  if (route.requestBody && route.requestBody.length > 0) {
+    const fields = route.requestBody.map((f) => `${f.name}: ${f.type}${f.required ? "" : "?"}`).join(", ");
+    lines.push(`${indent}// Expected body: { ${fields} }`);
+  }
+  if (route.notes.length > 0) {
+    for (const note of route.notes) {
+      lines.push(`${indent}// Note: ${note}`);
+    }
+  }
+  return lines.join("\n");
+}
+function groupRoutesByPrefix(routes) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const segments = route.path.replace(/^\//, "").split("/");
+    const groupKey = segments.slice(0, Math.min(2, segments.length)).filter((s) => !s.startsWith(":")).join("-") || "root";
+    const group = groups.get(groupKey) ?? [];
+    group.push(route);
+    groups.set(groupKey, group);
+  }
+  return groups;
+}
+function groupToFilename(groupKey, typescript) {
+  return `${groupKey}.${typescript ? "ts" : "js"}`;
+}
+
+// src/generators/express-generator.ts
+var ExpressGenerator = class {
+  framework = "express";
+  generate(routes, options) {
+    const ts = options.typescript !== false;
+    const files = [];
+    const warnings = [];
+    if (routes.length === 0) {
+      warnings.push("No routes to generate");
+      return { files, preserved: [], warnings };
+    }
+    const groups = groupRoutesByPrefix(routes);
+    for (const [groupKey, groupRoutes] of groups) {
+      const filename = groupToFilename(groupKey, ts);
+      const content = this.generateRouterFile(groupRoutes, groupKey, ts);
+      files.push({ path: `routes/${filename}`, content, isNew: true });
+    }
+    const indexContent = this.generateIndex(groups, ts);
+    files.push({ path: `routes/index.${ts ? "ts" : "js"}`, content: indexContent, isNew: true });
+    return { files, preserved: [], warnings };
+  }
+  generateRouterFile(routes, groupKey, ts) {
+    const lines = [];
+    lines.push(`// Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT scaffold markers`);
+    lines.push(`import { Router${ts ? ", Request, Response" : ""} } from 'express';`);
+    lines.push("");
+    lines.push("const router = Router();");
+    lines.push("");
+    for (const route of routes) {
+      lines.push(routeMarker(route));
+      lines.push(this.generateHandler(route, ts));
+      lines.push("");
+    }
+    lines.push("export default router;");
+    lines.push("");
+    return lines.join("\n");
+  }
+  generateHandler(route, ts) {
+    const method = route.method.toLowerCase();
+    const params = ts ? "(req: Request, res: Response)" : "(req, res)";
+    const lines = [];
+    lines.push(`router.${method}('${route.path}', async ${params} => {`);
+    lines.push(`  ${USER_START}`);
+    lines.push(todoBlock(route, "  "));
+    if (route.pathParams.length > 0) {
+      const paramList = route.pathParams.join(", ");
+      lines.push(`  const { ${paramList} } = req.params;`);
+    }
+    if (route.queryParams && route.queryParams.length > 0) {
+      const paramList = route.queryParams.map((p) => p.name).join(", ");
+      lines.push(`  const { ${paramList} } = req.query;`);
+    }
+    if (route.requestBody && route.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(route.method)) {
+      const fieldList = route.requestBody.map((f) => f.name).join(", ");
+      lines.push(`  const { ${fieldList} } = req.body;`);
+    }
+    if (route.responseFormat === "json") {
+      lines.push(`  res.json({ message: 'Not implemented' });`);
+    } else if (route.responseFormat === "html") {
+      lines.push(`  res.send('<div>Not implemented</div>');`);
+    } else {
+      lines.push(`  res.send('Not implemented');`);
+    }
+    lines.push(`  ${USER_END}`);
+    lines.push(`});`);
+    return lines.join("\n");
+  }
+  generateIndex(groups, ts) {
+    const lines = [];
+    lines.push(`// Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT`);
+    lines.push(`import { Router } from 'express';`);
+    for (const groupKey of groups.keys()) {
+      const filename = groupKey;
+      lines.push(`import ${toCamelCase(groupKey)}Router from './${filename}.js';`);
+    }
+    lines.push("");
+    lines.push("const router = Router();");
+    lines.push("");
+    for (const groupKey of groups.keys()) {
+      lines.push(`router.use(${toCamelCase(groupKey)}Router);`);
+    }
+    lines.push("");
+    lines.push("export default router;");
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+function toCamelCase(str) {
+  return str.replace(/-(\w)/g, (_, c) => c.toUpperCase());
+}
+
+// src/generators/hono-generator.ts
+var HonoGenerator = class {
+  framework = "hono";
+  generate(routes, options) {
+    const ts = options.typescript !== false;
+    const files = [];
+    const warnings = [];
+    if (routes.length === 0) {
+      warnings.push("No routes to generate");
+      return { files, preserved: [], warnings };
+    }
+    const groups = groupRoutesByPrefix(routes);
+    for (const [groupKey, groupRoutes] of groups) {
+      const filename = groupToFilename(groupKey, ts);
+      const content = this.generateRouteFile(groupRoutes, groupKey, ts);
+      files.push({ path: `routes/${filename}`, content, isNew: true });
+    }
+    const indexContent = this.generateIndex(groups, ts);
+    files.push({ path: `routes/index.${ts ? "ts" : "js"}`, content: indexContent, isNew: true });
+    return { files, preserved: [], warnings };
+  }
+  generateRouteFile(routes, groupKey, ts) {
+    const lines = [];
+    lines.push(`// Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT scaffold markers`);
+    lines.push(`import { Hono } from 'hono';`);
+    lines.push("");
+    lines.push("const app = new Hono();");
+    lines.push("");
+    for (const route of routes) {
+      lines.push(routeMarker(route));
+      lines.push(this.generateHandler(route, ts));
+      lines.push("");
+    }
+    lines.push("export default app;");
+    lines.push("");
+    return lines.join("\n");
+  }
+  generateHandler(route, ts) {
+    const method = route.method.toLowerCase();
+    const lines = [];
+    lines.push(`app.${method}('${route.path}', async (c) => {`);
+    lines.push(`  ${USER_START}`);
+    lines.push(todoBlock(route, "  "));
+    if (route.pathParams.length > 0) {
+      for (const param of route.pathParams) {
+        lines.push(`  const ${param} = c.req.param('${param}');`);
+      }
+    }
+    if (route.queryParams && route.queryParams.length > 0) {
+      for (const param of route.queryParams) {
+        lines.push(`  const ${param.name} = c.req.query('${param.name}');`);
+      }
+    }
+    if (route.requestBody && route.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(route.method)) {
+      lines.push(`  const body = await c.req.json();`);
+      const fieldList = route.requestBody.map((f) => f.name).join(", ");
+      lines.push(`  const { ${fieldList} } = body;`);
+    }
+    if (route.responseFormat === "json") {
+      lines.push(`  return c.json({ message: 'Not implemented' });`);
+    } else if (route.responseFormat === "html") {
+      lines.push(`  return c.html('<div>Not implemented</div>');`);
+    } else {
+      lines.push(`  return c.text('Not implemented');`);
+    }
+    lines.push(`  ${USER_END}`);
+    lines.push(`});`);
+    return lines.join("\n");
+  }
+  generateIndex(groups, ts) {
+    const lines = [];
+    lines.push(`// Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT`);
+    lines.push(`import { Hono } from 'hono';`);
+    for (const groupKey of groups.keys()) {
+      const filename = groupKey;
+      lines.push(`import ${toCamelCase2(groupKey)}Routes from './${filename}.js';`);
+    }
+    lines.push("");
+    lines.push("const app = new Hono();");
+    lines.push("");
+    for (const groupKey of groups.keys()) {
+      lines.push(`app.route('/', ${toCamelCase2(groupKey)}Routes);`);
+    }
+    lines.push("");
+    lines.push("export default app;");
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+function toCamelCase2(str) {
+  return str.replace(/-(\w)/g, (_, c) => c.toUpperCase());
+}
+
+// src/generators/openapi-generator.ts
+var OpenAPIGenerator = class {
+  framework = "openapi";
+  generate(routes, options) {
+    const files = [];
+    const warnings = [];
+    if (routes.length === 0) {
+      warnings.push("No routes to generate");
+      return { files, preserved: [], warnings };
+    }
+    const spec = this.buildSpec(routes);
+    const yaml = this.toYaml(spec);
+    files.push({
+      path: "openapi.yaml",
+      content: yaml,
+      isNew: true
+    });
+    return { files, preserved: [], warnings };
+  }
+  buildSpec(routes) {
+    const paths = {};
+    for (const route of routes) {
+      const oaPath = route.path.replace(/:(\w+)/g, "{$1}");
+      const method = route.method.toLowerCase();
+      if (!paths[oaPath]) {
+        paths[oaPath] = {};
+      }
+      paths[oaPath][method] = this.buildOperation(route);
+    }
+    return {
+      openapi: "3.1.0",
+      info: {
+        title: "ServerBridge Generated API",
+        version: "0.1.0",
+        description: "Auto-extracted from hyperscript/htmx attributes"
+      },
+      paths
+    };
+  }
+  buildOperation(route) {
+    const op = {
+      operationId: route.handlerName,
+      summary: `Source: ${route.source.file}${route.source.line ? ":" + route.source.line : ""} (${route.source.kind})`,
+      responses: {
+        "200": this.buildResponse(route)
+      }
+    };
+    if (route.pathParams.length > 0) {
+      op.parameters = route.pathParams.map((name) => ({
+        name,
+        in: "path",
+        required: true,
+        schema: { type: inferParamType(name) }
+      }));
+    }
+    if (route.queryParams && route.queryParams.length > 0) {
+      const queryParamSpecs = route.queryParams.map((param) => ({
+        name: param.name,
+        in: "query",
+        required: param.required,
+        schema: { type: "string" }
+      }));
+      if (op.parameters) {
+        op.parameters.push(...queryParamSpecs);
+      } else {
+        op.parameters = queryParamSpecs;
+      }
+    }
+    if (route.requestBody && route.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(route.method)) {
+      const required = route.requestBody.filter((f) => f.required).map((f) => f.name);
+      const properties = {};
+      for (const field of route.requestBody) {
+        properties[field.name] = fieldToSchema(field.type);
+      }
+      op.requestBody = {
+        required: required.length > 0,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              ...required.length > 0 ? { required } : {},
+              properties
+            }
+          }
+        }
+      };
+    }
+    return op;
+  }
+  buildResponse(route) {
+    const contentType = route.responseFormat === "json" ? "application/json" : route.responseFormat === "html" ? "text/html" : "text/plain";
+    return {
+      description: "Success",
+      content: {
+        [contentType]: {
+          schema: route.responseFormat === "json" ? { type: "object" } : { type: "string" }
+        }
+      }
+    };
+  }
+  /**
+   * Minimal YAML serializer — avoids adding a yaml dependency.
+   * Handles the specific nested structure of OpenAPI specs.
+   */
+  toYaml(obj, indent = 0) {
+    const pad = "  ".repeat(indent);
+    if (obj === null || obj === void 0) {
+      return "null";
+    }
+    if (typeof obj === "string") {
+      if (obj === "" || obj.includes(":") || obj.includes("#") || obj.includes("'") || /^\d/.test(obj) || obj === "true" || obj === "false") {
+        return `'${obj.replace(/'/g, "''")}'`;
+      }
+      return obj;
+    }
+    if (typeof obj === "number" || typeof obj === "boolean") {
+      return String(obj);
+    }
+    if (Array.isArray(obj)) {
+      if (obj.length === 0) return "[]";
+      if (obj.every((item) => typeof item === "string" || typeof item === "number")) {
+        return `[${obj.map((item) => typeof item === "string" ? `'${item}'` : String(item)).join(", ")}]`;
+      }
+      return obj.map((item) => {
+        if (typeof item === "object" && item !== null) {
+          const inner = this.toYaml(item, indent + 1).trimStart();
+          return `${pad}- ${inner}`;
+        }
+        return `${pad}- ${this.toYaml(item)}`;
+      }).join("\n");
+    }
+    if (typeof obj === "object") {
+      const entries = Object.entries(obj);
+      if (entries.length === 0) return "{}";
+      return entries.map(([key, value]) => {
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+          const inner = this.toYaml(value, indent + 1);
+          return `${pad}${key}:
+${inner}`;
+        }
+        if (Array.isArray(value) && value.length > 0 && value.some((v) => typeof v === "object")) {
+          const inner = this.toYaml(value, indent + 1);
+          return `${pad}${key}:
+${inner}`;
+        }
+        return `${pad}${key}: ${this.toYaml(value, indent + 1)}`;
+      }).join("\n");
+    }
+    return String(obj);
+  }
+};
+function inferParamType(name) {
+  if (name === "id" || name.endsWith("Id")) return "string";
+  if (name === "page" || name === "limit" || name === "offset") return "integer";
+  return "string";
+}
+function fieldToSchema(type) {
+  switch (type) {
+    case "number":
+      return { type: "number" };
+    case "boolean":
+      return { type: "boolean" };
+    case "file":
+      return { type: "string", format: "binary" };
+    default:
+      return { type: "string" };
+  }
+}
+
+// src/generators/django-generator.ts
+var PY_ROUTE_MARKER = "# @serverbridge-route:";
+var PY_USER_START = "# @serverbridge-user-start";
+var PY_USER_END = "# @serverbridge-user-end";
+var DjangoGenerator = class {
+  framework = "django";
+  generate(routes, options) {
+    const files = [];
+    const warnings = [];
+    if (routes.length === 0) {
+      warnings.push("No routes to generate");
+      return { files, preserved: [], warnings };
+    }
+    const groups = groupRoutesByPrefix(routes);
+    for (const [groupKey, groupRoutes] of groups) {
+      const views = this.generateViews(groupRoutes, groupKey);
+      files.push({ path: `${groupKey}/views.py`, content: views, isNew: true });
+      const urls = this.generateUrls(groupRoutes, groupKey);
+      files.push({ path: `${groupKey}/urls.py`, content: urls, isNew: true });
+      files.push({ path: `${groupKey}/__init__.py`, content: "", isNew: true });
+    }
+    const rootUrls = this.generateRootUrls(groups);
+    files.push({ path: "urls.py", content: rootUrls, isNew: true });
+    return { files, preserved: [], warnings };
+  }
+  generateViews(routes, groupKey) {
+    const lines = [];
+    lines.push(`# Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT scaffold markers`);
+    lines.push(`from django.http import JsonResponse, HttpResponse`);
+    const needsJson = routes.some(
+      (r) => r.requestBody && r.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(r.method)
+    );
+    if (needsJson) {
+      lines.push(`import json`);
+    }
+    const hasNonGet = routes.some((r) => r.method !== "GET");
+    if (hasNonGet) {
+      lines.push(`from django.views.decorators.http import require_http_methods`);
+    }
+    lines.push("");
+    for (const route of routes) {
+      lines.push("");
+      lines.push(`${PY_ROUTE_MARKER} ${route.method} ${route.path}`);
+      lines.push(this.generateView(route));
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  generateView(route) {
+    const lines = [];
+    const funcName = toSnakeCase(route.handlerName);
+    if (route.method !== "GET") {
+      lines.push(`@require_http_methods(["${route.method}"])`);
+    }
+    const params = ["request", ...route.pathParams];
+    lines.push(`def ${funcName}(${params.join(", ")}):`);
+    lines.push(`    ${PY_USER_START}`);
+    lines.push(`    # TODO: Implement ${route.method} ${route.path}`);
+    if (route.pathParams.length > 0) {
+      lines.push(`    # Path params: ${route.pathParams.join(", ")}`);
+    }
+    if (route.requestBody && route.requestBody.length > 0) {
+      const fields = route.requestBody.map((f) => `${f.name}: ${pythonType(f.type)}${f.required ? "" : " (optional)"}`).join(", ");
+      lines.push(`    # Expected body: { ${fields} }`);
+    }
+    for (const note of route.notes) {
+      lines.push(`    # Note: ${note}`);
+    }
+    if (route.queryParams && route.queryParams.length > 0) {
+      for (const param of route.queryParams) {
+        lines.push(`    ${param.name} = request.GET.get('${param.name}')`);
+      }
+    }
+    if (route.requestBody && route.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(route.method)) {
+      lines.push(`    data = json.loads(request.body)`);
+      for (const field of route.requestBody) {
+        const default_ = field.required ? "" : ", None";
+        lines.push(`    ${field.name} = data.get('${field.name}'${default_})`);
+      }
+    }
+    if (route.responseFormat === "json") {
+      lines.push(`    return JsonResponse({'message': 'Not implemented'})`);
+    } else if (route.responseFormat === "html") {
+      lines.push(`    return HttpResponse('<div>Not implemented</div>')`);
+    } else {
+      lines.push(`    return HttpResponse('Not implemented', content_type='text/plain')`);
+    }
+    lines.push(`    ${PY_USER_END}`);
+    return lines.join("\n");
+  }
+  generateUrls(routes, groupKey) {
+    const lines = [];
+    lines.push(`# Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT`);
+    lines.push(`from django.urls import path`);
+    lines.push(`from . import views`);
+    lines.push("");
+    lines.push("urlpatterns = [");
+    for (const route of routes) {
+      const djangoPath = toDjangoPath(route.path);
+      const funcName = toSnakeCase(route.handlerName);
+      lines.push(`    path('${djangoPath}', views.${funcName}, name='${funcName}'),`);
+    }
+    lines.push("]");
+    lines.push("");
+    return lines.join("\n");
+  }
+  generateRootUrls(groups) {
+    const lines = [];
+    lines.push(`# Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT`);
+    lines.push(`from django.urls import path, include`);
+    lines.push("");
+    lines.push("urlpatterns = [");
+    for (const groupKey of groups.keys()) {
+      lines.push(`    path('', include('${groupKey}.urls')),`);
+    }
+    lines.push("]");
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function toDjangoPath(path) {
+  return path.replace(/^\//, "").replace(/:(\w+)/g, "<str:$1>");
+}
+function pythonType(type) {
+  switch (type) {
+    case "number":
+      return "int";
+    case "boolean":
+      return "bool";
+    case "file":
+      return "UploadedFile";
+    default:
+      return "str";
+  }
+}
+
+// src/generators/fastapi-generator.ts
+var PY_ROUTE_MARKER2 = "# @serverbridge-route:";
+var PY_USER_START2 = "# @serverbridge-user-start";
+var PY_USER_END2 = "# @serverbridge-user-end";
+var FastAPIGenerator = class {
+  framework = "fastapi";
+  generate(routes, options) {
+    const files = [];
+    const warnings = [];
+    if (routes.length === 0) {
+      warnings.push("No routes to generate");
+      return { files, preserved: [], warnings };
+    }
+    const groups = groupRoutesByPrefix(routes);
+    for (const [groupKey, groupRoutes] of groups) {
+      const content = this.generateRouterFile(groupRoutes, groupKey);
+      const pyFilename = groupKey.replace(/-/g, "_");
+      files.push({ path: `routers/${pyFilename}.py`, content, isNew: true });
+    }
+    const mainContent = this.generateMain(groups);
+    files.push({ path: "main.py", content: mainContent, isNew: true });
+    const allRoutes = [...groups.values()].flat();
+    const routesWithBodies = allRoutes.filter(
+      (r) => r.requestBody && r.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(r.method)
+    );
+    if (routesWithBodies.length > 0) {
+      const models = this.generateModels(routesWithBodies);
+      files.push({ path: "models.py", content: models, isNew: true });
+    }
+    return { files, preserved: [], warnings };
+  }
+  generateRouterFile(routes, groupKey) {
+    const lines = [];
+    lines.push(`# Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT scaffold markers`);
+    const needsQuery = routes.some((r) => r.queryParams && r.queryParams.length > 0);
+    if (needsQuery) {
+      lines.push(`from fastapi import APIRouter, Query`);
+    } else {
+      lines.push(`from fastapi import APIRouter`);
+    }
+    const routesWithBodies = routes.filter(
+      (r) => r.requestBody && r.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(r.method)
+    );
+    if (routesWithBodies.length > 0) {
+      const modelNames = routesWithBodies.map((r) => modelName(r.handlerName));
+      lines.push(`from ..models import ${modelNames.join(", ")}`);
+    }
+    const needsHtml = routes.some((r) => r.responseFormat === "html");
+    const needsPlaintext = routes.some((r) => r.responseFormat === "text");
+    if (needsHtml || needsPlaintext) {
+      lines.push(`from fastapi.responses import HTMLResponse, PlainTextResponse`);
+    }
+    lines.push("");
+    lines.push(`router = APIRouter()`);
+    lines.push("");
+    for (const route of routes) {
+      lines.push("");
+      lines.push(`${PY_ROUTE_MARKER2} ${route.method} ${route.path}`);
+      lines.push(this.generateEndpoint(route));
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  generateEndpoint(route) {
+    const lines = [];
+    const method = route.method.toLowerCase();
+    const funcName = toSnakeCase2(route.handlerName);
+    const fastapiPath = toFastAPIPath(route.path);
+    const extraArgs = [];
+    if (route.responseFormat === "html") {
+      extraArgs.push("response_class=HTMLResponse");
+    } else if (route.responseFormat === "text") {
+      extraArgs.push("response_class=PlainTextResponse");
+    }
+    const argsStr = extraArgs.length > 0 ? `, ${extraArgs.join(", ")}` : "";
+    lines.push(`@router.${method}('${fastapiPath}'${argsStr})`);
+    const params = [];
+    for (const param of route.pathParams) {
+      params.push(`${param}: str`);
+    }
+    if (route.queryParams && route.queryParams.length > 0) {
+      for (const qp of route.queryParams) {
+        params.push(`${qp.name}: str = Query(...)`);
+      }
+    }
+    if (route.requestBody && route.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(route.method)) {
+      params.push(`body: ${modelName(route.handlerName)}`);
+    }
+    lines.push(`async def ${funcName}(${params.join(", ")}):`);
+    lines.push(`    ${PY_USER_START2}`);
+    lines.push(`    # TODO: Implement ${route.method} ${route.path}`);
+    if (route.pathParams.length > 0) {
+      lines.push(`    # Path params: ${route.pathParams.join(", ")}`);
+    }
+    if (route.requestBody && route.requestBody.length > 0) {
+      const fields = route.requestBody.map((f) => `${f.name}: ${pythonType2(f.type)}${f.required ? "" : " (optional)"}`).join(", ");
+      lines.push(`    # Expected body: { ${fields} }`);
+    }
+    for (const note of route.notes) {
+      lines.push(`    # Note: ${note}`);
+    }
+    if (route.responseFormat === "json") {
+      lines.push(`    return {'message': 'Not implemented'}`);
+    } else if (route.responseFormat === "html") {
+      lines.push(`    return '<div>Not implemented</div>'`);
+    } else {
+      lines.push(`    return 'Not implemented'`);
+    }
+    lines.push(`    ${PY_USER_END2}`);
+    return lines.join("\n");
+  }
+  generateMain(groups) {
+    const lines = [];
+    lines.push(`# Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT`);
+    lines.push(`from fastapi import FastAPI`);
+    for (const groupKey of groups.keys()) {
+      const pyName = groupKey.replace(/-/g, "_");
+      lines.push(`from .routers.${pyName} import router as ${pyName}_router`);
+    }
+    lines.push("");
+    lines.push("app = FastAPI()");
+    lines.push("");
+    for (const groupKey of groups.keys()) {
+      const pyName = groupKey.replace(/-/g, "_");
+      lines.push(`app.include_router(${pyName}_router)`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  generateModels(routes) {
+    const lines = [];
+    lines.push(`# Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT`);
+    lines.push(`from pydantic import BaseModel`);
+    lines.push(`from typing import Optional`);
+    lines.push("");
+    for (const route of routes) {
+      if (!route.requestBody || route.requestBody.length === 0) continue;
+      lines.push("");
+      lines.push(`class ${modelName(route.handlerName)}(BaseModel):`);
+      for (const field of route.requestBody) {
+        const pyType = pythonType2(field.type);
+        if (field.required) {
+          lines.push(`    ${field.name}: ${pyType}`);
+        } else {
+          lines.push(`    ${field.name}: Optional[${pyType}] = None`);
+        }
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+function toSnakeCase2(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function toFastAPIPath(path) {
+  return path.replace(/:(\w+)/g, "{$1}");
+}
+function modelName(handlerName) {
+  return handlerName.charAt(0).toUpperCase() + handlerName.slice(1) + "Body";
+}
+function pythonType2(type) {
+  switch (type) {
+    case "number":
+      return "int";
+    case "boolean":
+      return "bool";
+    case "file":
+      return "bytes";
+    default:
+      return "str";
+  }
+}
+
+// src/generators/index.ts
+function selectGenerator(framework) {
+  switch (framework) {
+    case "hono":
+      return new HonoGenerator();
+    case "openapi":
+      return new OpenAPIGenerator();
+    case "django":
+      return new DjangoGenerator();
+    case "fastapi":
+      return new FastAPIGenerator();
+    default:
+      return new ExpressGenerator();
+  }
+}
+
+// src/generators/manifest.ts
+var import_promises2 = require("fs/promises");
+var import_node_path = require("path");
+var import_node_crypto = require("crypto");
+var MANIFEST_FILENAME = "server-bridge.manifest.json";
+function hashRoute(route) {
+  const data = JSON.stringify({
+    path: route.path,
+    method: route.method,
+    responseFormat: route.responseFormat,
+    pathParams: route.pathParams,
+    queryParams: route.queryParams,
+    requestBody: route.requestBody
+  });
+  return (0, import_node_crypto.createHash)("md5").update(data).digest("hex").slice(0, 8);
+}
+function manifestKey(method, path) {
+  return `${method}:${path}`;
+}
+function createManifest(routes) {
+  const manifest = {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    routes: {}
+  };
+  for (const route of routes) {
+    const key = manifestKey(route.method, route.path);
+    manifest.routes[key] = {
+      method: route.method,
+      path: route.path,
+      handlerName: route.handlerName,
+      hash: hashRoute(route)
+    };
+  }
+  return manifest;
+}
+async function loadManifest(outputDir) {
+  try {
+    const content = await (0, import_promises2.readFile)((0, import_node_path.join)(outputDir, MANIFEST_FILENAME), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function saveManifest(outputDir, manifest) {
+  await (0, import_promises2.writeFile)(
+    (0, import_node_path.join)(outputDir, MANIFEST_FILENAME),
+    JSON.stringify(manifest, null, 2) + "\n",
+    "utf-8"
+  );
+}
+function diffRoutes(oldManifest, newRoutes) {
+  const oldRoutes = oldManifest?.routes ?? {};
+  const added = [];
+  const changed = [];
+  const unchanged = [];
+  for (const route of newRoutes) {
+    const key = manifestKey(route.method, route.path);
+    const existing = oldRoutes[key];
+    if (!existing) {
+      added.push(route);
+    } else if (existing.hash !== hashRoute(route)) {
+      changed.push(route);
+    } else {
+      unchanged.push(route);
+    }
+  }
+  const newKeys = new Set(newRoutes.map((r) => manifestKey(r.method, r.path)));
+  const removed = Object.values(oldRoutes).filter(
+    (entry) => !newKeys.has(manifestKey(entry.method, entry.path))
+  );
+  return { added, removed, changed, unchanged };
+}
+
+// src/generate.ts
+var import_node_path2 = require("path");
+async function generate(options) {
+  const cwd = (0, import_node_path2.resolve)(options.dir);
+  const outputDir = (0, import_node_path2.resolve)(cwd, options.output ?? "./server/routes");
+  const scan = await scanDirectory(cwd, {
+    include: options.include,
+    exclude: options.exclude,
+    ignore: options.ignore
+  });
+  const generator = selectGenerator(options.framework ?? "express");
+  const generated = generator.generate(scan.routes, {
+    outputDir,
+    typescript: options.typescript
+  });
+  return { scan, generated, routes: scan.routes };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DjangoGenerator,
+  ExpressGenerator,
+  FastAPIGenerator,
+  HonoGenerator,
+  OpenAPIGenerator,
+  createManifest,
+  detectConflicts,
+  diffRoutes,
+  extractFormBodies,
+  extractFormFields,
+  extractHtmxRoutes,
+  extractHyperscriptRoutes,
+  extractPathParams,
+  extractQueryParams,
+  formatConflicts,
+  generate,
+  inferConventions,
+  loadManifest,
+  normalizeUrl,
+  saveManifest,
+  scanDirectory,
+  scanRoutes,
+  selectGenerator,
+  urlToHandlerName
+});
+//# sourceMappingURL=index.cjs.map