@exposify/next 0.0.0-stage → 0.0.2

package/dist/config.cjs

@@ -0,0 +1,2046 @@
+"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/config.ts
+var config_exports = {};
+__export(config_exports, {
+  generate: () => generate,
+  withExposify: () => withExposify
+});
+module.exports = __toCommonJS(config_exports);
+var import_node_fs7 = require("fs");
+var import_node_path7 = require("path");
+var import_core3 = require("@exposify/core");
+
+// src/codegen.ts
+var import_node_crypto = require("crypto");
+var import_node_fs6 = require("fs");
+var import_node_path6 = require("path");
+var import_core2 = require("@exposify/core");
+var import_tinyglobby = require("tinyglobby");
+
+// src/ast.ts
+var import_parser = require("@babel/parser");
+var FUNCTION_TYPES = /* @__PURE__ */ new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+function parseModule(source, file) {
+  const plugins = /\.tsx$/.test(file) ? ["typescript", "jsx"] : /\.[mc]?ts$/.test(file) ? ["typescript"] : ["jsx"];
+  try {
+    return (0, import_parser.parse)(source, { sourceType: "module", plugins, errorRecovery: true }).program;
+  } catch {
+    return null;
+  }
+}
+function walk(node, visit, parents = []) {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const child of node) walk(child, visit, parents);
+    return;
+  }
+  const n = node;
+  if (typeof n.type !== "string") return;
+  visit(n, parents);
+  parents.push(n);
+  for (const key of Object.keys(n)) {
+    if (key === "loc" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") continue;
+    const value = n[key];
+    if (value && typeof value === "object") walk(value, visit, parents);
+  }
+  parents.pop();
+}
+var text = (source, n) => n && typeof n.start === "number" && typeof n.end === "number" ? source.slice(n.start, n.end) : void 0;
+var stringValue = (n) => n?.type === "StringLiteral" ? n.value : n?.type === "TemplateLiteral" && n.expressions.length === 0 ? n.quasis[0]?.value?.cooked : void 0;
+var keyName = (n) => n?.type === "Identifier" ? n.name : stringValue(n);
+function unwrapTs(n) {
+  while (n && (n.type === "TSAsExpression" || n.type === "TSSatisfiesExpression" || n.type === "TSNonNullExpression" || n.type === "ParenthesizedExpression")) n = n.expression;
+  return n;
+}
+var paramName = (p) => {
+  const id = p.type === "AssignmentPattern" ? p.left : p.type === "TSParameterProperty" ? p.parameter : p;
+  return id?.type === "Identifier" ? id.name : void 0;
+};
+var lineOf = (n) => n.loc?.start.line ?? 1;
+
+// src/fields.ts
+var listScope = (program, file, load) => ({ program, file, lists: /* @__PURE__ */ new Map(), ...load ? { load } : {} });
+var FORM_READS = /* @__PURE__ */ new Set(["get", "getAll", "has"]);
+var FORM_ITERATION = /* @__PURE__ */ new Set(["entries", "keys", "values", "forEach"]);
+var STRING_METHODS = /* @__PURE__ */ new Set(["trim", "trimStart", "trimEnd", "toString", "toLowerCase", "toUpperCase", "normalize", "valueOf"]);
+var NUMBER_FNS = /* @__PURE__ */ new Set(["Number", "parseInt", "parseFloat"]);
+var LOOP_METHODS = /* @__PURE__ */ new Set(["map", "forEach", "flatMap", "filter", "some", "every", "find", "reduce"]);
+var RANK = { string: 0, number: 1, boolean: 2, json: 3, file: 4 };
+var SEARCH_DEPTH = 3;
+var MAX_EXPANDED = 200;
+function merge(a, b) {
+  const type = !a.type ? b.type : !b.type ? a.type : RANK[b.type] > RANK[a.type] ? b.type : a.type;
+  const values = a.enum ?? b.enum;
+  return { ...type ? { type } : {}, ...values ? { enum: values } : {} };
+}
+function constLists(program) {
+  const out = /* @__PURE__ */ new Map();
+  for (const stmt of program.body) {
+    const decl = stmt.type === "ExportNamedDeclaration" ? stmt.declaration : stmt;
+    if (decl?.type !== "VariableDeclaration" || decl.kind !== "const") continue;
+    for (const d of decl.declarations) {
+      const init = unwrapTs(d.init);
+      if (d.id.type !== "Identifier" || init?.type !== "ArrayExpression") continue;
+      const values = init.elements.map((e) => stringValue(e));
+      if (values.length > 0 && values.every((v) => v !== void 0)) out.set(d.id.name, values);
+    }
+  }
+  return out;
+}
+function listNamed(name, st) {
+  if (st.lists.has(name)) return st.lists.get(name) ?? void 0;
+  let found = constLists(st.program).get(name);
+  if (!found && st.load) {
+    for (const stmt of st.program.body) {
+      if (stmt.type !== "ImportDeclaration" || stmt.importKind === "type") continue;
+      const spec = stmt.specifiers.find((s) => s.type === "ImportSpecifier" && s.local.name === name);
+      if (!spec) continue;
+      const mod = st.load(stmt.source.value, st.file);
+      const program = mod && parseModule(mod.source, mod.file);
+      if (program) found = constLists(program).get(keyName(spec.imported) ?? name);
+      break;
+    }
+  }
+  st.lists.set(name, found ?? null);
+  return found;
+}
+function listOf(n, st) {
+  n = unwrapTs(n);
+  if (n?.type === "Identifier") return listNamed(n.name, st);
+  if (n?.type === "ArrayExpression") {
+    const values = n.elements.map((e) => stringValue(e));
+    return values.length > 0 && values.every((v) => v !== void 0) ? values : void 0;
+  }
+  return void 0;
+}
+var isFileType = (t) => t?.type === "TSTypeReference" && t.typeName?.type === "Identifier" && ["File", "Blob"].includes(t.typeName.name);
+function referencesTo(root, name) {
+  const out = [];
+  walk(root, (n, parents) => {
+    if (n.type !== "Identifier" || n.name !== name) return;
+    const p = parents[parents.length - 1];
+    if ((p?.type === "MemberExpression" || p?.type === "OptionalMemberExpression") && p.property === n && !p.computed) return;
+    if (p?.type === "ObjectProperty" && p.key === n && !p.computed) return;
+    if (p?.type === "VariableDeclarator" && p.id === n) return;
+    if (p && FUNCTION_TYPES.has(p.type) && p.params.includes(n)) return;
+    out.push({ node: n, parents: [...parents] });
+  });
+  return out;
+}
+function classify(node, parents, st, fns, depth) {
+  let cur = node;
+  for (let i = parents.length - 1; i >= 0; i--) {
+    const p = parents[i];
+    if (FUNCTION_TYPES.has(p.type)) break;
+    if (p.type === "TSAsExpression" || p.type === "TSTypeAssertion") {
+      if (isFileType(p.typeAnnotation)) return { type: "file" };
+      cur = p;
+      continue;
+    }
+    if (p.type === "TSSatisfiesExpression" || p.type === "TSNonNullExpression" || p.type === "ParenthesizedExpression") {
+      cur = p;
+      continue;
+    }
+    if (p.type === "LogicalExpression" && p.left === cur && (p.operator === "??" || p.operator === "||")) {
+      cur = p;
+      continue;
+    }
+    if (p.type === "UnaryExpression" && p.operator === "+") return { type: "number" };
+    if (p.type === "BinaryExpression") {
+      const other = unwrapTs(p.left === cur ? p.right : p.left);
+      if (p.operator === "instanceof" && other?.type === "Identifier" && ["File", "Blob"].includes(other.name)) return { type: "file" };
+      if (["===", "==", "!==", "!="].includes(p.operator) && stringValue(other) === "on") return { type: "boolean" };
+      break;
+    }
+    const call = parents[i - 1];
+    if (p.type === "MemberExpression" && p.object === cur && !p.computed && STRING_METHODS.has(keyName(p.property) ?? "") && call?.type === "CallExpression" && call.callee === p) {
+      cur = call;
+      i--;
+      continue;
+    }
+    if (p.type === "CallExpression" && p.arguments.includes(cur)) {
+      const callee = unwrapTs(p.callee);
+      const index = p.arguments.indexOf(cur);
+      if (callee.type === "Identifier") {
+        if (callee.name === "String") {
+          cur = p;
+          continue;
+        }
+        if (NUMBER_FNS.has(callee.name)) return { type: "number" };
+        const local = fns.get(callee.name);
+        if (local && depth < SEARCH_DEPTH) return followParam(local, index, st, fns, depth + 1);
+        break;
+      }
+      if (callee.type === "MemberExpression") {
+        const object = unwrapTs(callee.object);
+        const method = keyName(callee.property);
+        if (object?.type === "Identifier" && object.name === "JSON" && method === "parse") return { type: "json" };
+        if (object?.type === "Identifier" && object.name === "Number" && (method === "parseInt" || method === "parseFloat")) return { type: "number" };
+        if (method === "includes" && index === 0) {
+          const values = listOf(object, st);
+          if (values) return { enum: values };
+        }
+      }
+      break;
+    }
+    if (p.type === "VariableDeclarator" && p.init === cur && p.id.type === "Identifier") {
+      if (depth >= SEARCH_DEPTH) break;
+      let scope = parents[0] ?? st.program;
+      for (let j = i - 1; j >= 0; j--) {
+        if (FUNCTION_TYPES.has(parents[j].type)) {
+          scope = parents[j].body;
+          break;
+        }
+      }
+      let hint = {};
+      for (const ref of referencesTo(scope, p.id.name)) hint = merge(hint, classify(ref.node, ref.parents, st, fns, depth + 1));
+      return hint;
+    }
+    break;
+  }
+  return {};
+}
+function followParam(fn, index, st, fns, depth) {
+  const param = fn.params[index];
+  const name = param && paramName(param);
+  if (!name) return {};
+  let hint = {};
+  for (const ref of referencesTo(fn.body, name)) hint = merge(hint, classify(ref.node, ref.parents, st, fns, depth));
+  return hint;
+}
+function loopValues(name, parents, st) {
+  for (let i = parents.length - 1; i >= 0; i--) {
+    const p = parents[i];
+    if (p.type === "ForOfStatement") {
+      const id = p.left.type === "VariableDeclaration" ? p.left.declarations[0]?.id : p.left;
+      if (id?.type === "Identifier" && id.name === name) return listOf(p.right, st);
+    }
+    if (FUNCTION_TYPES.has(p.type) && p.params[0] && paramName(p.params[0]) === name) {
+      const call = parents[i - 1];
+      const callee = call?.type === "CallExpression" && call.arguments[0] === p ? unwrapTs(call.callee) : void 0;
+      if (callee?.type === "MemberExpression" && LOOP_METHODS.has(keyName(callee.property) ?? "")) return listOf(callee.object, st);
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function namesOf(arg, parents, st) {
+  arg = unwrapTs(arg);
+  const literal = stringValue(arg);
+  if (literal !== void 0) return [literal];
+  if (arg?.type !== "TemplateLiteral") return void 0;
+  let names = [arg.quasis[0].value.cooked];
+  for (let k = 0; k < arg.expressions.length; k++) {
+    const e = unwrapTs(arg.expressions[k]);
+    const values = e?.type === "Identifier" ? loopValues(e.name, parents, st) : void 0;
+    if (!values || names.length * values.length > MAX_EXPANDED) return void 0;
+    const after = arg.quasis[k + 1].value.cooked;
+    names = names.flatMap((prefix) => values.map((v) => `${prefix}${v}${after}`));
+  }
+  return names;
+}
+function addField(st, name, hint, array) {
+  const existing = st.fields.get(name);
+  const merged = merge(existing ?? {}, hint);
+  st.fields.set(name, {
+    name,
+    type: merged.type ?? "string",
+    ...array || existing?.array ? { array: true } : {},
+    ...merged.enum ? { enum: merged.enum } : {},
+    ...existing?.required ? { required: true } : {}
+  });
+}
+function nestedFunctions(fn) {
+  const out = /* @__PURE__ */ new Map();
+  walk(fn.body, (n) => {
+    if (n.type === "FunctionDeclaration" && n.id) out.set(n.id.name, n);
+    if (n.type === "VariableDeclarator" && n.id.type === "Identifier") {
+      const init = unwrapTs(n.init);
+      if (init && FUNCTION_TYPES.has(init.type)) out.set(n.id.name, init);
+    }
+  });
+  return out;
+}
+var formRead = (n, formNames) => {
+  if (n.type !== "CallExpression") return void 0;
+  const callee = n.callee;
+  if (callee.type !== "MemberExpression" && callee.type !== "OptionalMemberExpression") return void 0;
+  const object = unwrapTs(callee.object);
+  const method = keyName(callee.property);
+  return object?.type === "Identifier" && formNames.has(object.name) && method && FORM_READS.has(method) ? method : void 0;
+};
+function asHelper(h, closure, st, fns, depth) {
+  const params = h.params.map(paramName);
+  let found;
+  walk(h.body, (n, parents) => {
+    if (found || n.type !== "CallExpression") return;
+    const callee = n.callee;
+    if (callee.type !== "MemberExpression" && callee.type !== "OptionalMemberExpression") return;
+    const method = keyName(callee.property);
+    const object = unwrapTs(callee.object);
+    const arg = unwrapTs(n.arguments[0]);
+    if (!method || !FORM_READS.has(method) || object?.type !== "Identifier" || arg?.type !== "Identifier") return;
+    const nameIndex = params.indexOf(arg.name);
+    if (nameIndex < 0) return;
+    const formIndex = params.indexOf(object.name);
+    if (formIndex < 0 && !closure.has(object.name)) return;
+    found = { nameIndex, ...formIndex >= 0 ? { formIndex } : {}, method, hint: method === "get" ? classify(n, parents, st, fns, depth) : {} };
+  });
+  return found;
+}
+function readsOf(fn, formNames, st, depth) {
+  if (st.visited.has(fn)) return;
+  st.visited.add(fn);
+  const names = new Set(formNames);
+  walk(fn.body, (n) => {
+    const init = unwrapTs(n.init);
+    if (n.type === "VariableDeclarator" && n.id.type === "Identifier" && init?.type === "Identifier" && names.has(init.name)) names.add(n.id.name);
+  });
+  const nested = nestedFunctions(fn);
+  const fns = new Map([...st.topLevel, ...nested]);
+  const helpers = /* @__PURE__ */ new Map();
+  for (const [name, h] of fns) {
+    if (h === fn) continue;
+    const helper = asHelper(h, nested.has(name) ? names : /* @__PURE__ */ new Set(), st, fns, depth);
+    if (helper) helpers.set(name, helper);
+  }
+  const unresolved = (n, what) => st.unresolved.push(`line ${lineOf(n)}: ${what}`);
+  walk(fn.body, (n, parents) => {
+    if (n.type === "ForOfStatement" && unwrapTs(n.right)?.type === "Identifier" && names.has(unwrapTs(n.right).name)) st.readsAll = true;
+    if (n.type === "SpreadElement" && unwrapTs(n.argument)?.type === "Identifier" && names.has(unwrapTs(n.argument).name)) st.readsAll = true;
+    if (n.type !== "CallExpression") return;
+    const callee = unwrapTs(n.callee);
+    const args = n.arguments;
+    const method = formRead(n, names);
+    if (method) {
+      const arg = unwrapTs(args[0]);
+      const enclosing = [...parents].reverse().find((p) => FUNCTION_TYPES.has(p.type));
+      if (arg?.type === "Identifier" && enclosing && enclosing.params.some((p) => paramName(p) === arg.name) && [...helpers.keys()].some((h) => fns.get(h) === enclosing)) return;
+      const fieldNames = namesOf(arg, parents, st);
+      if (!fieldNames) return unresolved(n, `a field name worked out at runtime: ${text(st.source, n)}`);
+      const hint = method === "has" ? { type: "boolean" } : method === "getAll" ? {} : classify(n, parents, st, fns, depth);
+      for (const name of fieldNames) addField(st, name, hint, method === "getAll");
+      return;
+    }
+    if (callee.type === "MemberExpression" && unwrapTs(callee.object)?.type === "Identifier" && names.has(unwrapTs(callee.object).name) && FORM_ITERATION.has(keyName(callee.property) ?? "")) {
+      st.readsAll = true;
+      return;
+    }
+    const helper = callee.type === "Identifier" ? helpers.get(callee.name) : void 0;
+    if (helper) {
+      const form = helper.formIndex === void 0 ? void 0 : unwrapTs(args[helper.formIndex]);
+      if (helper.formIndex !== void 0 && !(form?.type === "Identifier" && names.has(form.name))) return;
+      const fieldNames = namesOf(args[helper.nameIndex], parents, st);
+      if (!fieldNames) return unresolved(n, `a field name worked out at runtime: ${text(st.source, n)}`);
+      const hint = helper.method === "has" ? { type: "boolean" } : merge(helper.hint, classify(n, parents, st, fns, depth));
+      for (const name of fieldNames) addField(st, name, hint, helper.method === "getAll");
+      return;
+    }
+    const index = args.findIndex((a) => unwrapTs(a)?.type === "Identifier" && names.has(unwrapTs(a).name));
+    if (index < 0) return;
+    if (callee.type === "MemberExpression" && keyName(callee.object) === "Object" && keyName(callee.property) === "fromEntries") {
+      st.readsAll = true;
+      const decl = [...parents].reverse().find((p) => !["TSAsExpression", "TSSatisfiesExpression", "ParenthesizedExpression"].includes(p.type));
+      if (decl?.type === "VariableDeclarator" && decl.id.type === "ObjectPattern") {
+        for (const prop of decl.id.properties) {
+          const key = prop.type === "ObjectProperty" ? keyName(prop.key) : void 0;
+          if (key) addField(st, key, {}, false);
+        }
+      }
+      return;
+    }
+    const local = callee.type === "Identifier" ? fns.get(callee.name) : void 0;
+    const param = local && local.params[index];
+    const paramAs = param && paramName(param);
+    if (local && paramAs && depth < SEARCH_DEPTH) return readsOf(local, /* @__PURE__ */ new Set([paramAs]), st, depth + 1);
+    unresolved(n, `the form goes to ${text(st.source, callee) ?? "a function"}(), which isn't a function in this file`);
+  });
+}
+function annotated(t) {
+  if (t?.type === "TSStringKeyword") return { type: "string" };
+  if (t?.type === "TSNumberKeyword") return { type: "number" };
+  if (t?.type === "TSBooleanKeyword") return { type: "boolean" };
+  if (t?.type === "TSUnionType") {
+    const values = t.types.map((m) => m.type === "TSLiteralType" ? stringValue(m.literal) : void 0);
+    if (values.every((v) => v !== void 0)) return { type: "string", enum: values };
+  }
+  return void 0;
+}
+function analyzeFields(fn, roles, ctx) {
+  const st = { ...ctx, lists: /* @__PURE__ */ new Map(), fields: /* @__PURE__ */ new Map(), readsAll: false, unresolved: [], visited: /* @__PURE__ */ new Set() };
+  const params = fn.params.filter((p) => p.type !== "RestElement");
+  params.forEach((p, i) => {
+    const role = roles[i];
+    if (!role || role.role === "prev") return;
+    const id = p.type === "AssignmentPattern" ? p.left : p;
+    if (role.role === "formData") return readsOf(fn, /* @__PURE__ */ new Set([role.name]), st, 0);
+    if (role.role === "input") {
+      const hint = annotated(id.typeAnnotation?.typeAnnotation);
+      if (!hint) return st.unresolved.push(`line ${lineOf(p)}: parameter ${role.name} has no type it can read (string, number, boolean or a union of strings)`);
+      st.fields.set(role.name, { name: role.name, type: hint.type, ...hint.enum ? { enum: hint.enum } : {}, required: true });
+      return;
+    }
+    const literal = id.typeAnnotation?.typeAnnotation;
+    const members = /* @__PURE__ */ new Map();
+    if (literal?.type === "TSTypeLiteral") {
+      for (const m of literal.members) if (m.type === "TSPropertySignature" && keyName(m.key)) members.set(keyName(m.key), m);
+    }
+    for (const prop of id.properties) {
+      const key = prop.type === "ObjectProperty" ? keyName(prop.key) : void 0;
+      if (!key) {
+        st.unresolved.push(`line ${lineOf(prop)}: a rest element in parameter ${role.name}`);
+        continue;
+      }
+      const member = members.get(key);
+      const hint = annotated(member?.typeAnnotation?.typeAnnotation);
+      if (!hint) {
+        st.unresolved.push(`line ${lineOf(prop)}: ${key} has no type it can read (string, number, boolean or a union of strings)`);
+        continue;
+      }
+      st.fields.set(key, { name: key, type: hint.type, ...hint.enum ? { enum: hint.enum } : {}, ...member?.optional || prop.value.type === "AssignmentPattern" ? {} : { required: true } });
+    }
+  });
+  return { fields: [...st.fields.values()], readsAll: st.readsAll, unresolved: st.unresolved };
+}
+
+// src/forms.ts
+var STATE_HOOKS = /* @__PURE__ */ new Set(["useActionState", "useFormState"]);
+var FIELD_TAGS = /* @__PURE__ */ new Set(["input", "select", "textarea"]);
+var COMPONENT_DEPTH = 2;
+var tagName = (el) => el.openingElement?.name?.type === "JSXIdentifier" ? el.openingElement.name.name : void 0;
+var attrName = (a) => a.name?.type === "JSXIdentifier" ? a.name.name : a.name?.type === "JSXNamespacedName" ? `${a.name.namespace.name}:${a.name.name.name}` : void 0;
+var isComponent = (tag) => tag !== void 0 && /^[A-Z]/.test(tag);
+function attrValue(attr, parents, scope) {
+  const v = attr.value;
+  if (v === null) return { kind: "bool", value: true };
+  if (v.type === "StringLiteral") return { kind: "string", value: v.value };
+  if (v.type !== "JSXExpressionContainer") return void 0;
+  const e = unwrapTs(v.expression);
+  if (!e || e.type === "JSXEmptyExpression") return void 0;
+  if (e.type === "BooleanLiteral") return { kind: "bool", value: e.value };
+  if (e.type === "NumericLiteral") return { kind: "number", value: e.value };
+  const s = stringValue(e);
+  if (s !== void 0) return { kind: "string", value: s };
+  return { kind: "expr", node: e, parents, scope };
+}
+function attributes(el, parents, scope) {
+  return el.openingElement.attributes.map((a) => a.type === "JSXSpreadAttribute" ? null : [attrName(a) ?? "", attrValue(a, parents, scope)]);
+}
+function moduleFor(file, source, ctx) {
+  if (ctx.modules.has(file)) return ctx.modules.get(file);
+  const program = source === void 0 ? null : parseModule(source, file);
+  const out = program ? { program, scope: listScope(program, file, ctx.load) } : null;
+  ctx.modules.set(file, out);
+  return out;
+}
+function componentIn(program, name) {
+  for (const stmt of program.body) {
+    const decl = stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration" ? stmt.declaration : stmt;
+    if (name === "default" && stmt.type === "ExportDefaultDeclaration" && decl && FUNCTION_TYPES.has(decl.type)) return decl;
+    if (decl?.type === "FunctionDeclaration" && decl.id?.name === name) return decl;
+    if (decl?.type === "VariableDeclaration") {
+      for (const d of decl.declarations) {
+        if (d.id.type !== "Identifier" || d.id.name !== name) continue;
+        let init = unwrapTs(d.init);
+        while (init?.type === "CallExpression" && init.arguments.length > 0) init = unwrapTs(init.arguments[0]);
+        if (init && FUNCTION_TYPES.has(init.type)) return init;
+      }
+    }
+  }
+  return void 0;
+}
+function findComponent(tag, mod, ctx) {
+  const local = componentIn(mod.program, tag);
+  if (local) return { fn: local, mod };
+  if (!ctx.load) return void 0;
+  for (const stmt of mod.program.body) {
+    if (stmt.type !== "ImportDeclaration") continue;
+    const spec = stmt.specifiers.find((s) => s.local.name === tag);
+    if (!spec) continue;
+    const loaded = ctx.load(stmt.source.value, mod.scope.file);
+    if (!loaded) return void 0;
+    const other = moduleFor(loaded.file, loaded.source, ctx);
+    const fn = other && componentIn(other.program, spec.type === "ImportDefaultSpecifier" ? "default" : keyName(spec.imported) ?? tag);
+    return fn && other ? { fn, mod: other } : void 0;
+  }
+  return void 0;
+}
+function renderedAttributes(el, fn, use, mod) {
+  const param = fn.params[0];
+  const pattern = param?.type === "AssignmentPattern" ? param.left : param;
+  const propsName = pattern?.type === "Identifier" ? pattern.name : void 0;
+  let restName;
+  const locals = /* @__PURE__ */ new Map();
+  if (pattern?.type === "ObjectPattern") {
+    for (const p of pattern.properties) {
+      if (p.type === "RestElement" && p.argument.type === "Identifier") restName = p.argument.name;
+      if (p.type !== "ObjectProperty") continue;
+      const prop = keyName(p.key);
+      const value = p.value.type === "AssignmentPattern" ? p.value.left : p.value;
+      if (!prop || value.type !== "Identifier") continue;
+      const fallback = p.value.type === "AssignmentPattern" ? attrValue({ type: "JSXAttribute", value: { type: "JSXExpressionContainer", expression: p.value.right } }, [], mod.scope) : void 0;
+      locals.set(value.name, { prop, ...fallback ? { fallback } : {} });
+    }
+  }
+  const named2 = new Set([...locals.values()].map((l) => l.prop));
+  const out = /* @__PURE__ */ new Map();
+  for (const a of el.openingElement.attributes) {
+    if (a.type === "JSXSpreadAttribute") {
+      const arg = unwrapTs(a.argument);
+      if (arg?.type === "Identifier" && (arg.name === restName || arg.name === propsName)) {
+        for (const [k, v] of use) if (arg.name === propsName || !named2.has(k)) out.set(k, v);
+      }
+      continue;
+    }
+    const key = attrName(a);
+    if (!key) continue;
+    const expr = a.value?.type === "JSXExpressionContainer" ? unwrapTs(a.value.expression) : void 0;
+    if (expr?.type === "Identifier" && locals.has(expr.name)) {
+      const { prop, fallback } = locals.get(expr.name);
+      const v = use.has(prop) ? use.get(prop) : fallback;
+      if (v !== void 0) out.set(key, v);
+      continue;
+    }
+    if (expr?.type === "MemberExpression" && unwrapTs(expr.object)?.type === "Identifier" && unwrapTs(expr.object).name === propsName) {
+      const prop = keyName(expr.property);
+      if (prop && use.has(prop)) out.set(key, use.get(prop));
+      continue;
+    }
+    out.set(key, attrValue(a, [], mod.scope));
+  }
+  return out;
+}
+function receivesProps(el, fn) {
+  const param = fn.params[0];
+  const pattern = param?.type === "AssignmentPattern" ? param.left : param;
+  const names = /* @__PURE__ */ new Set();
+  if (pattern?.type === "Identifier") names.add(pattern.name);
+  if (pattern?.type === "ObjectPattern") {
+    for (const p of pattern.properties) {
+      if (p.type === "RestElement" && p.argument.type === "Identifier") names.add(p.argument.name);
+      const value = p.type === "ObjectProperty" ? p.value.type === "AssignmentPattern" ? p.value.left : p.value : void 0;
+      if (value?.type === "Identifier" && keyName(p.key) === "name") names.add(value.name);
+    }
+  }
+  return el.openingElement.attributes.some((a) => {
+    if (a.type === "JSXSpreadAttribute") return unwrapTs(a.argument)?.type === "Identifier" && names.has(unwrapTs(a.argument).name);
+    if (attrName(a) !== "name") return false;
+    const e = a.value?.type === "JSXExpressionContainer" ? unwrapTs(a.value.expression) : void 0;
+    return e?.type === "Identifier" && names.has(e.name) || e?.type === "MemberExpression" && unwrapTs(e.object)?.type === "Identifier" && names.has(unwrapTs(e.object).name);
+  });
+}
+function throughComponent(tag, use, mod, ctx, depth) {
+  if (depth > COMPONENT_DEPTH) return void 0;
+  const found = findComponent(tag, mod, ctx);
+  if (!found) return void 0;
+  let result;
+  walk(found.fn.body, (n) => {
+    if (result || n.type !== "JSXElement") return;
+    const inner = tagName(n);
+    if (!inner || !(FIELD_TAGS.has(inner) || isComponent(inner)) || !receivesProps(n, found.fn)) return;
+    const attrs = renderedAttributes(n, found.fn, use, found.mod);
+    result = FIELD_TAGS.has(inner) ? { tag: inner, attrs } : throughComponent(inner, attrs, found.mod, ctx, depth + 1);
+  });
+  return result;
+}
+var num = (v) => v?.kind === "number" ? v.value : v?.kind === "string" && v.value.trim() !== "" && !Number.isNaN(Number(v.value)) ? Number(v.value) : void 0;
+var str = (v) => v?.kind === "string" ? v.value : void 0;
+var truthy = (v) => v?.kind === "bool" ? v.value : v?.kind === "string" ? v.value !== "false" : false;
+function selectOptions(el, scope) {
+  const values = [];
+  let open = false;
+  walk(el.children, (n, parents) => {
+    if (n.type !== "JSXElement" || tagName(n) !== "option") return;
+    const attr = n.openingElement.attributes.find((a) => a.type === "JSXAttribute" && attrName(a) === "value");
+    const v = attr && attrValue(attr, [...parents], scope);
+    if (v?.kind === "string") return void values.push(v.value);
+    const names = v?.kind !== "expr" ? void 0 : v.node.type === "Identifier" ? loopValues(v.node.name, [...parents], scope) : namesOf(v.node, [...parents], scope);
+    if (names) values.push(...names);
+    else open = true;
+  });
+  return open || values.length === 0 ? void 0 : [...new Set(values)];
+}
+function formFields(form, mod, ctx, unresolved) {
+  const fields = /* @__PURE__ */ new Map();
+  const radios = /* @__PURE__ */ new Map();
+  walk(form.children, (n, parents) => {
+    if (n.type !== "JSXElement") return;
+    const tag = tagName(n);
+    if (!tag || !(FIELD_TAGS.has(tag) || isComponent(tag))) return;
+    const own = attributes(n, [...parents], mod.scope);
+    const use = new Map(own.filter((a) => a !== null));
+    if (!use.has("name")) return;
+    let el = { tag, attrs: use };
+    if (isComponent(tag)) el = throughComponent(tag, use, mod, ctx, 1) ?? { tag: "input", attrs: use };
+    const nameVal = el.attrs.get("name");
+    const names = nameVal?.kind === "string" ? [nameVal.value] : nameVal?.kind === "expr" ? namesOf(nameVal.node, nameVal.parents, nameVal.scope) : void 0;
+    if (!names) return void unresolved.push(`${mod.scope.file}:${lineOf(n)}: a field name from runtime data`);
+    const conditional = parents.some((p) => p.type === "LogicalExpression" || p.type === "ConditionalExpression");
+    const type = str(el.attrs.get("type"))?.toLowerCase();
+    const value = el.attrs.get("value");
+    const field = {};
+    if (el.tag === "input" && (type === "number" || type === "range")) field.type = "number";
+    if (el.tag === "input" && type === "checkbox") field.type = "boolean";
+    if (el.tag === "input" && type === "file") field.type = "file";
+    const stringified = value?.kind === "expr" && value.node.type === "CallExpression" && keyName(value.node.callee?.object) === "JSON" && keyName(value.node.callee?.property) === "stringify";
+    if (stringified) field.type = "json";
+    if (el.tag === "select" && !isComponent(tag)) {
+      const options = selectOptions(n, mod.scope);
+      if (options) field.enum = options;
+    }
+    if (el.tag === "input" && type === "radio" && str(value) !== void 0) {
+      for (const name of names) radios.set(name, [...radios.get(name) ?? [], str(value)]);
+    }
+    const required = truthy(el.attrs.get("required")) || el.tag === "input" && type === "hidden";
+    if (required && !conditional && type !== "checkbox") field.required = true;
+    for (const k of ["min", "max", "minLength", "maxLength"]) {
+      const v = num(el.attrs.get(k) ?? el.attrs.get(k.toLowerCase()));
+      if (v !== void 0) field[k] = v;
+    }
+    const pattern = str(el.attrs.get("pattern"));
+    if (pattern) field.pattern = pattern;
+    for (const name of names) fields.set(name, { name, ...fields.get(name), ...field });
+  });
+  for (const [name, values] of radios) {
+    const f = fields.get(name);
+    if (f) f.enum = [...new Set(values)];
+  }
+  return [...fields.values()];
+}
+function findFormUses(source, file, actions, load, ctx = { ...load ? { load } : {}, modules: /* @__PURE__ */ new Map() }) {
+  const mod = moduleFor(file, source, ctx);
+  if (!mod) return [];
+  const { program } = mod;
+  const imported = /* @__PURE__ */ new Map();
+  const namespaces = /* @__PURE__ */ new Map();
+  for (const stmt of program.body) {
+    if (stmt.type !== "ImportDeclaration" || stmt.importKind === "type" || !load) continue;
+    const target = load(stmt.source.value, file);
+    const exports2 = target && actions.get(target.file);
+    if (!target || !exports2) continue;
+    for (const spec of stmt.specifiers) {
+      if (spec.type === "ImportNamespaceSpecifier") namespaces.set(spec.local.name, target.file);
+      const name = spec.type === "ImportDefaultSpecifier" ? "default" : spec.type === "ImportSpecifier" ? keyName(spec.imported) : void 0;
+      if (name && exports2.has(name)) imported.set(spec.local.name, { file: target.file, export: name });
+    }
+  }
+  if (imported.size === 0 && namespaces.size === 0) return [];
+  const aliases = /* @__PURE__ */ new Map();
+  const refOf = (e) => {
+    e = unwrapTs(e);
+    if (!e) return void 0;
+    if (e.type === "Identifier") return aliases.get(e.name) ?? (imported.has(e.name) ? { ...imported.get(e.name), bound: 0, prev: false } : void 0);
+    if (e.type === "MemberExpression" && unwrapTs(e.object)?.type === "Identifier" && namespaces.has(unwrapTs(e.object).name)) {
+      const name = keyName(e.property);
+      const target = namespaces.get(unwrapTs(e.object).name);
+      return name && actions.get(target)?.has(name) ? { file: target, export: name, bound: 0, prev: false } : void 0;
+    }
+    if (e.type === "CallExpression" && e.callee.type === "MemberExpression" && keyName(e.callee.property) === "bind") {
+      const inner = refOf(e.callee.object);
+      return inner && { ...inner, bound: inner.bound + Math.max(0, e.arguments.length - 1) };
+    }
+    return void 0;
+  };
+  const refIn = (e) => {
+    let found;
+    walk(e, (n, parents) => {
+      if (found || !(n.type === "Identifier" || n.type === "MemberExpression" || n.type === "CallExpression")) return;
+      const ref = refOf(n);
+      if (!ref) return;
+      const call = parents[parents.length - 1];
+      const called = call?.type === "CallExpression" && call.callee === n && !ref.prev;
+      found = called ? { ...ref, bound: ref.bound + Math.max(0, call.arguments.length - 1) } : ref;
+    });
+    return found;
+  };
+  walk(program, (n) => {
+    if (n.type !== "VariableDeclarator") return;
+    const init = unwrapTs(n.init);
+    if (n.id.type === "ArrayPattern" && init?.type === "CallExpression") {
+      const hook = init.callee.type === "Identifier" ? init.callee.name : keyName(init.callee.property);
+      const ref = hook && STATE_HOOKS.has(hook) ? refOf(init.arguments[0]) : void 0;
+      const id = n.id.elements[1];
+      if (ref && id?.type === "Identifier") aliases.set(id.name, { ...ref, prev: true });
+    }
+    if (n.id.type === "Identifier" && init) {
+      const ref = refOf(init);
+      if (ref) aliases.set(n.id.name, ref);
+    }
+  });
+  const out = [];
+  const unresolvedFor = /* @__PURE__ */ new Map();
+  const fieldsFor = (form) => {
+    if (!unresolvedFor.has(form)) unresolvedFor.set(form, []);
+    return formFields(form, mod, ctx, unresolvedFor.get(form));
+  };
+  walk(program, (n, parents) => {
+    if (n.type !== "JSXElement") return;
+    const tag = tagName(n);
+    const attr = (name) => n.openingElement.attributes.find((a) => a.type === "JSXAttribute" && attrName(a) === name);
+    const refs = [];
+    if (tag === "form") {
+      for (const name of ["action", "onSubmit"]) {
+        const ref = refIn(attr(name)?.value);
+        if (ref) refs.push(ref);
+      }
+    }
+    const formAction = (tag === "button" || tag === "input") && refIn(attr("formAction")?.value);
+    const form = formAction ? [...parents].reverse().find((p) => p.type === "JSXElement" && tagName(p) === "form") : n;
+    if (formAction) refs.push(formAction);
+    if (!form || refs.length === 0) return;
+    const fields = fieldsFor(form);
+    for (const ref of refs.filter((r, i) => refs.findIndex((o) => o.file === r.file && o.export === r.export) === i)) {
+      out.push({ action: { file: ref.file, export: ref.export }, file, line: lineOf(form), bound: ref.bound, prev: ref.prev, fields, unresolved: unresolvedFor.get(form) });
+    }
+  });
+  return out;
+}
+function linkForms(action, uses) {
+  if (uses.length === 0) return action;
+  const fromForms = /* @__PURE__ */ new Map();
+  for (const use of uses) {
+    for (const f of use.fields) {
+      const seen = fromForms.get(f.name);
+      fromForms.set(f.name, { ...seen, ...f, enum: seen?.enum ?? f.enum, requiredIn: (seen?.requiredIn ?? 0) + (f.required ? 1 : 0) });
+    }
+  }
+  const formsWith = (name) => uses.filter((u) => u.fields.some((f) => f.name === name)).length;
+  const merged = (base, f) => {
+    const type = f.type === "file" ? "file" : base?.type ?? f.type ?? "string";
+    const values = base?.enum ?? f.enum;
+    const required = base?.required || f.requiredIn === formsWith(f.name);
+    return {
+      name: f.name,
+      type,
+      ...base?.array ? { array: true } : {},
+      ...values ? { enum: values } : {},
+      ...required ? { required: true } : {},
+      ...type === "number" && f.min !== void 0 ? { min: f.min } : {},
+      ...type === "number" && f.max !== void 0 ? { max: f.max } : {},
+      ...type === "string" && f.minLength !== void 0 ? { minLength: f.minLength } : {},
+      ...type === "string" && f.maxLength !== void 0 ? { maxLength: f.maxLength } : {},
+      ...type === "string" && f.pattern !== void 0 ? { pattern: f.pattern } : {},
+      origin: base ? "both" : "form"
+    };
+  };
+  const fields = action.fields.map((a) => {
+    const f = fromForms.get(a.name);
+    return f ? merged(a, f) : { ...a, origin: "action" };
+  });
+  if (action.readsAll) {
+    for (const f of fromForms.values()) if (!action.fields.some((a) => a.name === f.name)) fields.push(merged(void 0, f));
+  }
+  return {
+    ...action,
+    fields,
+    // A form's unreadable names matter only when the action reads whatever the form sends.
+    unresolved: [...action.unresolved, ...action.readsAll ? uses.flatMap((u) => u.unresolved) : []],
+    forms: uses.map((u) => ({ file: u.file, line: u.line }))
+  };
+}
+
+// src/hosts.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+
+// src/routes.ts
+var HTTP_METHODS = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
+var DEFAULT_PAGE_EXTENSIONS = ["tsx", "ts", "jsx", "js"];
+function appRoute(dirSegments) {
+  const parts = [];
+  const params = [];
+  for (const seg of dirSegments) {
+    if (seg.startsWith("_") || seg.startsWith("@") || seg.startsWith("(.")) return null;
+    if (seg.startsWith("(") && seg.endsWith(")")) continue;
+    const part = dynamicSegment(seg, params);
+    if (part === null) return null;
+    parts.push(part);
+  }
+  return { path: `/${parts.join("/")}`, params };
+}
+function pagesApiRoute(segments) {
+  if (segments[0] !== "api") return null;
+  const segs = segments.at(-1) === "index" ? segments.slice(0, -1) : segments;
+  const parts = [];
+  const params = [];
+  for (const seg of segs) {
+    if (seg.startsWith("_")) return null;
+    const part = dynamicSegment(seg, params);
+    if (part === null) return null;
+    parts.push(part);
+  }
+  return { path: `/${parts.join("/")}`, params };
+}
+function dynamicSegment(seg, params) {
+  const optionalCatchAll = /^\[\[\.\.\.([A-Za-z0-9_]+)\]\]$/.exec(seg);
+  if (optionalCatchAll) {
+    params.push(optionalCatchAll[1]);
+    return `:${optionalCatchAll[1]}*?`;
+  }
+  const catchAll = /^\[\.\.\.([A-Za-z0-9_]+)\]$/.exec(seg);
+  if (catchAll) {
+    params.push(catchAll[1]);
+    return `:${catchAll[1]}*`;
+  }
+  const dynamic = /^\[([A-Za-z0-9_]+)\]$/.exec(seg);
+  if (dynamic) {
+    params.push(dynamic[1]);
+    return `:${dynamic[1]}`;
+  }
+  return seg.includes("[") ? null : seg;
+}
+
+// src/hosts.ts
+function edgesOf(source, file, load) {
+  const program = parseModule(source, file);
+  if (!program) return [];
+  const edges = [];
+  const add = (specifier2, names) => {
+    if (typeof specifier2 !== "string") return;
+    const target = load(specifier2, file);
+    if (target) edges.push({ file: target.file, names });
+  };
+  for (const stmt of program.body) {
+    if (stmt.type === "ImportDeclaration" && stmt.importKind !== "type") {
+      const specs = stmt.specifiers;
+      if (specs.some((s) => s.type === "ImportNamespaceSpecifier")) add(stmt.source.value, "*");
+      else add(stmt.source.value, new Set(specs.filter((s) => s.importKind !== "type").map((s) => s.type === "ImportDefaultSpecifier" ? "default" : keyName(s.imported) ?? "").filter(Boolean)));
+    } else if (stmt.type === "ExportNamedDeclaration" && stmt.source && stmt.exportKind !== "type") {
+      add(stmt.source.value, new Set(stmt.specifiers.map((s) => s.type === "ExportNamespaceSpecifier" ? "*" : keyName(s.local) ?? "").filter(Boolean)));
+    } else if (stmt.type === "ExportAllDeclaration" && stmt.exportKind !== "type") {
+      add(stmt.source.value, "*");
+    }
+  }
+  walk(program, (n) => {
+    if (n.type === "CallExpression" && n.callee?.type === "Import") add(n.arguments?.[0]?.value, "*");
+    if (n.type === "ImportExpression") add(n.source?.value, "*");
+  });
+  return edges;
+}
+function moduleGraph(root, load) {
+  const cache = /* @__PURE__ */ new Map();
+  const edges = (file) => {
+    let e = cache.get(file);
+    if (!e) {
+      let source;
+      try {
+        source = (0, import_node_fs.readFileSync)((0, import_node_path.join)(root, file), "utf8");
+      } catch {
+        source = void 0;
+      }
+      e = source === void 0 ? [] : edgesOf(source, file, load);
+      cache.set(file, e);
+    }
+    return e;
+  };
+  return {
+    edges,
+    reachable(roots) {
+      const seen = /* @__PURE__ */ new Set();
+      const queue = [...roots];
+      while (queue.length > 0 && seen.size < 2e3) {
+        const file = queue.shift();
+        if (seen.has(file)) continue;
+        seen.add(file);
+        for (const edge of edges(file)) if (!seen.has(edge.file)) queue.push(edge.file);
+      }
+      return seen;
+    }
+  };
+}
+function pageEntries(appDir, files, exts) {
+  const extPattern = exts.map((e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  const entry = new RegExp(`^(page|layout|template)\\.(${extPattern})$`);
+  const base = (f) => f.slice(f.lastIndexOf("/") + 1);
+  const inApp = files.filter((f) => f.startsWith(`${appDir}/`) && entry.test(base(f)));
+  const layouts = /* @__PURE__ */ new Map();
+  for (const f of inApp) {
+    if (/^page\./.test(base(f))) continue;
+    const dir = f.slice(0, f.lastIndexOf("/"));
+    layouts.set(dir, [...layouts.get(dir) ?? [], f]);
+  }
+  const out = [];
+  for (const page of inApp.filter((f) => /^page\./.test(base(f)))) {
+    const dir = page.slice(0, page.lastIndexOf("/"));
+    const route = appRoute(dir === appDir ? [] : dir.slice(appDir.length + 1).split("/"));
+    if (!route) continue;
+    const roots = [page];
+    for (let d = dir; d.length >= appDir.length; d = d.slice(0, Math.max(d.lastIndexOf("/"), 0))) {
+      roots.push(...layouts.get(d) ?? []);
+      if (d === appDir) break;
+    }
+    out.push({ file: page, path: route.path, params: route.params, roots });
+  }
+  return out;
+}
+function actionHosts(pages, graph, actionExports) {
+  const best = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const used = /* @__PURE__ */ new Set();
+    for (const file of graph.reachable(page.roots)) {
+      for (const edge of graph.edges(file)) {
+        const exported = actionExports.get(edge.file);
+        if (exported) {
+          for (const name of edge.names === "*" ? exported : edge.names) if (exported.has(name)) used.add(`${edge.file}#${name}`);
+        }
+      }
+    }
+    for (const key of used) {
+      const current = best.get(key);
+      const candidate = { path: page.path, params: page.params.length };
+      if (!current || candidate.params < current.params || candidate.params === current.params && (candidate.path.length < current.path.length || candidate.path.length === current.path.length && candidate.path < current.path)) {
+        best.set(key, candidate);
+      }
+    }
+  }
+  return new Map([...best].map(([k, v]) => [k, v.path]));
+}
+
+// src/login.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_core = require("@exposify/core");
+var SESSION_CODE = /cookies\(\)\s*\.set|\.cookies\.set\(|cookieStore\.set|set-cookie|setCookie|\bjwt\.sign\(|new\s+SignJWT|\bsign\(|createSession|session\.(save|create)|\.login\(/i;
+function routeBodyFields(source) {
+  const names = /* @__PURE__ */ new Set();
+  let body = null;
+  for (const m of source.matchAll(/(?:const|let|var)\s+(\w+)\s*=\s*(?:await\s+)?\w+\.formData\(\)/g)) {
+    body ??= "form";
+    for (const read2 of source.matchAll(new RegExp(`\\b${m[1]}\\.get\\(\\s*["'\`]([A-Za-z0-9_.\\-]+)["'\`]`, "g"))) names.add(read2[1]);
+  }
+  for (const m of source.matchAll(/(?:const|let|var)\s*\{([^}]*)\}\s*=\s*(?:await\s+)?\w+\.(json|formData)\(\)/g)) {
+    body = m[2] === "json" ? "json" : "form";
+    for (const part of m[1].split(",")) {
+      const name = part.split(/[:=]/)[0].trim().replace(/^\.\.\./, "");
+      if (/^[A-Za-z_$][\w$]*$/.test(name)) names.add(name);
+    }
+  }
+  for (const m of source.matchAll(/(?:const|let|var)\s+(\w+)\s*=\s*(?:await\s+)?\w+\.json\(\)/g)) {
+    body ??= "json";
+    for (const read2 of source.matchAll(new RegExp(`\\b${m[1]}\\.(\\w+)`, "g"))) names.add(read2[1]);
+  }
+  return names.size && body ? { fields: [...names], body } : null;
+}
+function actionCandidate(a) {
+  if (import_core.NOT_A_LOGIN.test(a.key) || import_core.NOT_A_LOGIN.test(a.action.name)) return null;
+  if (!a.action.params.some((p) => p.role === "formData" || p.role === "object")) return null;
+  const fields = (0, import_core.loginFields)(a.action.fields.map((f) => f.name));
+  if (!fields) return null;
+  if (!a.action.setsCookies && !import_core.LOGIN_NAME.test(a.action.name)) return null;
+  return { kind: "action", key: a.key, export: a.action.name, file: a.file, fields, ...a.host ? { host: a.host } : {} };
+}
+function routeCandidate(root, r) {
+  if (r.router !== "app" || !r.module.methods.includes("POST") || r.params.length > 0 || import_core.NOT_A_LOGIN.test(r.path)) return null;
+  let source;
+  try {
+    source = (0, import_node_fs2.readFileSync)((0, import_node_path2.join)(root, r.file), "utf8");
+  } catch {
+    return null;
+  }
+  const read2 = routeBodyFields(source);
+  const fields = read2 ? (0, import_core.loginFields)(read2.fields) : null;
+  if (!read2 || !fields) return null;
+  if (!import_core.LOGIN_NAME.test(r.path) && !SESSION_CODE.test(source)) return null;
+  return { kind: "route", path: r.path, file: r.file, fields, body: read2.body };
+}
+var named = (l) => import_core.LOGIN_NAME.test(l.kind === "action" ? l.export : l.path);
+function findLogin(d) {
+  const candidates = [];
+  for (const a of d.actions) {
+    const c = actionCandidate(a);
+    if (c) candidates.push(c);
+  }
+  for (const r of d.routes) {
+    const c = routeCandidate(d.root, r);
+    if (c) candidates.push(c);
+  }
+  if (candidates.length === 0) return null;
+  const score = (l) => (named(l) ? 0 : 4) + (l.kind === "action" && l.host ? 0 : 2) + l.fields.length / 100;
+  candidates.sort((a, b) => score(a) - score(b));
+  return { login: candidates[0], others: candidates.slice(1) };
+}
+
+// src/guards.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+var STOPS = /* @__PURE__ */ new Set(["notFound", "redirect", "permanentRedirect", "forbidden", "unauthorized"]);
+var MAX_DEPTH = 4;
+function analyse(source, file) {
+  const program = parseModule(source, file);
+  if (!program) return null;
+  const imports = /* @__PURE__ */ new Map();
+  const stops = /* @__PURE__ */ new Set();
+  const functions = /* @__PURE__ */ new Map();
+  const exports2 = /* @__PURE__ */ new Map();
+  const fn = (n) => n && FUNCTION_TYPES.has(n.type) ? n : void 0;
+  for (const stmt of program.body) {
+    if (stmt.type === "ImportDeclaration" && stmt.importKind !== "type") {
+      const specifier2 = stmt.source.value;
+      for (const s of stmt.specifiers) {
+        const local = s.local?.name;
+        if (!local) continue;
+        const name = s.type === "ImportDefaultSpecifier" ? "default" : s.type === "ImportNamespaceSpecifier" ? "*" : keyName(s.imported) ?? local;
+        if (specifier2 === "next/navigation" && STOPS.has(name)) stops.add(local);
+        else imports.set(local, { specifier: specifier2, name });
+      }
+      continue;
+    }
+    const decl = stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration" ? stmt.declaration : stmt;
+    if (decl?.type === "FunctionDeclaration" && decl.id) {
+      functions.set(decl.id.name, decl);
+      if (stmt.type === "ExportNamedDeclaration") exports2.set(decl.id.name, decl.id.name);
+    }
+    if (stmt.type === "ExportDefaultDeclaration") {
+      if (decl?.type === "FunctionDeclaration" && decl.id) exports2.set("default", decl.id.name);
+      else if (fn(decl)) {
+        functions.set("default", decl);
+        exports2.set("default", "default");
+      } else if (decl?.type === "Identifier") exports2.set("default", decl.name);
+    }
+    if (decl?.type === "VariableDeclaration") {
+      for (const d of decl.declarations) {
+        const init = fn(d.init) ?? fn(d.init?.arguments?.[0]);
+        if (d.id?.type === "Identifier" && init) {
+          functions.set(d.id.name, init);
+          if (stmt.type === "ExportNamedDeclaration") exports2.set(d.id.name, d.id.name);
+        }
+      }
+    }
+    if (stmt.type === "ExportNamedDeclaration" && !stmt.source) {
+      for (const s of stmt.specifiers ?? []) {
+        const exported = keyName(s.exported);
+        if (exported && s.local?.name) exports2.set(exported, s.local.name);
+      }
+    }
+  }
+  return { program, imports, stops, functions, exports: exports2 };
+}
+function guardFinder(root, load) {
+  const parsed = /* @__PURE__ */ new Map();
+  const known = /* @__PURE__ */ new Map();
+  const parse2 = (file, source) => {
+    if (!parsed.has(file)) {
+      let text2 = source;
+      if (text2 === void 0) {
+        try {
+          text2 = (0, import_node_fs3.readFileSync)((0, import_node_path3.join)(root, file), "utf8");
+        } catch {
+          text2 = void 0;
+        }
+      }
+      parsed.set(file, text2 === void 0 ? null : analyse(text2, file));
+    }
+    return parsed.get(file);
+  };
+  const stopsLocally = (file, p, local, depth, seen) => {
+    const body = p.functions.get(local);
+    if (!body || seen.has(`${file}#${local}`)) return false;
+    seen.add(`${file}#${local}`);
+    let found = false;
+    walk(body, (n) => {
+      if (found || n.type !== "CallExpression" || n.callee?.type !== "Identifier") return;
+      const name = n.callee.name;
+      if (p.stops.has(name)) found = true;
+      else if (p.functions.has(name) && name !== local) found = stopsLocally(file, p, name, depth, seen);
+      else if (p.imports.has(name)) found = guardKey(file, p, name, depth + 1) !== null;
+    });
+    return found;
+  };
+  const guardKey = (file, p, local, depth) => {
+    if (depth > MAX_DEPTH) return null;
+    const imp = p.imports.get(local);
+    if (!imp || imp.name === "*") return null;
+    const target = load(imp.specifier, file);
+    if (!target) return null;
+    const key = `${target.file}#${imp.name}`;
+    const cached = known.get(key);
+    if (cached !== void 0) return cached ? key : null;
+    known.set(key, false);
+    const tp = parse2(target.file, target.source);
+    const localName = tp?.exports.get(imp.name);
+    const is = Boolean(tp && localName && stopsLocally(target.file, tp, localName, depth, /* @__PURE__ */ new Set()));
+    known.set(key, is);
+    return is ? key : null;
+  };
+  const guardsUnder = (file, p, node, visited = /* @__PURE__ */ new Set()) => {
+    const out = /* @__PURE__ */ new Set();
+    visited.add(node);
+    walk(node, (n) => {
+      if (n.type !== "CallExpression" || n.callee?.type !== "Identifier") return;
+      const name = n.callee.name;
+      if (p.imports.has(name)) {
+        const key = guardKey(file, p, name, 0);
+        if (key) out.add(key);
+      } else if (p.functions.has(name)) {
+        const body = p.functions.get(name);
+        if (!visited.has(body)) for (const k of guardsUnder(file, p, body, visited)) out.add(k);
+      }
+    });
+    return [...out];
+  };
+  return {
+    /** Guards a page runs: in its file and the layouts above it (every function there, so a check inside a Suspense'd component counts). */
+    page(files) {
+      const out = /* @__PURE__ */ new Set();
+      for (const file of files) {
+        const p = parse2(file);
+        if (p) for (const k of guardsUnder(file, p, p.program)) out.add(k);
+      }
+      return [...out].sort();
+    },
+    /** Guards a Server Action runs: in its own body. */
+    action(file, exportName) {
+      const p = parse2(file);
+      const local = p?.exports.get(exportName);
+      const body = local ? p.functions.get(local) : void 0;
+      return p && body ? guardsUnder(file, p, body).sort() : [];
+    }
+  };
+}
+
+// src/pages.ts
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
+var read = (root, file) => {
+  try {
+    return (0, import_node_fs4.readFileSync)((0, import_node_path4.join)(root, file), "utf8");
+  } catch {
+    return void 0;
+  }
+};
+function defaultExportFunction(program) {
+  const locals = /* @__PURE__ */ new Map();
+  for (const stmt of program.body) {
+    if (stmt.type === "FunctionDeclaration" && stmt.id) locals.set(stmt.id.name, stmt);
+    if (stmt.type === "VariableDeclaration") {
+      for (const d of stmt.declarations) if (d.id?.type === "Identifier" && FUNCTION_TYPES.has(unwrapTs(d.init)?.type ?? "")) locals.set(d.id.name, unwrapTs(d.init));
+    }
+  }
+  for (const stmt of program.body) {
+    if (stmt.type !== "ExportDefaultDeclaration") continue;
+    const d = unwrapTs(stmt.declaration);
+    if (d && FUNCTION_TYPES.has(d.type)) return d;
+    if (d?.type === "Identifier") return locals.get(d.name);
+  }
+  return void 0;
+}
+var AWAITED = (n) => {
+  const u = unwrapTs(n);
+  if (u?.type === "AwaitExpression") return unwrapTs(u.argument);
+  if (u?.type === "CallExpression" && u.callee?.type === "Identifier" && u.callee.name === "use") return unwrapTs(u.arguments?.[0]);
+  return u;
+};
+var patternKeys = (p) => p.type === "ObjectPattern" ? p.properties.filter((x) => x.type === "ObjectProperty").map((x) => keyName(x.key)).filter((k) => Boolean(k)) : [];
+function pageSearchParams(program) {
+  const names = /* @__PURE__ */ new Set();
+  const sources = /* @__PURE__ */ new Set();
+  const propsNames = /* @__PURE__ */ new Set();
+  walk(program, (fn) => {
+    if (!FUNCTION_TYPES.has(fn.type)) return;
+    const param = fn.params?.[0];
+    if (param?.type === "ObjectPattern") {
+      for (const prop of param.properties) {
+        if (prop.type !== "ObjectProperty" || keyName(prop.key) !== "searchParams") continue;
+        const value = prop.value.type === "AssignmentPattern" ? prop.value.left : prop.value;
+        if (value.type === "Identifier") sources.add(value.name);
+        for (const k of patternKeys(value)) names.add(k);
+      }
+    } else if (param?.type === "Identifier" && fn === defaultExportFunction(program)) propsNames.add(param.name);
+  });
+  const isSource = (n) => {
+    const a = AWAITED(n);
+    if (!a) return false;
+    if (a.type === "Identifier") return sources.has(a.name);
+    return a.type === "MemberExpression" && unwrapTs(a.object)?.type === "Identifier" && propsNames.has(unwrapTs(a.object).name) && keyName(a.property) === "searchParams";
+  };
+  const promiseAll = (n) => {
+    const a = AWAITED(n);
+    const callee = a?.type === "CallExpression" ? a.callee : void 0;
+    return callee?.type === "MemberExpression" && keyName(callee.object) === "Promise" && keyName(callee.property) === "all" && a.arguments?.[0]?.type === "ArrayExpression" ? a.arguments[0].elements : void 0;
+  };
+  walk(program, (n) => {
+    if (n.type !== "VariableDeclarator") return;
+    if (isSource(n.init)) {
+      if (n.id.type === "Identifier") sources.add(n.id.name);
+      for (const k of patternKeys(n.id)) names.add(k);
+    }
+    const all = promiseAll(n.init);
+    if (all && n.id.type === "ArrayPattern") {
+      n.id.elements.forEach((el, i) => {
+        if (!el || !isSource(all[i])) return;
+        if (el.type === "Identifier") sources.add(el.name);
+        for (const k of patternKeys(el)) names.add(k);
+      });
+    }
+  });
+  walk(program, (n) => {
+    if (n.type !== "MemberExpression" || !isSource(n.object)) return;
+    const k = n.computed ? stringValue(n.property) : keyName(n.property);
+    if (k) names.add(k);
+  });
+  return [...names];
+}
+function hookSearchParams(program) {
+  const names = /* @__PURE__ */ new Set();
+  const holders = /* @__PURE__ */ new Set();
+  const isHook = (n) => {
+    const u = unwrapTs(n);
+    return u?.type === "CallExpression" && u.callee?.type === "Identifier" && u.callee.name === "useSearchParams";
+  };
+  walk(program, (n) => {
+    if (n.type === "VariableDeclarator" && n.id.type === "Identifier" && isHook(n.init)) holders.add(n.id.name);
+  });
+  walk(program, (n) => {
+    if (n.type !== "CallExpression" || n.callee?.type !== "MemberExpression") return;
+    const method = keyName(n.callee.property);
+    if (method !== "get" && method !== "getAll" && method !== "has") return;
+    const target = unwrapTs(n.callee.object);
+    const fromHook = isHook(target) || target?.type === "Identifier" && holders.has(target.name);
+    const name = stringValue(n.arguments?.[0]);
+    if (fromHook && name) names.add(name);
+  });
+  return [...names];
+}
+function staticMetadata(program) {
+  for (const stmt of program.body) {
+    if (stmt.type !== "ExportNamedDeclaration" || stmt.declaration?.type !== "VariableDeclaration") continue;
+    for (const d of stmt.declaration.declarations) {
+      const init = unwrapTs(d.init);
+      if (d.id?.type !== "Identifier" || d.id.name !== "metadata" || init?.type !== "ObjectExpression") continue;
+      const out = {};
+      for (const prop of init.properties) {
+        if (prop.type !== "ObjectProperty") continue;
+        const key = keyName(prop.key);
+        const value = unwrapTs(prop.value);
+        if (key === "description") {
+          const s = stringValue(value);
+          if (s) out.description = s;
+        }
+        if (key === "title") {
+          let s = stringValue(value);
+          if (!s && value?.type === "ObjectExpression") {
+            const byKey = new Map(value.properties.filter((p) => p.type === "ObjectProperty").map((p) => [keyName(p.key), stringValue(unwrapTs(p.value))]));
+            s = byKey.get("absolute") ?? byKey.get("default");
+          }
+          if (s) out.title = s;
+        }
+      }
+      return out;
+    }
+  }
+  return {};
+}
+function readsData(program, file, load, actionFiles) {
+  const imported = /* @__PURE__ */ new Set();
+  for (const stmt of program.body) {
+    if (stmt.type !== "ImportDeclaration" || stmt.importKind === "type") continue;
+    const source = stmt.source.value;
+    if (/^next(\/|$)/.test(source) || source === "react") continue;
+    if (actionFiles.has(load(source, file)?.file ?? "")) continue;
+    for (const s of stmt.specifiers) if (!/^[A-Z]/.test(s.local.name)) imported.add(s.local.name);
+  }
+  let reads = false;
+  walk(program, (n, parents) => {
+    if (reads) return;
+    if (n.type === "AwaitExpression") reads = true;
+    if (n.type !== "Identifier" || !imported.has(n.name)) return;
+    const parent = parents[parents.length - 1];
+    if (!parent || parent.type.startsWith("Import")) return;
+    if (parent.type === "CallExpression" && parent.callee === n) return;
+    if (parent.type === "MemberExpression" && parent.property === n && !parent.computed || parent.type === "ObjectProperty" && parent.key === n && !parent.computed) return;
+    reads = true;
+  });
+  return reads;
+}
+var directive = (program) => program.directives?.[0]?.value?.value;
+function pageToolName(path, snake) {
+  const words = path.split("/").filter(Boolean).map((seg) => seg.replace(/^:/, "").replace(/\*\??$/, ""));
+  return `view_${snake(words.join("_")) || "home"}`;
+}
+function discoverPages(root, entries, graph, load, actionFiles, formFiles, taken, snake) {
+  const hookCache = /* @__PURE__ */ new Map();
+  const hookNames = (file) => {
+    let names = hookCache.get(file);
+    if (!names) {
+      const source = read(root, file);
+      const program = source?.includes("useSearchParams") ? parseModule(source, file) : null;
+      names = program ? hookSearchParams(program) : [];
+      hookCache.set(file, names);
+    }
+    return names;
+  };
+  const used = new Set(taken);
+  const out = [];
+  for (const entry of [...entries].sort((a, b) => a.path.localeCompare(b.path))) {
+    const source = read(root, entry.file);
+    const program = source ? parseModule(source, entry.file) : null;
+    const reachable = graph.reachable([entry.file]);
+    const search = new Set(program ? pageSearchParams(program) : []);
+    for (const file of reachable) for (const n of hookNames(file)) search.add(n);
+    const meta = program ? staticMetadata(program) : {};
+    const hasForm = [...reachable].some((f) => formFiles.has(f));
+    const formOnly = hasForm && Boolean(program) && ![...reachable].some((f) => {
+      if (!/\.[jt]sx$/.test(f) && f !== entry.file) return false;
+      const prog = f === entry.file ? program : parseModule(read(root, f) ?? "", f);
+      return prog ? directive(prog) === void 0 && readsData(prog, f, load, actionFiles) : false;
+    });
+    let name = pageToolName(entry.path, snake);
+    for (let i = 2; used.has(name); i++) name = `${pageToolName(entry.path, snake)}_${i}`;
+    used.add(name);
+    out.push({
+      file: entry.file,
+      path: entry.path,
+      params: entry.params,
+      name,
+      search: [...search].filter((s) => !entry.params.includes(s)).sort(),
+      ...meta,
+      ...formOnly ? { formOnly: true } : {}
+    });
+  }
+  return out;
+}
+
+// src/resolve.ts
+var import_node_fs5 = require("fs");
+var import_node_path5 = require("path");
+var EXTENSIONS = [".ts", ".tsx", ".mts", ".js", ".jsx", ".mjs"];
+function readTsconfig(root) {
+  try {
+    const raw = (0, import_node_fs5.readFileSync)((0, import_node_path5.join)(root, "tsconfig.json"), "utf8").replace(/("(?:\\.|[^"\\])*")|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (_m, str2) => str2 ?? "").replace(/,(\s*[}\]])/g, "$1");
+    const options = JSON.parse(raw).compilerOptions ?? {};
+    return { ...options.baseUrl ? { baseUrl: options.baseUrl } : {}, ...options.paths ? { paths: options.paths } : {} };
+  } catch {
+    return {};
+  }
+}
+function asFile(path) {
+  const candidates = [path, ...EXTENSIONS.map((e) => path + e), ...EXTENSIONS.map((e) => (0, import_node_path5.join)(path, `index${e}`))];
+  if (/\.[mc]?jsx?$/.test(path)) candidates.push(...EXTENSIONS.map((e) => path.replace(/\.[mc]?jsx?$/, e)));
+  return candidates.find((c) => (0, import_node_fs5.existsSync)(c) && (0, import_node_fs5.statSync)(c).isFile());
+}
+function moduleLoader(root) {
+  const { baseUrl, paths } = readTsconfig(root);
+  const base = (0, import_node_path5.join)(root, baseUrl ?? ".");
+  const cache = /* @__PURE__ */ new Map();
+  const candidates = (specifier2, fromFile) => {
+    if (specifier2.startsWith(".")) return [(0, import_node_path5.resolve)(root, (0, import_node_path5.dirname)(fromFile), specifier2)];
+    for (const [pattern, targets] of Object.entries(paths ?? {})) {
+      const star = pattern.indexOf("*");
+      const prefix = star < 0 ? pattern : pattern.slice(0, star);
+      const suffix = star < 0 ? "" : pattern.slice(star + 1);
+      const matches = star < 0 ? specifier2 === pattern : specifier2.startsWith(prefix) && specifier2.endsWith(suffix) && specifier2.length >= prefix.length + suffix.length;
+      if (!matches) continue;
+      const middle = star < 0 ? "" : specifier2.slice(prefix.length, specifier2.length - suffix.length);
+      return targets.map((t) => (0, import_node_path5.join)(base, t.replace("*", middle)));
+    }
+    return baseUrl ? [(0, import_node_path5.join)(base, specifier2)] : [];
+  };
+  return (specifier2, fromFile) => {
+    const key = `${fromFile}\0${specifier2}`;
+    if (cache.has(key)) return cache.get(key);
+    let found;
+    for (const candidate of candidates(specifier2, fromFile)) {
+      const path = asFile(candidate);
+      const rel = path && (0, import_node_path5.relative)(root, path);
+      if (!path || !rel || rel.startsWith("..") || rel.split(import_node_path5.sep).includes("node_modules")) continue;
+      found = { file: rel.split(import_node_path5.sep).join("/"), source: (0, import_node_fs5.readFileSync)(path, "utf8") };
+      break;
+    }
+    cache.set(key, found);
+    return found;
+  };
+}
+
+// src/parse.ts
+var SOURCE_CAP = 6e3;
+var PACKAGES = /* @__PURE__ */ new Set(["@exposify/next", "@exposify/core"]);
+var METHOD_SET = new Set(HTTP_METHODS);
+var cap = (s) => s === void 0 ? void 0 : s.length > SOURCE_CAP ? `${s.slice(0, SOURCE_CAP)}
+/* \u2026 truncated */` : s;
+function ourImports(program) {
+  const locals = /* @__PURE__ */ new Map();
+  for (const stmt of program.body) {
+    if (stmt.type !== "ImportDeclaration" || !PACKAGES.has(stmt.source.value)) continue;
+    for (const spec of stmt.specifiers) {
+      if (spec.type === "ImportSpecifier") locals.set(spec.local.name, keyName(spec.imported) ?? spec.local.name);
+    }
+  }
+  return locals;
+}
+function writtenInput(n) {
+  n = unwrapTs(n);
+  if (n?.type !== "ObjectExpression") return "opaque";
+  const out = {};
+  for (const prop of n.properties) {
+    const key = prop.type === "ObjectProperty" ? keyName(prop.key) : void 0;
+    if (!key) continue;
+    let values;
+    walk(prop.value, (c) => {
+      if (values || c.type !== "CallExpression" || keyName(c.callee?.property) !== "enum") return;
+      const list = unwrapTs(c.arguments[0]);
+      const items = list?.type === "ArrayExpression" ? list.elements.map((e) => stringValue(e)) : [];
+      if (items.length > 0 && items.every((v) => v !== void 0)) values = items;
+    });
+    out[key] = values ? { enum: values } : {};
+  }
+  return out;
+}
+function markerOf(init, imports) {
+  const call = unwrapTs(init);
+  if (call?.type !== "CallExpression" || call.callee.type !== "Identifier") return { handler: call };
+  const imported = imports.get(call.callee.name);
+  if (imported !== "exposed" && imported !== "hidden" && imported !== "describe") return { handler: call };
+  const handler = call.arguments[0];
+  if (imported !== "describe") return { marker: { kind: imported }, handler };
+  const meta = call.arguments[1];
+  const marker = { kind: "described" };
+  if (meta?.type === "ObjectExpression") {
+    for (const prop of meta.properties) {
+      if (prop.type !== "ObjectProperty") continue;
+      const key = keyName(prop.key);
+      const value = stringValue(prop.value);
+      if (key === "name" && value) marker.name = value;
+      if (key === "description" && value) marker.description = value;
+      if (key === "input") marker.input = writtenInput(prop.value);
+    }
+  }
+  return { marker, handler };
+}
+function analyzeRouteModule(source, file) {
+  const out = { methods: [], edge: false, mcpRoute: false, markers: {}, sources: {} };
+  const program = parseModule(source, file);
+  if (!program) return out;
+  const imports = ourImports(program);
+  out.mcpRoute = [...imports.values()].includes("aiReady");
+  const found = /* @__PURE__ */ new Set();
+  const record = (name, init, whole) => {
+    if (!METHOD_SET.has(name)) return;
+    found.add(name);
+    const { marker, handler } = markerOf(init, imports);
+    if (marker) out.markers[name] = marker;
+    const src = cap(text(source, handler ?? whole));
+    if (src) out.sources[name] = src;
+  };
+  for (const stmt of program.body) {
+    if (stmt.type !== "ExportNamedDeclaration") continue;
+    const decl = stmt.declaration;
+    if (decl?.type === "FunctionDeclaration" && decl.id) record(decl.id.name, void 0, decl);
+    if (decl?.type === "VariableDeclaration") {
+      for (const d of decl.declarations) {
+        if (d.id.type === "Identifier") {
+          record(d.id.name, d.init, d.init);
+          if (d.id.name === "runtime" && stringValue(d.init) === "edge") out.edge = true;
+        } else if (d.id.type === "ObjectPattern") {
+          for (const p of d.id.properties) if (p.type === "ObjectProperty" && p.value.type === "Identifier") record(p.value.name);
+        }
+      }
+    }
+    for (const spec of stmt.specifiers ?? []) {
+      const exported = keyName(spec.exported);
+      if (exported) record(exported);
+    }
+  }
+  out.methods = HTTP_METHODS.filter((m) => found.has(m));
+  return out;
+}
+function detectPagesMethods(source, file) {
+  const program = parseModule(source, file);
+  if (!program) return null;
+  const usesNextConnect = program.body.some((s) => s.type === "ImportDeclaration" && s.source.value === "next-connect");
+  if (usesNextConnect) {
+    const methods2 = /* @__PURE__ */ new Set();
+    walk(program, (n) => {
+      if (n.type !== "CallExpression" || n.callee.type !== "MemberExpression") return;
+      const name = keyName(n.callee.property)?.toUpperCase();
+      if (name && METHOD_SET.has(name) && name !== "OPTIONS") methods2.add(name);
+    });
+    if (methods2.size > 0) return { methods: HTTP_METHODS.filter((m) => methods2.has(m)), via: "next-connect" };
+  }
+  const aliases = /* @__PURE__ */ new Set();
+  walk(program, (n) => {
+    if (n.type !== "VariableDeclarator") return;
+    if (n.id.type === "ObjectPattern" && n.init?.type === "Identifier") {
+      for (const p of n.id.properties) if (p.type === "ObjectProperty" && keyName(p.key) === "method" && p.value.type === "Identifier") aliases.add(p.value.name);
+    }
+    if (n.id.type === "Identifier" && isReqMethod(n.init, aliases)) aliases.add(n.id.name);
+  });
+  const methods = /* @__PURE__ */ new Set();
+  let via = "if";
+  const add = (value) => {
+    const m = value?.toUpperCase();
+    if (m && METHOD_SET.has(m)) methods.add(m);
+  };
+  walk(program, (n) => {
+    if (n.type === "BinaryExpression" && ["===", "==", "!==", "!="].includes(n.operator)) {
+      if (isReqMethod(n.left, aliases)) add(stringValue(n.right));
+      else if (isReqMethod(n.right, aliases)) add(stringValue(n.left));
+    } else if (n.type === "SwitchStatement" && isReqMethod(n.discriminant, aliases)) {
+      for (const c of n.cases) add(stringValue(c.test));
+      if (methods.size > 0) via = "switch";
+    } else if (n.type === "CallExpression" && n.callee.type === "MemberExpression" && keyName(n.callee.property) === "includes" && n.callee.object.type === "ArrayExpression" && isReqMethod(n.arguments[0], aliases)) {
+      for (const el of n.callee.object.elements) add(stringValue(el));
+    }
+  });
+  methods.delete("OPTIONS");
+  return methods.size > 0 ? { methods: HTTP_METHODS.filter((m) => methods.has(m)), via } : null;
+}
+function isReqMethod(n, aliases) {
+  n = unwrapTs(n);
+  if (!n) return false;
+  if (n.type === "Identifier") return aliases.has(n.name);
+  if (n.type === "OptionalMemberExpression" || n.type === "MemberExpression") return keyName(n.property) === "method" && !n.computed;
+  return false;
+}
+function defaultExportSource(source, file) {
+  const program = parseModule(source, file);
+  const stmt = program?.body?.find((s) => s.type === "ExportDefaultDeclaration");
+  if (!stmt) return void 0;
+  let decl = stmt.declaration;
+  if (decl.type === "Identifier") {
+    for (const s of program.body) {
+      const d = s.type === "ExportNamedDeclaration" ? s.declaration : s;
+      if (d?.type === "FunctionDeclaration" && d.id?.name === decl.name) return cap(text(source, d));
+      if (d?.type === "VariableDeclaration") {
+        const v = d.declarations.find((x) => x.id.type === "Identifier" && x.id.name === decl.name);
+        if (v) return cap(text(source, v.init));
+      }
+    }
+  }
+  return cap(text(source, decl));
+}
+var FORM_READS2 = /* @__PURE__ */ new Set(["get", "getAll", "has"]);
+var PREV_STATE_NAME = /^_*(prev|previous|state|prevState|previousState|initialState|currentState)?$/i;
+var SEARCH_DEPTH2 = 3;
+function isActionModule(program) {
+  return program.directives?.[0]?.value?.value === "use server";
+}
+function localFunctions(program, imports) {
+  const out = /* @__PURE__ */ new Map();
+  for (const stmt of program.body) {
+    const decl = stmt.type === "ExportNamedDeclaration" ? stmt.declaration : stmt;
+    if (decl?.type === "FunctionDeclaration" && decl.id) out.set(decl.id.name, { fn: decl });
+    if (decl?.type === "VariableDeclaration") {
+      for (const d of decl.declarations) {
+        if (d.id.type !== "Identifier") continue;
+        const { handler } = markerOf(d.init, imports);
+        const fn = unwrapTs(handler);
+        if (fn && FUNCTION_TYPES.has(fn.type)) out.set(d.id.name, { fn, init: d.init });
+      }
+    }
+  }
+  return out;
+}
+var typedFormData = (p) => {
+  const id = p.type === "AssignmentPattern" ? p.left : p;
+  const t = id?.typeAnnotation?.typeAnnotation;
+  return t?.type === "TSTypeReference" && t.typeName?.type === "Identifier" && t.typeName.name === "FormData";
+};
+function references(body, name) {
+  let count = 0;
+  walk(body, (n) => {
+    if (n.type === "Identifier" && n.name === name) count++;
+    if ((n.type === "MemberExpression" || n.type === "OptionalMemberExpression") && !n.computed && n.property.type === "Identifier" && n.property.name === name) count--;
+    if (n.type === "ObjectProperty" && !n.computed && !n.shorthand && n.key.type === "Identifier" && n.key.name === name) count--;
+  });
+  return count;
+}
+function readsForm(body, name) {
+  let found = false;
+  walk(body, (n) => {
+    if (found || n.type !== "CallExpression") return;
+    const callee = n.callee;
+    if (callee.type !== "MemberExpression" || callee.object.type !== "Identifier" || callee.object.name !== name) return;
+    const method = keyName(callee.property);
+    if (method && FORM_READS2.has(method) && stringValue(n.arguments[0]) !== void 0) found = true;
+  });
+  return found;
+}
+function actionParams(fn, shape) {
+  const raw = fn.params.filter((p) => p.type !== "RestElement");
+  if (shape) {
+    const formIndex2 = shape.bound + (shape.prev ? 1 : 0);
+    return raw.map((p, i) => {
+      const name = paramName(p) ?? `arg${i}`;
+      if (i < shape.bound) return { name, role: "input" };
+      if (i === formIndex2) return { name, role: "formData" };
+      if (shape.prev && i === shape.bound) return { name, role: "prev" };
+      return { name, role: "input" };
+    });
+  }
+  let formIndex = raw.findIndex(typedFormData);
+  if (formIndex < 0) formIndex = raw.findIndex((p) => {
+    const name = paramName(p);
+    return name !== void 0 && readsForm(fn.body, name);
+  });
+  return raw.map((p, i) => {
+    const name = paramName(p) ?? `arg${i}`;
+    if (i === formIndex) return { name, role: "formData" };
+    if (p.type === "ObjectPattern" || p.type === "AssignmentPattern" && p.left.type === "ObjectPattern") return { name: "input", role: "object" };
+    if (formIndex === 1 && i === 0 && (PREV_STATE_NAME.test(name) || references(fn.body, name) === 0)) return { name, role: "prev" };
+    return { name, role: "input" };
+  });
+}
+function setsCookies(fn, program, functions) {
+  const cookiesLocal = program.body.filter((s) => s.type === "ImportDeclaration" && s.source.value === "next/headers").flatMap((s) => s.specifiers).find((s) => s.type === "ImportSpecifier" && keyName(s.imported) === "cookies")?.local?.name;
+  if (!cookiesLocal) return false;
+  const isCookiesCall = (n) => {
+    n = unwrapTs(n);
+    if (n?.type === "AwaitExpression") n = unwrapTs(n.argument);
+    return n?.type === "CallExpression" && n.callee.type === "Identifier" && n.callee.name === cookiesLocal;
+  };
+  const visited = /* @__PURE__ */ new Set();
+  const search = (f, depth) => {
+    if (visited.has(f) || depth > SEARCH_DEPTH2) return false;
+    visited.add(f);
+    const jars = /* @__PURE__ */ new Set();
+    walk(f.body, (n) => {
+      if (n.type === "VariableDeclarator" && n.id.type === "Identifier" && isCookiesCall(n.init)) jars.add(n.id.name);
+    });
+    let found = false;
+    const callees = [];
+    walk(f.body, (n) => {
+      if (found || n.type !== "CallExpression") return;
+      const callee = n.callee;
+      if (callee.type === "Identifier") callees.push(callee.name);
+      if (callee.type !== "MemberExpression" || !["set", "delete"].includes(keyName(callee.property) ?? "")) return;
+      const target = unwrapTs(callee.object);
+      if (isCookiesCall(target) || target?.type === "Identifier" && jars.has(target.name)) found = true;
+    });
+    if (found) return true;
+    return callees.some((name) => {
+      const local = functions.get(name);
+      return local !== void 0 && search(local.fn, depth + 1);
+    });
+  };
+  return search(fn, 0);
+}
+function analyzeActionModule(source, file, load, shapes) {
+  const program = parseModule(source, file);
+  if (!program || !isActionModule(program)) return null;
+  const imports = ourImports(program);
+  const functions = localFunctions(program, imports);
+  const topLevel = new Map([...functions].map(([name, f]) => [name, f.fn]));
+  const out = [];
+  const record = (name, at, local) => {
+    const line = lineOf(at);
+    if (!local) {
+      out.push({ name, line, params: [], setsCookies: false, resolved: false, fields: [], readsAll: false, unresolved: [`line ${line}: it's defined in another module, so its code wasn't read`] });
+      return;
+    }
+    const { marker } = markerOf(local.init, imports);
+    const src = cap(text(source, local.fn));
+    const params = actionParams(local.fn, shapes?.get(name));
+    out.push({
+      name,
+      line,
+      params,
+      ...analyzeFields(local.fn, params, { program, source, file, topLevel, ...load ? { load } : {} }),
+      setsCookies: setsCookies(local.fn, program, functions),
+      resolved: true,
+      ...marker ? { marker } : {},
+      ...src ? { source: src } : {}
+    });
+  };
+  for (const stmt of program.body) {
+    if (stmt.type === "ExportDefaultDeclaration") {
+      const decl2 = stmt.declaration;
+      if (FUNCTION_TYPES.has(decl2.type)) record("default", stmt, { fn: decl2 });
+      else if (decl2.type === "Identifier") record("default", stmt, functions.get(decl2.name));
+      else {
+        const fn = unwrapTs(markerOf(decl2, imports).handler);
+        record("default", stmt, fn && FUNCTION_TYPES.has(fn.type) ? { fn, init: decl2 } : void 0);
+      }
+      continue;
+    }
+    if (stmt.type !== "ExportNamedDeclaration") continue;
+    if (stmt.exportKind === "type") continue;
+    const decl = stmt.declaration;
+    if (decl?.type === "FunctionDeclaration" && decl.id) record(decl.id.name, decl, functions.get(decl.id.name));
+    if (decl?.type === "VariableDeclaration") {
+      for (const d of decl.declarations) if (d.id.type === "Identifier") record(d.id.name, d, functions.get(d.id.name));
+    }
+    for (const spec of stmt.specifiers ?? []) {
+      if (spec.type !== "ExportSpecifier" || spec.exportKind === "type") continue;
+      const exported = keyName(spec.exported);
+      if (!exported) continue;
+      record(exported, spec, stmt.source ? void 0 : functions.get(spec.local.name));
+    }
+  }
+  return out;
+}
+function findInlineActions(source, file) {
+  const program = parseModule(source, file);
+  if (!program) return [];
+  const out = [];
+  const named2 = /* @__PURE__ */ new Map();
+  walk(program, (n) => {
+    if (n.type === "VariableDeclarator" && n.id.type === "Identifier" && n.init) named2.set(unwrapTs(n.init), n.id.name);
+    if (!FUNCTION_TYPES.has(n.type) || n.body?.type !== "BlockStatement") return;
+    if (!n.body.directives.some((d) => d.value?.value === "use server")) return;
+    if (isActionModule(program) && program.body.some((s) => s === n || s.declaration === n || s.declaration?.declarations?.some((d) => unwrapTs(d.init) === n))) return;
+    const name = n.id?.name ?? named2.get(n);
+    out.push({ ...name ? { name } : {}, line: n.loc?.start.line ?? 1 });
+  });
+  return out;
+}
+
+// src/codegen.ts
+var DEFAULT_DOCS = ["README.md", "docs/**/*.md"];
+var actionRoute = (mcpPath, key) => `POST ${(mcpPath ?? "/mcp").replace(/\/$/, "")}/actions/${key}`;
+function actionSignature(route, source) {
+  const [method, path] = route.split(" ");
+  return (0, import_node_crypto.createHash)("sha256").update(JSON.stringify([method, path, [], source ?? ""])).digest("hex").slice(0, 16);
+}
+var posix = (p) => p.split(import_node_path6.sep).join("/");
+function firstDir(root, names) {
+  return names.find((n) => (0, import_node_fs6.existsSync)((0, import_node_path6.join)(root, n)));
+}
+function filesUnder(root, dir) {
+  const out = [];
+  const visit = (rel) => {
+    let entries;
+    try {
+      entries = (0, import_node_fs6.readdirSync)((0, import_node_path6.join)(root, rel), { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.name === "node_modules") continue;
+      const child = `${rel}/${e.name}`;
+      if (e.isDirectory()) visit(child);
+      else out.push(child);
+    }
+  };
+  visit(dir);
+  return out.sort();
+}
+function discover(root, opts = {}) {
+  const exts = opts.pageExtensions ?? DEFAULT_PAGE_EXTENSIONS;
+  const extPattern = new RegExp(`\\.(${exts.map((e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})$`);
+  const appDir = firstDir(root, ["app", "src/app"]);
+  const pagesDir = firstDir(root, ["pages", "src/pages"]);
+  const out = { root, routes: [], actions: [], inlineActions: [], pages: [], ...appDir ? { appDir } : {}, ...pagesDir ? { pagesDir } : {} };
+  if (appDir) {
+    for (const file of filesUnder(root, appDir)) {
+      const name = file.slice(file.lastIndexOf("/") + 1);
+      if (!/^route\./.test(name) || !extPattern.test(name)) continue;
+      const dirSegs = file.slice(appDir.length + 1).split("/").slice(0, -1);
+      const route = appRoute(dirSegs);
+      if (!route) continue;
+      const source = (0, import_node_fs6.readFileSync)((0, import_node_path6.join)(root, file), "utf8");
+      const module2 = analyzeRouteModule(source, file);
+      if (module2.mcpRoute) {
+        out.mcpRoute ??= { file, source };
+        continue;
+      }
+      if (module2.methods.length === 0) continue;
+      out.routes.push({ router: "app", file, ...route, module: module2 });
+    }
+  }
+  if (pagesDir) {
+    for (const file of filesUnder(root, `${pagesDir}/api`)) {
+      if (!extPattern.test(file) || /\.d\.ts$/.test(file)) continue;
+      const segs = file.slice(pagesDir.length + 1).replace(extPattern, "").split("/");
+      const route = pagesApiRoute(segs);
+      if (!route) continue;
+      const source = (0, import_node_fs6.readFileSync)((0, import_node_path6.join)(root, file), "utf8");
+      const src = defaultExportSource(source, file);
+      out.routes.push({ router: "pages", file, ...route, detected: detectPagesMethods(source, file), ...src ? { source: src } : {} });
+    }
+  }
+  out.routes.sort((a, b) => a.path.localeCompare(b.path) || a.file.localeCompare(b.file));
+  if (appDir && out.mcpRoute) {
+    const segs = out.mcpRoute.file.slice(appDir.length + 1).split("/").slice(0, -1);
+    const route = appRoute(segs);
+    const catchAll = route ? /^(.*)\/:[A-Za-z0-9_]+\*\??$/.exec(route.path) : null;
+    if (catchAll) out.mcpPath = catchAll[1] || "/";
+  }
+  discoverActions(root, out, exts);
+  const found = findLogin(out);
+  if (found) {
+    out.login = found.login;
+    out.loginOthers = found.others;
+  }
+  return out;
+}
+var SOURCE_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs}";
+var NOT_SOURCE = ["**/node_modules/**", ".next/**", "out/**", "build/**", "dist/**", "coverage/**", "**/*.d.ts"];
+function snakeCase(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+}
+function discoverActions(root, out, exts) {
+  const files = (0, import_tinyglobby.globSync)(SOURCE_GLOB, { cwd: root, ignore: NOT_SOURCE }).sort();
+  const load = moduleLoader(root);
+  const modules = [];
+  const components = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    let source;
+    try {
+      source = (0, import_node_fs6.readFileSync)((0, import_node_path6.join)(root, file), "utf8");
+    } catch {
+      continue;
+    }
+    if (/\.[jt]sx$/.test(file)) components.set(file, source);
+    if (!source.includes("use server")) continue;
+    const actions = analyzeActionModule(source, file, load);
+    if (actions) modules.push({ file, source, actions });
+    for (const inline of findInlineActions(source, file)) out.inlineActions.push({ file, ...inline });
+  }
+  const exportsByFile = new Map(modules.map((m) => [m.file, new Set(m.actions.map((a) => a.name))]));
+  const names = [...new Set(modules.flatMap((m) => m.actions.map((a) => a.name)))];
+  const uses = [];
+  const ctx = { load, modules: /* @__PURE__ */ new Map() };
+  for (const [file, source] of components) {
+    if (names.some((n) => source.includes(n === "default" ? "import" : n))) uses.push(...findFormUses(source, file, exportsByFile, load, ctx));
+  }
+  const found = [];
+  for (const m of modules) {
+    const mine = uses.filter((u) => u.action.file === m.file);
+    const shapes = /* @__PURE__ */ new Map();
+    for (const u of mine) if (!shapes.has(u.action.export)) shapes.set(u.action.export, { bound: u.bound, prev: u.prev });
+    const actions = shapes.size > 0 ? analyzeActionModule(m.source, m.file, load, shapes) ?? m.actions : m.actions;
+    for (const action of actions) found.push({ file: m.file, action: linkForms(action, mine.filter((u) => u.action.export === action.name)) });
+  }
+  const pages = out.appDir ? pageEntries(out.appDir, files, exts) : [];
+  const graph = moduleGraph(root, load);
+  const hosts = actionHosts(pages, graph, exportsByFile);
+  const proposals = readProposedInputs(root);
+  const stem = (file) => snakeCase(file.slice(file.lastIndexOf("/") + 1).replace(/\.[^.]+$/, ""));
+  const base = (f) => (f.action.name === "default" ? stem(f.file) : snakeCase(f.action.name)) || "action";
+  const counts = /* @__PURE__ */ new Map();
+  for (const f of found) counts.set(base(f), (counts.get(base(f)) ?? 0) + 1);
+  const taken = /* @__PURE__ */ new Set();
+  for (const f of found) {
+    let key = base(f);
+    if (counts.get(key) > 1 && f.action.name !== "default") key = `${stem(f.file)}_${key}`;
+    let candidate = key;
+    for (let i = 2; taken.has(candidate); i++) candidate = `${key}_${i}`;
+    taken.add(candidate);
+    const route = actionRoute(out.mcpPath, candidate);
+    const entry = proposals[route];
+    const proposed = entry ? { fields: entry.fields, status: entry.signature === actionSignature(route, f.action.source) ? "current" : "stale" } : void 0;
+    const host = hosts.get(`${f.file}#${f.action.name}`);
+    out.actions.push({ ...f, key: candidate, ...proposed ? { proposed } : {}, ...host ? { host } : {} });
+  }
+  out.pages = discoverPages(root, pages, graph, load, new Set(modules.map((m) => m.file)), new Set(uses.map((u) => u.file)), new Set(out.actions.map((a) => a.key)), snakeCase);
+  const guards = guardFinder(root, load);
+  const rootsOf = new Map(pages.map((p) => [p.file, p.roots]));
+  for (const page of out.pages) {
+    const found2 = guards.page(rootsOf.get(page.file) ?? [page.file]);
+    if (found2.length > 0) page.guards = found2;
+  }
+  for (const a of out.actions) {
+    const found2 = guards.action(a.file, a.action.name);
+    if (found2.length > 0) a.guards = found2;
+  }
+}
+function readJson(path) {
+  try {
+    return JSON.parse((0, import_node_fs6.readFileSync)(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function readProposedInputs(root) {
+  const path = (0, import_node_path6.join)(root, import_core2.DESCRIPTIONS_FILE);
+  if (!(0, import_node_fs6.existsSync)(path)) return {};
+  const parsed = (0, import_core2.parseDescriptions)((0, import_node_fs6.readFileSync)(path, "utf8"));
+  return typeof parsed === "string" ? {} : parsed.inputs ?? {};
+}
+function readDescriptions(root, warn) {
+  const path = (0, import_node_path6.join)(root, import_core2.DESCRIPTIONS_FILE);
+  if (!(0, import_node_fs6.existsSync)(path)) return {};
+  const parsed = (0, import_core2.parseDescriptions)((0, import_node_fs6.readFileSync)(path, "utf8"));
+  if (typeof parsed === "string") {
+    warn(`ignoring ${import_core2.DESCRIPTIONS_FILE}: ${parsed}`);
+    return {};
+  }
+  return Object.fromEntries(Object.entries(parsed.descriptions).map(([k, e]) => [k, e.text.trim()]));
+}
+function readDocs(root, globs) {
+  const paths = (0, import_tinyglobby.globSync)(globs, { cwd: root, ignore: ["**/node_modules/**", ".next/**"] }).sort();
+  const docs = [];
+  for (const path of paths) {
+    try {
+      docs.push({ path, content: (0, import_node_fs6.readFileSync)((0, import_node_path6.join)(root, path), "utf8") });
+    } catch {
+    }
+  }
+  return docs;
+}
+function defaultOutFile(root) {
+  return (0, import_node_fs6.existsSync)((0, import_node_path6.join)(root, "tsconfig.json")) ? "exposify.generated.ts" : "exposify.generated.js";
+}
+function specifier(outFile, file) {
+  const rel = posix((0, import_node_path6.relative)((0, import_node_path6.dirname)(outFile), file)).replace(/\.[^./]+$/, "");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function manifestLogin(l) {
+  return l.kind === "action" ? { kind: "action", key: l.key, fields: l.fields, ...l.host ? { host: l.host } : {}, where: `${l.export} in ${l.file}` } : { kind: "route", path: l.path, fields: l.fields, body: l.body, where: `POST ${l.path} in ${l.file}` };
+}
+function renderManifest(d, opts) {
+  const ts = opts.outFile.endsWith(".ts");
+  const j = (v) => JSON.stringify(v);
+  const routes = d.routes.map((r) => {
+    const common = `router: ${j(r.router)}, path: ${j(r.path)}, params: ${j(r.params)}, file: ${j(r.file)}`;
+    if (r.router === "pages") return `    { ${common} },`;
+    const methods = `methods: ${j(r.module.methods)}`;
+    if (r.module.edge) return `    { ${common}, ${methods}, edge: true },`;
+    return `    { ${common}, ${methods}, load: () => import(${j(specifier(opts.outFile, r.file))}) },`;
+  });
+  const actions = d.actions.map(({ file, key, action, proposed, host, guards }) => {
+    const flags = [
+      action.setsCookies ? ", setsCookies: true" : "",
+      `, fields: ${j(action.fields)}`,
+      action.readsAll ? ", readsAll: true" : "",
+      action.unresolved.length > 0 ? `, unresolved: ${j(action.unresolved)}` : "",
+      action.forms && action.forms.length > 0 ? `, forms: ${j(action.forms)}` : "",
+      proposed?.status === "current" ? `, proposed: ${j(proposed.fields)}` : "",
+      host ? `, host: ${j(host)}` : "",
+      guards ? `, guards: ${j(guards)}` : ""
+    ].join("");
+    return `    { key: ${j(key)}, file: ${j(file)}, export: ${j(action.name)}, params: ${j(action.params)}${flags}, load: () => import(${j(specifier(opts.outFile, file))}) },`;
+  });
+  const pages = d.pages.map((p) => {
+    const extra = [
+      p.search.length > 0 ? `, search: ${j(p.search)}` : "",
+      p.title ? `, title: ${j(p.title)}` : "",
+      p.description ? `, description: ${j(p.description)}` : "",
+      p.formOnly ? ", formOnly: true" : "",
+      p.guards ? `, guards: ${j(p.guards)}` : ""
+    ].join("");
+    return `    { name: ${j(p.name)}, path: ${j(p.path)}, params: ${j(p.params)}, file: ${j(p.file)}${extra} },`;
+  });
+  const lines = [
+    "// Generated by exposify-next from your route files. Don't edit: withExposify()",
+    "// in next.config regenerates it on `next dev` and `next build`, or run",
+    "// `npx exposify-next generate`.",
+    "/* eslint-disable */",
+    ...ts ? ['import type { ExposifyManifest } from "@exposify/next";', ""] : ["", '/** @type {import("@exposify/next").ExposifyManifest} */'],
+    `export const exposify${ts ? ": ExposifyManifest" : ""} = {`,
+    `  info: ${j(opts.info)},`,
+    ...opts.basePath ? [`  basePath: ${j(opts.basePath)},`] : [],
+    ...opts.trailingSlash ? ["  trailingSlash: true,"] : [],
+    ...d.mcpPath && (actions.length > 0 || d.login) ? [`  mcpPath: ${j(d.mcpPath)},`] : [],
+    "  routes: [",
+    ...routes,
+    "  ],",
+    ...actions.length > 0 ? ["  actions: [", ...actions, "  ],"] : [],
+    ...pages.length > 0 ? ["  pages: [", ...pages, "  ],"] : [],
+    ...d.login ? [`  login: ${j(manifestLogin(d.login))},`] : [],
+    ...opts.authStacks?.length ? [`  authStacks: ${j(opts.authStacks)},`] : [],
+    `  docs: ${j(opts.docs)},`,
+    ...Object.keys(opts.descriptions).length > 0 ? [`  descriptions: ${JSON.stringify(opts.descriptions, null, 2).replace(/\n/g, "\n  ")},`] : [],
+    "};",
+    ""
+  ];
+  return lines.join("\n");
+}
+function generate(root, opts = {}, warn = (m) => console.warn(`[exposify] ${m}`)) {
+  const outFile = opts.out ?? defaultOutFile(root);
+  const discovery = discover(root, opts);
+  const pkg = readJson((0, import_node_path6.join)(root, "package.json"));
+  const info = { name: typeof pkg?.name === "string" ? pkg.name : "next-app", version: typeof pkg?.version === "string" ? pkg.version : "0.0.0" };
+  const content = renderManifest(discovery, {
+    outFile,
+    docs: readDocs(root, opts.docs ?? DEFAULT_DOCS),
+    descriptions: readDescriptions(root, warn),
+    info,
+    ...opts.basePath ? { basePath: opts.basePath } : {},
+    ...opts.trailingSlash ? { trailingSlash: true } : {},
+    authStacks: (0, import_core2.authStacksOf)((0, import_core2.dependencyNames)(pkg)).map((s) => s.pkg)
+  });
+  for (const a of discovery.actions.filter((x) => x.proposed?.status === "stale")) {
+    warn(`the input accepted for the ${a.action.name} server action (${a.file}) is out of date, since the action changed: it's not used until \`exposify-next describe\` reviews it again`);
+  }
+  if (discovery.actions.length > 0 && !discovery.mcpPath) {
+    warn(
+      discovery.mcpRoute ? `found ${discovery.actions.length} Server Action(s), but the MCP route (${discovery.mcpRoute.file}) isn't a catch-all route, which they're served under: move it to app/mcp/[[...transport]]/route.ts` : `found ${discovery.actions.length} Server Action(s), but no MCP route to serve them under: create app/mcp/[[...transport]]/route.ts (npx exposify-next setup)`
+    );
+  }
+  const file = (0, import_node_path6.join)(root, outFile);
+  let current;
+  try {
+    current = (0, import_node_fs6.readFileSync)(file, "utf8");
+  } catch {
+    current = void 0;
+  }
+  if (current !== content) (0, import_node_fs6.writeFileSync)(file, content);
+  return { file, changed: current !== content, discovery };
+}
+
+// src/config.ts
+var PHASE_DEV = "phase-development-server";
+var PHASE_BUILD = "phase-production-build";
+var WATCHING = /* @__PURE__ */ Symbol.for("exposify.next.watching");
+function withExposify(nextConfig = {}, options = {}) {
+  return async (phase, ctx) => {
+    const config = typeof nextConfig === "function" ? await nextConfig(phase, ctx) : nextConfig;
+    if (phase !== PHASE_DEV && phase !== PHASE_BUILD) return config;
+    const root = options.root ?? process.cwd();
+    const c = config;
+    const opts = {
+      ...options.out ? { out: options.out } : {},
+      ...options.docs ? { docs: options.docs } : {},
+      ...c.pageExtensions ? { pageExtensions: c.pageExtensions } : {},
+      ...c.basePath ? { basePath: c.basePath } : {},
+      ...c.trailingSlash ? { trailingSlash: true } : {}
+    };
+    const run = () => {
+      try {
+        generate(root, opts);
+      } catch (err) {
+        console.error(`[exposify] couldn't generate the route table: ${err.message}`);
+      }
+    };
+    run();
+    if (phase === PHASE_DEV) watchRoutes(root, run);
+    return config;
+  };
+}
+function watchRoutes(root, run) {
+  const g = globalThis;
+  if (g[WATCHING]) return;
+  g[WATCHING] = true;
+  let timer;
+  const schedule = () => {
+    clearTimeout(timer);
+    timer = setTimeout(run, 150);
+  };
+  for (const dir of ["app", "pages", "src", "lib", "actions", "server"]) {
+    if (!(0, import_node_fs7.existsSync)((0, import_node_path7.join)(root, dir))) continue;
+    try {
+      (0, import_node_fs7.watch)((0, import_node_path7.join)(root, dir), { recursive: true }, schedule).unref();
+    } catch {
+    }
+  }
+  try {
+    (0, import_node_fs7.watch)(root, (_event, name) => {
+      if (name === import_core3.DESCRIPTIONS_FILE) schedule();
+    }).unref();
+  } catch {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generate,
+  withExposify
+});