flowdoc-gen 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -0,0 +1,1412 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  defineConfig: () => defineConfig,
+  flowdoc: () => flowdoc,
+  generate: () => generate,
+  init: () => init,
+  serve: () => serve
+});
+module.exports = __toCommonJS(src_exports);
+
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@1.21.7_postcss@8.5.15_tsx@4.22.4_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/generate.ts
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var import_url = require("url");
+var import_chalk = __toESM(require("chalk"), 1);
+var import_ora = __toESM(require("ora"), 1);
+
+// ../core/dist/index.js
+var import_fs = require("fs");
+var import_path = require("path");
+var CONFIG_FILES = [
+  "flowdoc.config.ts",
+  "flowdoc.config.js",
+  "flowdoc.config.mjs"
+];
+var findConfigFile = (cwd) => {
+  for (const file of CONFIG_FILES) {
+    const full = (0, import_path.join)(cwd, file);
+    if ((0, import_fs.existsSync)(full)) return full;
+  }
+  return null;
+};
+var loadConfig = async (configPath) => {
+  const resolved = (0, import_path.resolve)(configPath);
+  const mod = await import(resolved);
+  const config = "default" in mod ? mod.default : mod;
+  if (!config) throw new Error(`No config exported from ${configPath}`);
+  return config;
+};
+var resolveConfig = (config, cwd) => ({
+  version: "1.0.0",
+  baseUrl: "http://localhost:3000",
+  ...config,
+  entry: (0, import_path.resolve)(cwd, config.entry),
+  output: (0, import_path.resolve)(cwd, config.output ?? "./docs-output")
+});
+
+// ../parser/dist/index.js
+var import_ts_morph = require("ts-morph");
+var import_glob = require("glob");
+var import_path2 = require("path");
+var import_fs2 = require("fs");
+var import_ts_morph2 = require("ts-morph");
+var import_ts_morph3 = require("ts-morph");
+var import_ts_morph4 = require("ts-morph");
+var import_ts_morph5 = require("ts-morph");
+var zodNodeToJsonSchema = (node) => {
+  if (!import_ts_morph2.Node.isCallExpression(node)) return {};
+  const expr = node.getExpression();
+  const callText = expr.getText();
+  if (callText === "z.string") return buildStringSchema(node);
+  if (callText === "z.number") return buildNumberSchema(node);
+  if (callText === "z.boolean") return { type: "boolean" };
+  if (callText === "z.null") return { type: "null" };
+  if (callText === "z.literal") return buildLiteralSchema(node);
+  if (callText === "z.enum") return buildEnumSchema(node);
+  if (callText === "z.nativeEnum") return { type: "string" };
+  if (callText === "z.object") return buildObjectSchema(node);
+  if (callText === "z.array") return buildArraySchema(node);
+  if (callText === "z.union") return buildUnionSchema(node);
+  if (callText === "z.optional") return buildOptionalSchema(node);
+  if (callText === "z.date") return { type: "string", format: "date-time" };
+  if (callText === "z.any") return {};
+  if (callText === "z.unknown") return {};
+  if (import_ts_morph2.Node.isPropertyAccessExpression(expr)) {
+    return buildChainedSchema(node);
+  }
+  return {};
+};
+var buildStringSchema = (node) => {
+  const schema = { type: "string" };
+  applyChainedValidations(node, schema);
+  return schema;
+};
+var buildNumberSchema = (node) => {
+  const schema = { type: "number" };
+  applyChainedValidations(node, schema);
+  return schema;
+};
+var buildLiteralSchema = (node) => {
+  const arg = node.getArguments()[0];
+  if (!arg) return {};
+  const text = arg.getText().replace(/['"]/g, "");
+  return { type: "string", enum: [text] };
+};
+var buildEnumSchema = (node) => {
+  const arg = node.getArguments()[0];
+  if (!arg || !import_ts_morph2.Node.isArrayLiteralExpression(arg)) return { type: "string" };
+  const values = arg.getElements().map((el) => el.getText().replace(/['"]/g, ""));
+  return { type: "string", enum: values };
+};
+var buildObjectSchema = (node) => {
+  const arg = node.getArguments()[0];
+  if (!arg || !import_ts_morph2.Node.isObjectLiteralExpression(arg)) return { type: "object" };
+  const properties = {};
+  const required = [];
+  for (const prop of arg.getProperties()) {
+    if (!import_ts_morph2.Node.isPropertyAssignment(prop)) continue;
+    const name = prop.getName();
+    const init2 = prop.getInitializer();
+    if (!init2) continue;
+    const childSchema = zodNodeToJsonSchema(init2);
+    properties[name] = childSchema;
+    if (!isOptionalZodExpr(init2)) {
+      required.push(name);
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+};
+var buildArraySchema = (node) => {
+  const arg = node.getArguments()[0];
+  if (!arg) return { type: "array" };
+  return { type: "array", items: zodNodeToJsonSchema(arg) };
+};
+var buildUnionSchema = (node) => {
+  const arg = node.getArguments()[0];
+  if (!arg || !import_ts_morph2.Node.isArrayLiteralExpression(arg)) return {};
+  const schemas = arg.getElements().map((el) => zodNodeToJsonSchema(el));
+  return { anyOf: schemas };
+};
+var buildOptionalSchema = (node) => {
+  const arg = node.getArguments()[0];
+  if (!arg) return {};
+  return zodNodeToJsonSchema(arg);
+};
+var buildChainedSchema = (node) => {
+  const chain = unwrapChain(node);
+  if (!chain.root) return {};
+  const base = zodNodeToJsonSchema(chain.root);
+  applyChainedCallsToSchema(chain.methods, base);
+  return base;
+};
+var unwrapChain = (node) => {
+  const methods = [];
+  let current = node;
+  while (import_ts_morph2.Node.isCallExpression(current)) {
+    const expr = current.getExpression();
+    if (import_ts_morph2.Node.isPropertyAccessExpression(expr)) {
+      const obj = expr.getExpression();
+      if (import_ts_morph2.Node.isIdentifier(obj)) {
+        return { root: current, methods };
+      }
+      const methodName = expr.getName();
+      const args = current.getArguments();
+      methods.unshift({ name: methodName, args });
+      current = obj;
+    } else {
+      return { root: current, methods };
+    }
+  }
+  return { root: null, methods };
+};
+var applyChainedValidations = (node, schema) => {
+  const chain = unwrapChain(node);
+  applyChainedCallsToSchema(chain.methods, schema);
+};
+var applyChainedCallsToSchema = (methods, schema) => {
+  for (const { name, args } of methods) {
+    switch (name) {
+      case "email":
+        schema.format = "email";
+        break;
+      case "url":
+        schema.format = "uri";
+        break;
+      case "uuid":
+        schema.format = "uuid";
+        break;
+      case "datetime":
+        schema.format = "date-time";
+        break;
+      case "min": {
+        const val = getNumericArg(args[0]);
+        if (val !== null) {
+          if (schema.type === "string") schema.minLength = val;
+          else schema.minimum = val;
+        }
+        break;
+      }
+      case "max": {
+        const val = getNumericArg(args[0]);
+        if (val !== null) {
+          if (schema.type === "string") schema.maxLength = val;
+          else schema.maximum = val;
+        }
+        break;
+      }
+      case "describe": {
+        const desc = getStringArg(args[0]);
+        if (desc) schema.description = desc;
+        break;
+      }
+      case "default": {
+        const arg = args[0];
+        if (arg) schema.default = tryParseValue(arg.getText());
+        break;
+      }
+      case "optional":
+      case "nullish":
+        schema.nullable = true;
+        break;
+      case "positive":
+        schema.minimum = 0;
+        break;
+      case "negative":
+        schema.maximum = 0;
+        break;
+      case "int":
+        schema.type = "integer";
+        break;
+      case "regex": {
+        const pattern = args[0]?.getText();
+        if (pattern) schema.pattern = pattern.replace(/^\/|\/[gimsuy]*$/g, "");
+        break;
+      }
+    }
+  }
+};
+var isOptionalZodExpr = (node) => {
+  const text = node.getText();
+  return text.includes(".optional()") || text.includes(".nullish()") || text.startsWith("z.optional(");
+};
+var getNumericArg = (node) => {
+  if (!node) return null;
+  const val = Number(node.getText());
+  return isNaN(val) ? null : val;
+};
+var getStringArg = (node) => {
+  if (!node) return null;
+  const text = node.getText();
+  const match = text.match(/^['"`](.*?)['"`]$/s);
+  return match?.[1] ?? null;
+};
+var tryParseValue = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text.replace(/['"]/g, "");
+  }
+};
+var extractZodSchemas = (sourceFile) => {
+  const schemas = {};
+  const varDeclarations = sourceFile.getVariableDeclarations();
+  for (const decl of varDeclarations) {
+    const init2 = decl.getInitializer();
+    if (!init2) continue;
+    const text = init2.getText();
+    if (!text.startsWith("z.")) continue;
+    const name = decl.getName();
+    try {
+      schemas[name] = zodNodeToJsonSchema(init2);
+    } catch {
+    }
+  }
+  return schemas;
+};
+var YUP_ROOT_METHODS = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "array",
+  "date",
+  "mixed",
+  "ref",
+  "lazy"
+]);
+var yupNodeToJsonSchema = (node) => {
+  if (!import_ts_morph3.Node.isCallExpression(node)) return {};
+  const chain = unwrapYupChain(node);
+  if (!chain.root) return {};
+  const base = buildYupBase(chain.rootMethod);
+  applyYupChain(chain.methods, base);
+  return base;
+};
+var unwrapYupChain = (node) => {
+  const methods = [];
+  let current = node;
+  while (import_ts_morph3.Node.isCallExpression(current)) {
+    const expr = current.getExpression();
+    if (!import_ts_morph3.Node.isPropertyAccessExpression(expr)) {
+      if (import_ts_morph3.Node.isIdentifier(expr) && YUP_ROOT_METHODS.has(expr.getText())) {
+        return { root: current, rootMethod: expr.getText(), methods };
+      }
+      return { root: null, rootMethod: "", methods };
+    }
+    const obj = expr.getExpression();
+    const methodName = expr.getName();
+    if (import_ts_morph3.Node.isIdentifier(obj) && obj.getText() === "yup" && YUP_ROOT_METHODS.has(methodName)) {
+      return { root: current, rootMethod: methodName, methods };
+    }
+    methods.unshift({ name: methodName, args: current.getArguments() });
+    current = obj;
+  }
+  return { root: null, rootMethod: "", methods };
+};
+var buildYupBase = (method) => {
+  switch (method) {
+    case "string":
+      return { type: "string" };
+    case "number":
+      return { type: "number" };
+    case "boolean":
+      return { type: "boolean" };
+    case "date":
+      return { type: "string", format: "date-time" };
+    case "array":
+      return { type: "array" };
+    case "object":
+      return { type: "object" };
+    default:
+      return {};
+  }
+};
+var applyYupChain = (methods, schema) => {
+  let required = false;
+  for (const { name, args } of methods) {
+    switch (name) {
+      case "required":
+        required = true;
+        break;
+      case "optional":
+      case "nullable":
+        schema.nullable = true;
+        break;
+      case "email":
+        schema.format = "email";
+        break;
+      case "url":
+        schema.format = "uri";
+        break;
+      case "uuid":
+        schema.format = "uuid";
+        break;
+      case "min": {
+        const v = getNum(args[0]);
+        if (v !== null) {
+          if (schema.type === "string") schema.minLength = v;
+          else if (schema.type === "array") schema.minItems = v;
+          else schema.minimum = v;
+        }
+        break;
+      }
+      case "max": {
+        const v = getNum(args[0]);
+        if (v !== null) {
+          if (schema.type === "string") schema.maxLength = v;
+          else if (schema.type === "array") schema.maxItems = v;
+          else schema.maximum = v;
+        }
+        break;
+      }
+      case "length": {
+        const v = getNum(args[0]);
+        if (v !== null && schema.type === "string") {
+          schema.minLength = v;
+          schema.maxLength = v;
+        }
+        break;
+      }
+      case "integer":
+        schema.type = "integer";
+        break;
+      case "positive":
+        schema.minimum = 0;
+        break;
+      case "negative":
+        schema.maximum = 0;
+        break;
+      case "oneOf": {
+        const arg = args[0];
+        if (arg && import_ts_morph3.Node.isArrayLiteralExpression(arg)) {
+          schema.enum = arg.getElements().map((el) => el.getText().replace(/['"]/g, ""));
+        }
+        break;
+      }
+      case "shape": {
+        const arg = args[0];
+        if (arg && import_ts_morph3.Node.isObjectLiteralExpression(arg)) {
+          const { properties, required: req } = parseYupShape(arg);
+          schema.type = "object";
+          schema.properties = properties;
+          if (req.length > 0) schema.required = req;
+        }
+        break;
+      }
+      case "of": {
+        const arg = args[0];
+        if (arg) schema.items = yupNodeToJsonSchema(arg);
+        break;
+      }
+      case "label": {
+        const s = getStr(args[0]);
+        if (s) schema.title = s;
+        break;
+      }
+      case "meta": {
+        const arg = args[0];
+        if (arg && import_ts_morph3.Node.isObjectLiteralExpression(arg)) {
+          for (const prop of arg.getProperties()) {
+            if (import_ts_morph3.Node.isPropertyAssignment(prop) && prop.getName() === "description") {
+              const s = getStr(prop.getInitializer());
+              if (s) schema.description = s;
+            }
+          }
+        }
+        break;
+      }
+      case "default": {
+        const arg = args[0];
+        if (arg) schema.default = tryParse(arg.getText());
+        break;
+      }
+    }
+  }
+  if (required) schema.__required = true;
+};
+var parseYupShape = (arg) => {
+  const properties = {};
+  const required = [];
+  if (!arg || !import_ts_morph3.Node.isObjectLiteralExpression(arg)) return { properties, required };
+  for (const prop of arg.getProperties()) {
+    if (!import_ts_morph3.Node.isPropertyAssignment(prop)) continue;
+    const name = prop.getName();
+    const init2 = prop.getInitializer();
+    if (!init2) continue;
+    const childSchema = yupNodeToJsonSchema(init2);
+    const isReq = childSchema.__required === true;
+    delete childSchema.__required;
+    properties[name] = childSchema;
+    if (isReq) required.push(name);
+  }
+  return { properties, required };
+};
+var getNum = (node) => {
+  if (!node) return null;
+  const v = Number(node.getText());
+  return isNaN(v) ? null : v;
+};
+var getStr = (node) => {
+  if (!node) return null;
+  const m = node.getText().match(/^['"`](.*?)['"`]$/s);
+  return m?.[1] ?? null;
+};
+var tryParse = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text.replace(/['"]/g, "");
+  }
+};
+var isYupExpr = (text) => /^yup\.(?:string|number|boolean|object|array|date|mixed)\s*\(/.test(text) || /^(?:string|number|boolean|object|array|date|mixed)\s*\(\s*\)/.test(text);
+var extractYupSchemas = (sourceFile) => {
+  const schemas = {};
+  for (const decl of sourceFile.getVariableDeclarations()) {
+    const init2 = decl.getInitializer();
+    if (!init2) continue;
+    const text = init2.getText();
+    if (!isYupExpr(text)) continue;
+    try {
+      const schema = yupNodeToJsonSchema(init2);
+      if (Object.keys(schema).length > 0) schemas[decl.getName()] = schema;
+    } catch {
+    }
+  }
+  return schemas;
+};
+var JOI_PRIMITIVES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "array",
+  "date",
+  "binary",
+  "any",
+  "alternatives",
+  "link"
+]);
+var joiNodeToJsonSchema = (node, joiId = "Joi") => {
+  if (!import_ts_morph4.Node.isCallExpression(node)) return {};
+  const chain = unwrapJoiChain(node, joiId);
+  if (!chain.root) return {};
+  const base = buildJoiBase(chain.rootMethod);
+  applyJoiChain(chain.methods, base, joiId);
+  return base;
+};
+var unwrapJoiChain = (node, joiId) => {
+  const methods = [];
+  let current = node;
+  while (import_ts_morph4.Node.isCallExpression(current)) {
+    const expr = current.getExpression();
+    if (!import_ts_morph4.Node.isPropertyAccessExpression(expr)) {
+      return { root: null, rootMethod: "", methods };
+    }
+    const obj = expr.getExpression();
+    const methodName = expr.getName();
+    if (import_ts_morph4.Node.isIdentifier(obj) && obj.getText() === joiId && JOI_PRIMITIVES.has(methodName)) {
+      return { root: current, rootMethod: methodName, methods };
+    }
+    methods.unshift({ name: methodName, args: current.getArguments() });
+    current = obj;
+  }
+  return { root: null, rootMethod: "", methods };
+};
+var buildJoiBase = (method) => {
+  switch (method) {
+    case "string":
+      return { type: "string" };
+    case "number":
+      return { type: "number" };
+    case "boolean":
+      return { type: "boolean" };
+    case "date":
+      return { type: "string", format: "date-time" };
+    case "binary":
+      return { type: "string", format: "binary" };
+    case "array":
+      return { type: "array" };
+    case "object":
+      return { type: "object" };
+    default:
+      return {};
+  }
+};
+var applyJoiChain = (methods, schema, joiId) => {
+  for (const { name, args } of methods) {
+    switch (name) {
+      case "required":
+        schema.__required = true;
+        break;
+      case "optional":
+      case "allow":
+        schema.nullable = true;
+        break;
+      case "email":
+        schema.format = "email";
+        break;
+      case "uri":
+        schema.format = "uri";
+        break;
+      case "guid":
+      case "uuid":
+        schema.format = "uuid";
+        break;
+      case "isoDate":
+        schema.format = "date-time";
+        break;
+      case "min": {
+        const v = getNum2(args[0]);
+        if (v !== null) {
+          if (schema.type === "string") schema.minLength = v;
+          else if (schema.type === "array") schema.minItems = v;
+          else schema.minimum = v;
+        }
+        break;
+      }
+      case "max": {
+        const v = getNum2(args[0]);
+        if (v !== null) {
+          if (schema.type === "string") schema.maxLength = v;
+          else if (schema.type === "array") schema.maxItems = v;
+          else schema.maximum = v;
+        }
+        break;
+      }
+      case "length": {
+        const v = getNum2(args[0]);
+        if (v !== null && schema.type === "string") {
+          schema.minLength = v;
+          schema.maxLength = v;
+        }
+        break;
+      }
+      case "integer":
+        schema.type = "integer";
+        break;
+      case "positive":
+        schema.minimum = 0;
+        break;
+      case "negative":
+        schema.maximum = 0;
+        break;
+      case "valid": {
+        const vals = args.map((a) => a.getText().replace(/['"]/g, "")).filter((v) => !v.includes(".override"));
+        if (vals.length > 0) schema.enum = vals;
+        break;
+      }
+      case "items": {
+        const arg = args[0];
+        if (arg) schema.items = joiNodeToJsonSchema(arg, joiId);
+        break;
+      }
+      case "keys": {
+        const arg = args[0];
+        if (arg && import_ts_morph4.Node.isObjectLiteralExpression(arg)) {
+          const { properties, required } = parseJoiKeys(arg, joiId);
+          schema.type = "object";
+          schema.properties = properties;
+          if (required.length > 0) schema.required = required;
+        }
+        break;
+      }
+      case "description": {
+        const s = getStr2(args[0]);
+        if (s) schema.description = s;
+        break;
+      }
+      case "label": {
+        const s = getStr2(args[0]);
+        if (s) schema.title = s;
+        break;
+      }
+      case "default": {
+        const arg = args[0];
+        if (arg) schema.default = tryParse2(arg.getText());
+        break;
+      }
+      case "pattern": {
+        const arg = args[0];
+        if (arg) schema.pattern = arg.getText().replace(/^\/|\/[gimsuy]*$/g, "");
+        break;
+      }
+    }
+  }
+};
+var parseJoiKeys = (arg, joiId) => {
+  const properties = {};
+  const required = [];
+  if (!arg || !import_ts_morph4.Node.isObjectLiteralExpression(arg)) return { properties, required };
+  for (const prop of arg.getProperties()) {
+    if (!import_ts_morph4.Node.isPropertyAssignment(prop)) continue;
+    const name = prop.getName();
+    const init2 = prop.getInitializer();
+    if (!init2) continue;
+    const childSchema = joiNodeToJsonSchema(init2, joiId);
+    const isReq = childSchema.__required === true;
+    delete childSchema.__required;
+    properties[name] = childSchema;
+    if (isReq) required.push(name);
+  }
+  return { properties, required };
+};
+var getNum2 = (node) => {
+  if (!node) return null;
+  const v = Number(node.getText());
+  return isNaN(v) ? null : v;
+};
+var getStr2 = (node) => {
+  if (!node) return null;
+  const m = node.getText().match(/^['"`](.*?)['"`]$/s);
+  return m?.[1] ?? null;
+};
+var tryParse2 = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text.replace(/['"]/g, "");
+  }
+};
+var detectJoiId = (sourceFile) => {
+  for (const decl of sourceFile.getImportDeclarations()) {
+    const mod = decl.getModuleSpecifierValue();
+    if (mod !== "joi" && mod !== "@hapi/joi") continue;
+    const def = decl.getDefaultImport() ?? decl.getNamespaceImport();
+    if (def) return def.getText();
+  }
+  return null;
+};
+var isJoiExpr = (text, joiId) => new RegExp(`^${joiId}\\.(?:${[...JOI_PRIMITIVES].join("|")})\\s*\\(`).test(text);
+var extractJoiSchemas = (sourceFile) => {
+  const schemas = {};
+  const joiId = detectJoiId(sourceFile);
+  if (!joiId) return schemas;
+  for (const decl of sourceFile.getVariableDeclarations()) {
+    const init2 = decl.getInitializer();
+    if (!init2) continue;
+    if (!isJoiExpr(init2.getText(), joiId)) continue;
+    try {
+      const schema = joiNodeToJsonSchema(init2, joiId);
+      if (Object.keys(schema).length > 0) schemas[decl.getName()] = schema;
+    } catch {
+    }
+  }
+  return schemas;
+};
+var DECORATOR_MAP = {
+  IsString: { type: "string" },
+  IsNumber: { type: "number" },
+  IsInt: { type: "integer" },
+  IsBoolean: { type: "boolean" },
+  IsDate: { type: "string", format: "date-time" },
+  IsDateString: { type: "string", format: "date-time" },
+  IsEmail: { type: "string", format: "email" },
+  IsUrl: { type: "string", format: "uri" },
+  IsUUID: { type: "string", format: "uuid" },
+  IsArray: { type: "array" },
+  IsObject: { type: "object" },
+  IsHexColor: { type: "string", pattern: "^#[0-9A-Fa-f]{6}$" },
+  IsIP: { type: "string", format: "ipv4" },
+  IsJWT: { type: "string", format: "jwt" },
+  IsPhoneNumber: { type: "string" },
+  IsPostalCode: { type: "string" }
+};
+var CONSTRAINED = {
+  MinLength: (s, v) => {
+    s.type = s.type ?? "string";
+    s.minLength = Number(v);
+  },
+  MaxLength: (s, v) => {
+    s.type = s.type ?? "string";
+    s.maxLength = Number(v);
+  },
+  Min: (s, v) => {
+    s.minimum = Number(v);
+  },
+  Max: (s, v) => {
+    s.maximum = Number(v);
+  },
+  ArrayMinSize: (s, v) => {
+    s.minItems = Number(v);
+  },
+  ArrayMaxSize: (s, v) => {
+    s.maxItems = Number(v);
+  },
+  Length: (s, v) => {
+    s.minLength = Number(v);
+    s.maxLength = Number(v);
+  },
+  Matches: (s, v) => {
+    const pat = String(v).replace(/^\/|\/[gimsuy]*$/g, "");
+    s.pattern = pat;
+  },
+  IsIn: (s, v) => {
+    if (Array.isArray(v)) s.enum = v.map(String);
+  },
+  IsEnum: (s, _v) => {
+    s.type = s.type ?? "string";
+  }
+};
+var OPTIONAL_DECORATORS = /* @__PURE__ */ new Set(["IsOptional"]);
+var extractClassValidatorSchemas = (sourceFile) => {
+  const schemas = {};
+  const hasClassValidator = sourceFile.getImportDeclarations().some((d) => {
+    const mod = d.getModuleSpecifierValue();
+    return mod === "class-validator" || mod.includes("class-validator");
+  });
+  if (!hasClassValidator) return schemas;
+  for (const cls of sourceFile.getClasses()) {
+    const className = cls.getName();
+    if (!className) continue;
+    const properties = {};
+    const required = [];
+    for (const prop of cls.getProperties()) {
+      const decorators = prop.getDecorators();
+      if (decorators.length === 0) continue;
+      const propSchema = {};
+      let isOptional = false;
+      for (const decorator of decorators) {
+        const name = decorator.getName();
+        if (DECORATOR_MAP[name]) {
+          Object.assign(propSchema, DECORATOR_MAP[name]);
+          continue;
+        }
+        if (CONSTRAINED[name]) {
+          const call = decorator.getCallExpression();
+          const firstArg = call?.getArguments()[0];
+          if (firstArg) {
+            const raw = firstArg.getText();
+            if (import_ts_morph5.Node.isArrayLiteralExpression(firstArg)) {
+              const values = firstArg.getElements().map((el) => el.getText().replace(/['"]/g, ""));
+              CONSTRAINED[name](propSchema, values);
+            } else {
+              const num = Number(raw);
+              CONSTRAINED[name](propSchema, isNaN(num) ? raw.replace(/['"]/g, "") : num);
+            }
+          }
+          continue;
+        }
+        if (OPTIONAL_DECORATORS.has(name)) {
+          isOptional = true;
+          continue;
+        }
+        if (name === "ValidateNested") {
+          propSchema.type = "object";
+          continue;
+        }
+      }
+      if (!propSchema.type) {
+        const typeNode = prop.getTypeNode();
+        if (typeNode) {
+          const typeText = typeNode.getText();
+          if (typeText === "string") propSchema.type = "string";
+          else if (typeText === "number") propSchema.type = "number";
+          else if (typeText === "boolean") propSchema.type = "boolean";
+          else if (typeText.endsWith("[]")) propSchema.type = "array";
+        }
+      }
+      if (Object.keys(propSchema).length === 0) continue;
+      const propName = prop.getName();
+      properties[propName] = propSchema;
+      if (!isOptional) required.push(propName);
+    }
+    if (Object.keys(properties).length === 0) continue;
+    schemas[className] = {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {}
+    };
+  }
+  return schemas;
+};
+var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+var findTsConfig = (startDir) => {
+  let dir = startDir;
+  for (let i = 0; i < 5; i++) {
+    const candidate = (0, import_path2.join)(dir, "tsconfig.json");
+    if ((0, import_fs2.existsSync)(candidate)) return candidate;
+    const parent = (0, import_path2.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+};
+var extractExpressRoutes = async (config) => {
+  const cwd = (0, import_fs2.existsSync)(config.entry) && !config.entry.endsWith(".ts") && !config.entry.endsWith(".js") ? config.entry : (0, import_path2.dirname)(config.entry);
+  const tsConfigPath = findTsConfig(cwd);
+  const project = tsConfigPath ? new import_ts_morph.Project({ tsConfigFilePath: tsConfigPath, skipAddingFilesFromTsConfig: true }) : new import_ts_morph.Project({ compilerOptions: { allowJs: true, strict: false } });
+  const patterns = ["**/*.ts", "**/*.js"].map((p) => (0, import_path2.resolve)(cwd, "**", p));
+  const files = await (0, import_glob.glob)(`${cwd}/**/*.{ts,js}`, {
+    ignore: ["**/node_modules/**", "**/dist/**", "**/*.d.ts", "**/*.spec.*", "**/*.test.*"]
+  });
+  for (const file of files) {
+    project.addSourceFileAtPath(file);
+  }
+  const globalSchemas = {};
+  for (const sourceFile of project.getSourceFiles()) {
+    Object.assign(globalSchemas, extractZodSchemas(sourceFile));
+    Object.assign(globalSchemas, extractYupSchemas(sourceFile));
+    Object.assign(globalSchemas, extractJoiSchemas(sourceFile));
+    Object.assign(globalSchemas, extractClassValidatorSchemas(sourceFile));
+  }
+  const allRoutes = [];
+  for (const sourceFile of project.getSourceFiles()) {
+    const ctx = { zodSchemas: globalSchemas, routerPrefix: "" };
+    const routes = extractRoutesFromFile(sourceFile, ctx);
+    allRoutes.push(...routes);
+  }
+  return deduplicateRoutes(allRoutes);
+};
+var extractRoutesFromFile = (sourceFile, ctx) => {
+  const routes = [];
+  const callExpressions = sourceFile.getDescendantsOfKind(import_ts_morph.SyntaxKind.CallExpression);
+  for (const call of callExpressions) {
+    const route = tryExtractRoute(call, ctx);
+    if (route) routes.push(route);
+  }
+  return routes;
+};
+var tryExtractRoute = (call, ctx) => {
+  const expr = call.getExpression();
+  if (!import_ts_morph.Node.isPropertyAccessExpression(expr)) return null;
+  const methodName = expr.getName().toUpperCase();
+  if (!HTTP_METHODS.includes(methodName)) return null;
+  const args = call.getArguments();
+  if (args.length < 2) return null;
+  const firstArg = args[0];
+  if (!firstArg) return null;
+  if (!import_ts_morph.Node.isStringLiteral(firstArg) && !import_ts_morph.Node.isTemplateExpression(firstArg) && !import_ts_morph.Node.isNoSubstitutionTemplateLiteral(firstArg)) {
+    return null;
+  }
+  const rawPath = firstArg.getText().replace(/['"'`]/g, "");
+  const path = normalizePath(ctx.routerPrefix, rawPath);
+  const method = methodName;
+  const middlewareArgs = args.slice(1, -1);
+  const handlerArg = args[args.length - 1];
+  const { requestBody, parameters } = extractFromMiddleware(middlewareArgs, ctx);
+  const pathParams = extractPathParameters(path);
+  const handlerInfo = extractHandlerInfo(handlerArg);
+  const allParameters = mergeParameters(parameters, pathParams);
+  const tags = inferTags(path);
+  const route = {
+    method,
+    path,
+    tags,
+    parameters: allParameters,
+    responses: buildDefaultResponses(method),
+    middleware: middlewareArgs.map((m) => m.getText())
+  };
+  if (handlerInfo.summary !== void 0) route.summary = handlerInfo.summary;
+  if (handlerInfo.description !== void 0) route.description = handlerInfo.description;
+  if (requestBody !== null) route.requestBody = requestBody;
+  return route;
+};
+var extractFromMiddleware = (middleware, ctx) => {
+  let requestBody = null;
+  const parameters = [];
+  for (const mw of middleware) {
+    const text = mw.getText();
+    const bodyMatch = text.match(/(?:validateBody|validate|zodValidate|joiValidate|validateDto|bodyValidator|checkBody|schemaValidator)\((\w+)\)/) ?? text.match(/celebrate\s*\(\s*\{\s*body\s*:\s*(\w+)/);
+    if (bodyMatch) {
+      const schemaName = bodyMatch[1];
+      const schema = schemaName ? ctx.zodSchemas[schemaName] : null;
+      if (schema) {
+        requestBody = {
+          required: true,
+          content: { "application/json": { schema } }
+        };
+      }
+    }
+    const queryMatch = text.match(/(?:validateQuery|queryValidator|checkQuery)\((\w+)\)/);
+    if (queryMatch) {
+      const schemaName = queryMatch[1];
+      const schema = schemaName ? ctx.zodSchemas[schemaName] : null;
+      if (schema?.type === "object" && schema.properties) {
+        for (const [name, propSchema] of Object.entries(schema.properties)) {
+          parameters.push({
+            name,
+            in: "query",
+            required: schema.required?.includes(name) ?? false,
+            schema: propSchema
+          });
+        }
+      }
+    }
+  }
+  return { requestBody, parameters };
+};
+var extractPathParameters = (path) => {
+  const paramRegex = /:(\w+)/g;
+  const params = [];
+  let match;
+  while ((match = paramRegex.exec(path)) !== null) {
+    const name = match[1];
+    if (name) {
+      params.push({
+        name,
+        in: "path",
+        required: true,
+        schema: { type: "string" }
+      });
+    }
+  }
+  return params;
+};
+var extractHandlerInfo = (handler) => {
+  const leadingComments = handler.getLeadingCommentRanges();
+  if (leadingComments.length === 0) return {};
+  const comment = leadingComments[leadingComments.length - 1];
+  if (!comment) return {};
+  const text = comment.getText();
+  const summary = extractJsDocTag(text, null);
+  const description = extractJsDocTag(text, "description");
+  const result = {};
+  if (summary !== null) result.summary = summary;
+  if (description !== null) result.description = description;
+  return result;
+};
+var extractJsDocTag = (comment, tag) => {
+  if (tag === null) {
+    const match2 = comment.match(/\/\*\*\s*\n?\s*\*\s*(.+)/);
+    return match2?.[1]?.trim() ?? null;
+  }
+  const match = comment.match(new RegExp(`@${tag}\\s+(.+)`));
+  return match?.[1]?.trim() ?? null;
+};
+var mergeParameters = (fromMiddleware, fromPath) => {
+  const existing = new Set(fromMiddleware.map((p) => `${p.in}:${p.name}`));
+  const merged = [...fromMiddleware];
+  for (const param of fromPath) {
+    if (!existing.has(`${param.in}:${param.name}`)) {
+      merged.push(param);
+    }
+  }
+  return merged;
+};
+var normalizePath = (prefix, path) => {
+  const combined = `${prefix}${path}`.replace(/\/+/g, "/");
+  return combined.startsWith("/") ? combined : `/${combined}`;
+};
+var inferTags = (path) => {
+  const segments = path.split("/").filter(Boolean);
+  const tag = segments.find((s) => !s.startsWith(":"));
+  return tag ? [tag] : ["default"];
+};
+var buildDefaultResponses = (method) => {
+  const responses = {
+    "200": { description: method === "DELETE" ? "Success" : "Successful response" },
+    "400": { description: "Bad request" },
+    "401": { description: "Unauthorized" },
+    "500": { description: "Internal server error" }
+  };
+  if (method === "POST") {
+    responses["201"] = { description: "Created" };
+  }
+  if (method === "DELETE") {
+    responses["204"] = { description: "No content" };
+  }
+  return responses;
+};
+var deduplicateRoutes = (routes) => {
+  const seen = /* @__PURE__ */ new Set();
+  return routes.filter((r) => {
+    const key = `${r.method}:${r.path}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+};
+var buildSpec = (routes, config) => {
+  const groups = groupRoutes(routes, config.groups);
+  return {
+    info: {
+      title: config.name,
+      version: config.version ?? "1.0.0",
+      baseUrl: config.baseUrl ?? "http://localhost:3000",
+      ...config.description !== void 0 ? { description: config.description } : {}
+    },
+    ...config.auth !== void 0 ? { auth: config.auth } : {},
+    groups,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceFramework: config.framework
+  };
+};
+var groupRoutes = (routes, groupConfig) => {
+  if (!groupConfig) {
+    return groupByTag(routes);
+  }
+  const groups = [];
+  const assignedRoutes = /* @__PURE__ */ new Set();
+  for (const [groupName, patterns] of Object.entries(groupConfig)) {
+    const matched = routes.filter((r) => {
+      const key = `${r.method}:${r.path}`;
+      if (assignedRoutes.has(key)) return false;
+      const matches = patterns.some((pattern) => matchesGlob(r.path, pattern));
+      if (matches) assignedRoutes.add(key);
+      return matches;
+    });
+    if (matched.length > 0) {
+      groups.push({ name: groupName, routes: matched });
+    }
+  }
+  const unassigned = routes.filter(
+    (r) => !assignedRoutes.has(`${r.method}:${r.path}`)
+  );
+  if (unassigned.length > 0) {
+    groups.push({ name: "Other", routes: unassigned });
+  }
+  return groups;
+};
+var groupByTag = (routes) => {
+  const tagMap = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const tag = route.tags[0] ?? "default";
+    if (!tagMap.has(tag)) tagMap.set(tag, []);
+    tagMap.get(tag).push(route);
+  }
+  return Array.from(tagMap.entries()).map(([name, groupRoutes2]) => ({
+    name: capitalize(name),
+    routes: groupRoutes2
+  }));
+};
+var matchesGlob = (path, pattern) => {
+  const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\/\*\*$/, "(/.*)?").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+  return new RegExp(`^${regexStr}$`).test(path);
+};
+var capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+
+// src/generate.ts
+var generate = async (opts = {}) => {
+  const cwd = process.cwd();
+  const spinner = opts.quiet ? null : (0, import_ora.default)();
+  spinner?.start("Loading flowdoc config...");
+  const configPath = opts.config ? (0, import_path3.resolve)(cwd, opts.config) : findConfigFile(cwd);
+  if (!configPath) {
+    spinner?.fail(import_chalk.default.red("No flowdoc.config.ts found. Run `flowdoc init` first."));
+    process.exit(1);
+  }
+  let rawConfig;
+  try {
+    rawConfig = await loadConfig(configPath);
+  } catch (err) {
+    spinner?.fail(import_chalk.default.red(`Failed to load config: ${String(err)}`));
+    process.exit(1);
+  }
+  const config = resolveConfig(rawConfig, cwd);
+  spinner?.succeed(`Config loaded \u2014 ${import_chalk.default.cyan(config.name)}`);
+  spinner?.start(`Scanning ${import_chalk.default.cyan(config.entry)} for routes...`);
+  let routes;
+  try {
+    routes = await extractExpressRoutes(config);
+  } catch (err) {
+    spinner?.fail(import_chalk.default.red(`Parse failed: ${String(err)}`));
+    process.exit(1);
+  }
+  spinner?.succeed(
+    `Found ${import_chalk.default.green(String(routes.length))} routes across ${import_chalk.default.cyan(config.framework)} app`
+  );
+  const spec = buildSpec(routes, config);
+  const outputDir = opts.output ? (0, import_path3.resolve)(cwd, opts.output) : config.output ?? (0, import_path3.resolve)(cwd, "docs-output");
+  (0, import_fs3.mkdirSync)(outputDir, { recursive: true });
+  const specPath = (0, import_path3.join)(outputDir, "flowdoc.json");
+  (0, import_fs3.writeFileSync)(specPath, JSON.stringify(spec, null, 2), "utf-8");
+  await writeUiHtml(outputDir, config);
+  if (!opts.quiet) {
+    console.log();
+    console.log(import_chalk.default.bold("  flowdoc generated successfully"));
+    console.log();
+    console.log(`  ${import_chalk.default.gray("Spec:")}   ${import_chalk.default.cyan(specPath)}`);
+    console.log(`  ${import_chalk.default.gray("UI:")}     ${import_chalk.default.cyan((0, import_path3.join)(outputDir, "index.html"))}`);
+    console.log();
+    console.log(`  ${import_chalk.default.gray("Routes:")} ${import_chalk.default.green(String(routes.length))}`);
+    console.log(`  ${import_chalk.default.gray("Groups:")} ${import_chalk.default.green(String(spec.groups.length))}`);
+    console.log();
+  }
+  return spec;
+};
+var writeUiHtml = async (outputDir, config) => {
+  const brand = config.theme?.brand ?? "#6366f1";
+  const title = config.name;
+  const darkMode = config.theme?.darkMode !== false;
+  const cliRoot = (0, import_path3.dirname)((0, import_path3.dirname)((0, import_url.fileURLToPath)(importMetaUrl)));
+  const uiAssetsSource = (0, import_path3.join)(cliRoot, "ui-assets");
+  const uiAssetsDest = (0, import_path3.join)(outputDir, "assets");
+  if ((0, import_fs3.existsSync)(uiAssetsSource)) {
+    (0, import_fs3.mkdirSync)(uiAssetsDest, { recursive: true });
+    (0, import_fs3.cpSync)(uiAssetsSource, uiAssetsDest, { recursive: true });
+  }
+  const html = generateHtmlShell({ title, brand, darkMode });
+  (0, import_fs3.writeFileSync)((0, import_path3.join)(outputDir, "index.html"), html, "utf-8");
+};
+var generateHtmlShell = ({ title, brand, darkMode }) => `<!DOCTYPE html>
+<html lang="en" class="${darkMode ? "dark" : ""}">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${title} \u2014 API Docs</title>
+    <meta name="description" content="API documentation generated by flowdoc" />
+    <script>
+      window.__FLOWDOC_BRAND__ = "${brand}";
+      window.__FLOWDOC_DARK__ = ${String(darkMode)};
+    </script>
+    <script type="module" crossorigin src="./assets/ui.js"></script>
+    <link rel="stylesheet" href="./assets/index.css" />
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>`;
+
+// src/serve.ts
+var import_http = require("http");
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+var import_chalk2 = __toESM(require("chalk"), 1);
+var import_open = __toESM(require("open"), 1);
+var import_chokidar = __toESM(require("chokidar"), 1);
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon"
+};
+var serve = async (opts = {}) => {
+  const cwd = process.cwd();
+  const outputDir = opts.output ?? (0, import_path4.join)(cwd, "docs-output");
+  const port = opts.port ?? 4e3;
+  await generate({ ...opts, quiet: false });
+  const server = (0, import_http.createServer)((req, res) => {
+    const url = req.url === "/" || req.url === "" ? "/index.html" : req.url ?? "/index.html";
+    const filePath = (0, import_path4.join)(outputDir, url);
+    if (!(0, import_fs4.existsSync)(filePath)) {
+      res.writeHead(404);
+      res.end("Not found");
+      return;
+    }
+    const ext = (0, import_path4.extname)(filePath);
+    const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+    res.writeHead(200, { "Content-Type": contentType });
+    (0, import_fs4.createReadStream)(filePath).pipe(res);
+  });
+  server.listen(port, () => {
+    const url = `http://localhost:${port}`;
+    console.log();
+    console.log(`  ${import_chalk2.default.bold("flowdoc")} is running at ${import_chalk2.default.cyan(url)}`);
+    if (opts.watch) {
+      console.log(`  ${import_chalk2.default.dim("watching for changes\u2026")}`);
+    }
+    console.log();
+    if (!opts.noOpen) {
+      void (0, import_open.default)(url);
+    }
+  });
+  if (!opts.watch) return;
+  const configPath = opts.config ?? findConfigFile(cwd) ?? "";
+  let watchGlob = "src/**/*.ts";
+  if (configPath) {
+    try {
+      const raw = await loadConfig(configPath);
+      const config = resolveConfig(raw, cwd);
+      const entryDir = (0, import_path4.resolve)(cwd, config.entry).replace(/\/[^/]+$/, "");
+      watchGlob = `${entryDir}/**/*.ts`;
+    } catch {
+    }
+  }
+  let rebuilding = false;
+  const watcher = import_chokidar.default.watch(watchGlob, {
+    ignoreInitial: true,
+    ignored: ["**/node_modules/**", "**/dist/**", "**/docs-output/**"]
+  });
+  const rebuild = async (filePath) => {
+    if (rebuilding) return;
+    rebuilding = true;
+    console.log(`  ${import_chalk2.default.dim("\u2192")} ${import_chalk2.default.yellow(filePath.replace(cwd + "/", ""))} changed \u2014 regenerating\u2026`);
+    try {
+      await generate({ ...opts, quiet: true });
+      console.log(`  ${import_chalk2.default.green("\u2713")} docs updated`);
+    } catch (err) {
+      console.error(`  ${import_chalk2.default.red("\u2717")} regeneration failed:`, err instanceof Error ? err.message : err);
+    } finally {
+      rebuilding = false;
+    }
+  };
+  watcher.on("add", rebuild).on("change", rebuild).on("unlink", rebuild);
+  process.on("SIGINT", () => {
+    void watcher.close();
+    server.close();
+    process.exit(0);
+  });
+};
+
+// src/init.ts
+var import_fs5 = require("fs");
+var import_path5 = require("path");
+var import_chalk3 = __toESM(require("chalk"), 1);
+var CONFIG_TEMPLATE = `import { defineConfig } from "flowdoc-gen";
+
+export default defineConfig({
+  name: "My API",
+  version: "1.0.0",
+  description: "API documentation generated by flowdoc",
+  framework: "express",
+  entry: "./src",
+  output: "./docs-output",
+  theme: {
+    brand: "#6366f1",
+    darkMode: true,
+  },
+  // groups: [
+  //   { name: "Auth",  match: "/auth/**" },
+  //   { name: "Users", match: "/users/**" },
+  // ],
+});
+`;
+var init = (cwd = process.cwd()) => {
+  const configPath = (0, import_path5.resolve)(cwd, "flowdoc.config.ts");
+  if ((0, import_fs5.existsSync)(configPath)) {
+    console.log(import_chalk3.default.yellow("  flowdoc.config.ts already exists \u2014 skipping."));
+    return;
+  }
+  (0, import_fs5.writeFileSync)(configPath, CONFIG_TEMPLATE, "utf-8");
+  console.log();
+  console.log(`  ${import_chalk3.default.bold("flowdoc")} initialized`);
+  console.log();
+  console.log(`  Created ${import_chalk3.default.cyan("flowdoc.config.ts")}`);
+  console.log();
+  console.log("  Next steps:");
+  console.log(`    1. Edit ${import_chalk3.default.cyan("flowdoc.config.ts")} \u2014 set your entry path`);
+  console.log(`    2. Run ${import_chalk3.default.cyan("flowdoc generate")} to build your docs`);
+  console.log(`    3. Run ${import_chalk3.default.cyan("flowdoc serve")} to preview locally`);
+  console.log();
+};
+
+// src/middleware.ts
+var import_fs6 = require("fs");
+var import_path6 = require("path");
+var import_url2 = require("url");
+var MIME = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json"
+};
+var flowdoc = (opts = {}) => {
+  const cwd = process.cwd();
+  let outputDir = null;
+  let ready = false;
+  let initError = null;
+  const init2 = (async () => {
+    try {
+      const configPath = opts.config ?? findConfigFile(cwd);
+      if (!configPath) throw new Error("No flowdoc.config.ts found. Run `flowdoc init` first.");
+      const rawConfig = await loadConfig(configPath);
+      const config = resolveConfig(rawConfig, cwd);
+      outputDir = config.output ?? (0, import_path6.join)(cwd, "docs-output");
+      const routes = await extractExpressRoutes(config);
+      const spec = buildSpec(routes, config);
+      (0, import_fs6.mkdirSync)(outputDir, { recursive: true });
+      (0, import_fs6.writeFileSync)((0, import_path6.join)(outputDir, "flowdoc.json"), JSON.stringify(spec, null, 2));
+      const cliRoot = (0, import_path6.dirname)((0, import_path6.dirname)((0, import_url2.fileURLToPath)(importMetaUrl)));
+      const uiAssetsSource = (0, import_path6.join)(cliRoot, "ui-assets");
+      if ((0, import_fs6.existsSync)(uiAssetsSource)) {
+        const dest = (0, import_path6.join)(outputDir, "assets");
+        (0, import_fs6.mkdirSync)(dest, { recursive: true });
+        (0, import_fs6.cpSync)(uiAssetsSource, dest, { recursive: true });
+      }
+      ready = true;
+    } catch (err) {
+      initError = err instanceof Error ? err.message : String(err);
+    }
+  })();
+  return async (req, res, next) => {
+    await init2;
+    if (initError || !outputDir) {
+      res.status(500).send(`flowdoc init failed: ${initError}`);
+      return;
+    }
+    const urlPath = req.path === "/" || req.path === "" ? "/index.html" : req.path;
+    if (urlPath === "/index.html") {
+      const brand = "#6366f1";
+      const baseUrl = `${req.protocol}://${req.get("host")}`;
+      res.setHeader("Content-Type", "text/html");
+      res.send(buildHtml({ baseUrl, brand }));
+      return;
+    }
+    const filePath = (0, import_path6.join)(outputDir, urlPath);
+    if (!(0, import_fs6.existsSync)(filePath)) {
+      next();
+      return;
+    }
+    const mime = MIME[(0, import_path6.extname)(filePath)] ?? "application/octet-stream";
+    res.setHeader("Content-Type", mime);
+    (0, import_fs6.createReadStream)(filePath).pipe(res);
+  };
+};
+var buildHtml = ({ baseUrl, brand }) => `<!DOCTYPE html>
+<html lang="en" class="dark">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>API Docs</title>
+    <script>
+      window.__FLOWDOC_BRAND__ = "${brand}";
+      window.__FLOWDOC_BASE_URL__ = "${baseUrl}";
+    </script>
+    <script type="module" crossorigin src="./assets/ui.js"></script>
+    <link rel="stylesheet" href="./assets/index.css" />
+  </head>
+  <body><div id="root"></div></body>
+</html>`;
+
+// src/index.ts
+var defineConfig = (config) => config;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineConfig,
+  flowdoc,
+  generate,
+  init,
+  serve
+});