@exposify/next 0.0.0-stage → 0.0.2

package/dist/exposify-next.js

@@ -0,0 +1,2651 @@
+#!/usr/bin/env node
+
+// bin/exposify-next.ts
+import { relative as relative4 } from "path";
+import { runCli } from "@exposify/cli";
+
+// src/codegen.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync6, readdirSync, writeFileSync } from "fs";
+import { dirname as dirname2, join as join6, relative as relative2, sep as sep2 } from "path";
+import { DESCRIPTIONS_FILE, authStacksOf, dependencyNames, parseDescriptions } from "@exposify/core";
+import { globSync } from "tinyglobby";
+
+// src/ast.ts
+import { parse } from "@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 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 exports = target && actions.get(target.file);
+    if (!target || !exports) 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 && exports.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
+import { readFileSync } from "fs";
+import { join } from "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 = readFileSync(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
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { LOGIN_NAME, NOT_A_LOGIN, loginFields } from "@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 (NOT_A_LOGIN.test(a.key) || 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 = loginFields(a.action.fields.map((f) => f.name));
+  if (!fields) return null;
+  if (!a.action.setsCookies && !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 || NOT_A_LOGIN.test(r.path)) return null;
+  let source;
+  try {
+    source = readFileSync2(join2(root, r.file), "utf8");
+  } catch {
+    return null;
+  }
+  const read2 = routeBodyFields(source);
+  const fields = read2 ? loginFields(read2.fields) : null;
+  if (!read2 || !fields) return null;
+  if (!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) => 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) };
+}
+function loginLabel(l) {
+  return l.kind === "action" ? `server action ${l.export} (${l.file})` : `POST ${l.path} (${l.file})`;
+}
+
+// src/guards.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "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 exports = /* @__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") exports.set(decl.id.name, decl.id.name);
+    }
+    if (stmt.type === "ExportDefaultDeclaration") {
+      if (decl?.type === "FunctionDeclaration" && decl.id) exports.set("default", decl.id.name);
+      else if (fn(decl)) {
+        functions.set("default", decl);
+        exports.set("default", "default");
+      } else if (decl?.type === "Identifier") exports.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") exports.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) exports.set(exported, s.local.name);
+      }
+    }
+  }
+  return { program, imports, stops, functions, exports };
+}
+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 = readFileSync3(join3(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
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+var read = (root, file) => {
+  try {
+    return readFileSync4(join4(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
+import { existsSync, readFileSync as readFileSync5, statSync } from "fs";
+import { dirname, join as join5, relative, resolve, sep } from "path";
+var EXTENSIONS = [".ts", ".tsx", ".mts", ".js", ".jsx", ".mjs"];
+function readTsconfig(root) {
+  try {
+    const raw = readFileSync5(join5(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) => join5(path, `index${e}`))];
+  if (/\.[mc]?jsx?$/.test(path)) candidates.push(...EXTENSIONS.map((e) => path.replace(/\.[mc]?jsx?$/, e)));
+  return candidates.find((c) => existsSync(c) && statSync(c).isFile());
+}
+function moduleLoader(root) {
+  const { baseUrl, paths } = readTsconfig(root);
+  const base = join5(root, baseUrl ?? ".");
+  const cache = /* @__PURE__ */ new Map();
+  const candidates = (specifier2, fromFile) => {
+    if (specifier2.startsWith(".")) return [resolve(root, 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) => join5(base, t.replace("*", middle)));
+    }
+    return baseUrl ? [join5(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 && relative(root, path);
+      if (!path || !rel || rel.startsWith("..") || rel.split(sep).includes("node_modules")) continue;
+      found = { file: rel.split(sep).join("/"), source: readFileSync5(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;
+}
+function sourceAtColumn0(source, n) {
+  const raw = text(source, n) ?? "";
+  const column = n.loc?.start.column ?? 0;
+  return raw.split("\n").map((line, i) => i === 0 ? line : line.slice(Math.min(column, line.length - line.trimStart().length))).join("\n");
+}
+function findAiReadyCall(source, file) {
+  const program = parseModule(source, file);
+  if (!program) return null;
+  const local = [...ourImports(program)].find(([, imported]) => imported === "aiReady")?.[0];
+  if (!local) return null;
+  let found = null;
+  walk(program, (n) => {
+    if (found || n.type !== "CallExpression" || n.callee.type !== "Identifier" || n.callee.name !== local) return;
+    const call = { line: n.loc?.start.line ?? 1, otherKeys: [] };
+    const options = unwrapTs(n.arguments[1]);
+    if (options && options.type !== "ObjectExpression") call.otherKeys.push("(options variable)");
+    for (const prop of options?.type === "ObjectExpression" ? options.properties : []) {
+      const key = prop.type === "ObjectProperty" ? keyName(prop.key) : void 0;
+      if (!key) {
+        call.otherKeys.push("(spread)");
+        continue;
+      }
+      const value = unwrapTs(prop.value);
+      if (key === "expose" && stringValue(value) === "*") call.expose = "*";
+      else if ((key === "expose" || key === "exclude") && value?.type === "ArrayExpression") {
+        call[key] = value.elements.map((e) => stringValue(e)).filter((s) => s !== void 0);
+      } else if (key === "startupLog" && value?.type === "BooleanLiteral") call.startupLog = value.value;
+      else if (key === "actions") {
+        if (value?.type !== "ObjectExpression") call.actions = "opaque";
+        else {
+          const actions = {};
+          for (const entry of value.properties) {
+            const name = entry.type === "ObjectProperty" ? keyName(entry.key) : void 0;
+            if (!name) continue;
+            const conf = { source: sourceAtColumn0(source, entry) };
+            const body = unwrapTs(entry.value);
+            for (const p of body?.type === "ObjectExpression" ? body.properties : []) {
+              const k = p.type === "ObjectProperty" ? keyName(p.key) : void 0;
+              if (k === "name" && stringValue(p.value)) conf.name = stringValue(p.value);
+              if (k === "description" && stringValue(p.value)) conf.description = stringValue(p.value);
+              if (k === "input") conf.input = writtenInput(p.value);
+            }
+            actions[name] = conf;
+          }
+          call.actions = actions;
+        }
+      } else call.otherKeys.push(key);
+    }
+    found = call;
+  });
+  return found;
+}
+
+// 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 createHash("sha256").update(JSON.stringify([method, path, [], source ?? ""])).digest("hex").slice(0, 16);
+}
+var posix = (p) => p.split(sep2).join("/");
+function firstDir(root, names) {
+  return names.find((n) => existsSync2(join6(root, n)));
+}
+function filesUnder(root, dir) {
+  const out = [];
+  const visit = (rel) => {
+    let entries;
+    try {
+      entries = readdirSync(join6(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 = readFileSync6(join6(root, file), "utf8");
+      const module = analyzeRouteModule(source, file);
+      if (module.mcpRoute) {
+        out.mcpRoute ??= { file, source };
+        continue;
+      }
+      if (module.methods.length === 0) continue;
+      out.routes.push({ router: "app", file, ...route, module });
+    }
+  }
+  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 = readFileSync6(join6(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 = 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 = readFileSync6(join6(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(readFileSync6(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function readProposedInputs(root) {
+  const path = join6(root, DESCRIPTIONS_FILE);
+  if (!existsSync2(path)) return {};
+  const parsed = parseDescriptions(readFileSync6(path, "utf8"));
+  return typeof parsed === "string" ? {} : parsed.inputs ?? {};
+}
+function readDescriptions(root, warn) {
+  const path = join6(root, DESCRIPTIONS_FILE);
+  if (!existsSync2(path)) return {};
+  const parsed = parseDescriptions(readFileSync6(path, "utf8"));
+  if (typeof parsed === "string") {
+    warn(`ignoring ${DESCRIPTIONS_FILE}: ${parsed}`);
+    return {};
+  }
+  return Object.fromEntries(Object.entries(parsed.descriptions).map(([k, e]) => [k, e.text.trim()]));
+}
+function readDocs(root, globs) {
+  const paths = globSync(globs, { cwd: root, ignore: ["**/node_modules/**", ".next/**"] }).sort();
+  const docs = [];
+  for (const path of paths) {
+    try {
+      docs.push({ path, content: readFileSync6(join6(root, path), "utf8") });
+    } catch {
+    }
+  }
+  return docs;
+}
+function defaultOutFile(root) {
+  return existsSync2(join6(root, "tsconfig.json")) ? "exposify.generated.ts" : "exposify.generated.js";
+}
+function specifier(outFile, file) {
+  const rel = posix(relative2(dirname2(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(join6(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: authStacksOf(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 = join6(root, outFile);
+  let current;
+  try {
+    current = readFileSync6(file, "utf8");
+  } catch {
+    current = void 0;
+  }
+  if (current !== content) writeFileSync(file, content);
+  return { file, changed: current !== content, discovery };
+}
+
+// bin/adapter.ts
+import { existsSync as existsSync4, readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname4, join as join8, relative as relative3, resolve as resolve2 } from "path";
+import { decideExposure, deriveDescription, resolveOptions, toolNames } from "@exposify/core";
+import { renderConfig, replaceAiReadyOptions } from "@exposify/cli";
+
+// bin/actions.ts
+import { existsSync as existsSync3, readFileSync as readFileSync7 } from "fs";
+
+// src/inline.ts
+import { dirname as dirname3 } from "path";
+function patternNames(p, out = []) {
+  if (!p) return out;
+  if (p.type === "Identifier") out.push(p.name);
+  else if (p.type === "AssignmentPattern") patternNames(p.left, out);
+  else if (p.type === "RestElement") patternNames(p.argument, out);
+  else if (p.type === "ObjectPattern") for (const prop of p.properties) patternNames(prop.type === "RestElement" ? prop : prop.value, out);
+  else if (p.type === "ArrayPattern") for (const el of p.elements) patternNames(el ?? void 0, out);
+  else if (p.type === "TSParameterProperty") patternNames(p.parameter, out);
+  return out;
+}
+function declaredIn(scope, skip) {
+  const names = /* @__PURE__ */ new Set();
+  for (const p of scope.params ?? []) for (const n of patternNames(p)) names.add(n);
+  walk(scope.body, (n, parents) => {
+    if (skip && (n === skip || parents.includes(skip))) return;
+    if (n.type === "FunctionDeclaration" && n.id && !parents.some((p) => FUNCTION_TYPES.has(p.type))) names.add(n.id.name);
+    if (parents.some((p) => FUNCTION_TYPES.has(p.type))) return;
+    if (n.type === "VariableDeclarator") for (const name of patternNames(n.id)) names.add(name);
+  });
+  return names;
+}
+function readsIn(fn) {
+  const own = declaredIn(fn);
+  const out = [];
+  walk(fn.body, (n, parents) => {
+    if (n.type !== "Identifier") 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 && !p.shorthand) return;
+    if (p?.type === "VariableDeclarator" && p.id === n) return;
+    if (own.has(n.name) || out.includes(n.name)) return;
+    out.push(n.name);
+  });
+  return out;
+}
+var lowerFirst = (s) => s.charAt(0).toLowerCase() + s.slice(1);
+function suggestInlineMove(source, file, line) {
+  const program = parseModule(source, file);
+  if (!program) return void 0;
+  let fn;
+  let chain = [];
+  walk(program, (n, parents) => {
+    if (fn || !FUNCTION_TYPES.has(n.type) || n.body?.type !== "BlockStatement" || lineOf(n) !== line) return;
+    if (n.body.directives.some((d) => d.value?.value === "use server")) {
+      fn = n;
+      chain = [...parents];
+    }
+  });
+  if (!fn) return void 0;
+  const target = fn;
+  const parent = chain[chain.length - 1];
+  const declarator = parent?.type === "VariableDeclarator" && unwrapTs(parent.init) === target ? parent : void 0;
+  const component = [...chain].reverse().find((p) => FUNCTION_TYPES.has(p.type));
+  const componentName = component?.id?.name ?? [...chain].reverse().find((p) => p.type === "VariableDeclarator" && p.id.type === "Identifier")?.id?.name;
+  const name = target.id?.name ?? (declarator?.id.type === "Identifier" ? declarator.id.name : `${componentName ? lowerFirst(componentName) : "inline"}Action`);
+  const enclosing = /* @__PURE__ */ new Set();
+  for (const scope of chain.filter((p) => FUNCTION_TYPES.has(p.type))) for (const n of declaredIn(scope, target)) enclosing.add(n);
+  enclosing.delete(name);
+  const reads = readsIn(target);
+  const captured = reads.filter((n) => enclosing.has(n));
+  const imports = [];
+  const pageLocals = [];
+  for (const stmt of program.body) {
+    if (stmt.type === "ImportDeclaration") {
+      const used = stmt.specifiers.filter((s) => reads.includes(s.local.name));
+      if (used.length === 0) continue;
+      const named2 = used.filter((s) => s.type === "ImportSpecifier").map((s) => s.imported.name === s.local.name ? s.local.name : `${s.imported.name} as ${s.local.name}`);
+      const def = used.find((s) => s.type === "ImportDefaultSpecifier")?.local.name;
+      const ns = used.find((s) => s.type === "ImportNamespaceSpecifier")?.local.name;
+      const parts = [def, ns ? `* as ${ns}` : void 0, named2.length ? `{ ${named2.join(", ")} }` : void 0].filter(Boolean);
+      imports.push(`import ${parts.join(", ")} from ${JSON.stringify(stmt.source.value)};`);
+    } else {
+      const decl = stmt.type === "ExportNamedDeclaration" ? stmt.declaration : stmt;
+      const names = decl?.type === "VariableDeclaration" ? decl.declarations.flatMap((d) => patternNames(d.id)) : decl?.id ? [decl.id.name] : [];
+      for (const n of names) if (reads.includes(n) && n !== componentName) pageLocals.push(n);
+    }
+  }
+  const ext = /\.(t|j)sx?$/.exec(file)?.[1] === "j" ? "js" : "ts";
+  const dir = dirname3(file);
+  const newFile = `${dir === "." ? "" : `${dir}/`}actions.${ext}`;
+  const ownParams = target.params.map((p) => text(source, p) ?? paramName(p) ?? "arg");
+  const directive2 = target.body.directives.find((d) => d.value?.value === "use server");
+  const bodyText = source.slice(directive2.end, target.body.end - 1).replace(/^\s*\n/, "").replace(/\s+$/, "");
+  const bodyLines = bodyText.split("\n");
+  const indent = Math.min(...bodyLines.filter((l) => l.trim()).map((l) => l.length - l.trimStart().length), 99);
+  const body = bodyLines.map((l) => `  ${l.slice(Math.min(indent, l.length - l.trimStart().length))}`.trimEnd()).join("\n");
+  const asyncKw = target.async ? "async " : "";
+  const newLines = [
+    '"use server";',
+    ...imports,
+    "",
+    ...captured.length > 0 ? [`// TODO(exposify): this was only reachable for the ${captured.join(", ")} the page had loaded; check that the caller may act on ${captured.length === 1 ? "it" : "them"}, and add ${captured.length === 1 ? "its type" : "their types"}.`] : [],
+    ...pageLocals.map((n) => `// TODO(exposify): it uses ${n} from ${file}: move or import it.`),
+    `export ${asyncKw}function ${name}(${[...captured, ...ownParams].join(", ")}) {`,
+    ...body.split("\n"),
+    "}"
+  ];
+  const lines = source.split("\n");
+  const bound = captured.length > 0 ? `${name}.bind(null, ${captured.join(", ")})` : name;
+  const hunks = [];
+  const lastImport = program.body.filter((s) => s.type === "ImportDeclaration").pop();
+  const importAt = lastImport ? lastImport.loc.end.line : 0;
+  hunks.push({ at: importAt + 1, remove: [], add: [`import { ${name} } from "./actions";`] });
+  const removed = declarator ? chain[chain.length - 2] : target.type === "FunctionDeclaration" ? target : void 0;
+  if (removed) {
+    const from = lineOf(removed);
+    const to = removed.loc.end.line;
+    hunks.push({ at: from, remove: lines.slice(from - 1, to), add: [] });
+    if (captured.length > 0) {
+      const uses = /* @__PURE__ */ new Map();
+      walk(program, (n, parents) => {
+        if (n.type !== "Identifier" || n.name !== name || parents.includes(removed) || n === removed.id) return;
+        const at = lineOf(n);
+        const current = uses.get(at) ?? lines[at - 1];
+        uses.set(at, current.replace(new RegExp(`\\b${name}\\b(?!\\.bind)`), bound));
+      });
+      for (const [at, next] of uses) hunks.push({ at, remove: [lines[at - 1]], add: [next] });
+    }
+  } else {
+    const from = lineOf(target);
+    const to = target.loc.end.line;
+    const startCol = target.loc.start.column;
+    const endCol = target.loc.end.column;
+    const replaced = `${lines[from - 1].slice(0, startCol)}${bound}${lines[to - 1].slice(endCol)}`;
+    hunks.push({ at: from, remove: lines.slice(from - 1, to), add: [replaced] });
+  }
+  hunks.sort((a, b) => a.at - b.at);
+  const diff = [
+    "--- /dev/null",
+    `+++ ${newFile}  (or add to it, if it exists)`,
+    ...newLines.map((l) => `+${l}`),
+    `--- ${file}`,
+    `+++ ${file}`,
+    ...hunks.flatMap((h) => [`@@ line ${h.at} @@`, ...h.remove.map((l) => `-${l}`), ...h.add.map((l) => `+${l}`)])
+  ].join("\n");
+  return { name, captured, newFile, diff };
+}
+
+// bin/actions.ts
+import { join as join7 } from "path";
+
+// src/actions.ts
+var AUTH_LIKE = /^(log_?in|log_?out|sign_?in|sign_?out|sign_?up|register|authenticate)(_|$)/;
+var looksLikeAuth = (action) => Boolean(action.setsCookies) || AUTH_LIKE.test(action.key);
+function inputProblem(action) {
+  if (action.unresolved && action.unresolved.length > 0) return `its input couldn't all be worked out from its code (${action.unresolved.join("; ")})`;
+  if (action.readsAll && !action.forms?.length) return "it reads the whole form (Object.fromEntries or a loop over it) and no form that submits to it was found, so nothing says which fields exist";
+  const files = action.fields.filter((f) => f.type === "file").map((f) => f.name);
+  if (files.length > 0) return `it takes a file (${files.join(", ")}), which agents can't send yet`;
+  return void 0;
+}
+
+// bin/actions.ts
+var TODO = "// TODO(exposify):";
+var AUTH_NOTE = "looks like it signs people in or out: a cookie it sets lands on exposify's internal call, not on the agent's client";
+function zodFor(f) {
+  let base;
+  if (f.enum && f.enum.length > 0) base = `z.enum(${JSON.stringify(f.enum)})`;
+  else if (f.type === "number") base = `z.number()${f.min !== void 0 ? `.min(${f.min})` : ""}${f.max !== void 0 ? `.max(${f.max})` : ""}`;
+  else if (f.type === "boolean") base = "z.boolean()";
+  else if (f.type === "json") base = "z.unknown()";
+  else {
+    base = "z.string()";
+    if (f.minLength !== void 0) base += `.min(${f.minLength})`;
+    if (f.maxLength !== void 0) base += `.max(${f.maxLength})`;
+    if (f.pattern !== void 0) base += `.regex(/^(?:${f.pattern.replace(/\//g, "\\/")})$/)`;
+  }
+  if (f.array) base = `z.array(${base})`;
+  return f.required ? base : `${base}.optional()`;
+}
+var propKey = (name) => /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+var located = (file, item) => item.startsWith("line ") ? `${file}:${item.slice(5)}` : item;
+function stubFor(configKey, found, problem, auth) {
+  const a = found.action;
+  const key = propKey(configKey);
+  const authLine = auth ? [`  ${TODO} this ${AUTH_NOTE}.`] : [];
+  if (!problem) return auth ? [`${key}: {`, ...authLine, "},"].join("\n") : `${key}: true,`;
+  const lines = [`${key}: {`, ...authLine, "  input: {"];
+  for (const f of a.fields) {
+    if (f.type === "file") lines.push(`    ${TODO} ${f.name} is a file, which agents can't send yet: leave it out if the action works without it.`);
+    else lines.push(`    ${propKey(f.name)}: ${zodFor(f)},${f.type === "json" ? " // sent as JSON text" : ""}`);
+  }
+  for (const u of a.unresolved) lines.push(`    ${TODO} ${located(found.file, u)}`);
+  if (a.readsAll && !a.forms?.length) lines.push(`    ${TODO} it reads the whole form, and no form that submits to it was found: list the fields it expects.`);
+  lines.push("  },", "},");
+  return lines.join("\n");
+}
+function driftOf(name, written, fields, complete) {
+  if (!written || written === "opaque") return [];
+  const out = [];
+  for (const f of fields) {
+    if (f.type === "file" || f.name in written) continue;
+    out.push(f.origin === "form" ? `its form sends \`${f.name}\`, which its input doesn't list` : `${name} reads \`${f.name}\`, which its input doesn't list`);
+  }
+  for (const [k, w] of Object.entries(written)) {
+    const f = fields.find((x) => x.name === k);
+    if (!f) {
+      if (complete) out.push(`its input lists \`${k}\`, which neither ${name} nor its form reads`);
+      continue;
+    }
+    if (!w.enum || !f.enum) continue;
+    const quote = (vs) => vs.map((v) => `\`${v}\``).join(", ");
+    const gone = w.enum.filter((v) => !f.enum.includes(v));
+    const added = f.enum.filter((v) => !w.enum.includes(v));
+    if (gone.length > 0) out.push(`\`${k}\` option${gone.length === 1 ? "" : "s"} ${quote(gone)} ${gone.length === 1 ? "is" : "are"} no longer allowed by ${name} or its form`);
+    if (added.length > 0) out.push(`\`${k}\` can now also be ${quote(added)}, which its input doesn't allow`);
+  }
+  return out;
+}
+function formSources(root, forms) {
+  const files = [];
+  const sources = [];
+  for (const file of [...new Set(forms.map((f) => f.file))].slice(0, 2)) {
+    try {
+      const text2 = readFileSync7(join7(root, file), "utf8");
+      files.push(file);
+      sources.push(text2.length > 6e3 ? `${text2.slice(0, 6e3)}
+/* \u2026 truncated */` : text2);
+    } catch {
+    }
+  }
+  return { files, sources };
+}
+function crossCheck(root, d) {
+  const path = join7(root, ".next", "server", "server-reference-manifest.json");
+  if (!existsSync3(path)) return [];
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync7(path, "utf8"));
+  } catch {
+    return [];
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const section of ["node", "edge"]) {
+    for (const entry of Object.values(manifest[section] ?? {})) {
+      const { filename, exportedName } = entry;
+      if (!filename || !exportedName || exportedName.startsWith("$$RSC_SERVER_")) continue;
+      const known = d.actions.some((a) => (filename === a.file || filename.endsWith(`/${a.file}`)) && a.action.name === exportedName);
+      if (!known) out.add(`Next's last build has a Server Action ${exportedName} in ${filename} that the scan didn't find (exposify reads exports of files starting with "use server").`);
+    }
+  }
+  return [...out];
+}
+function scanActions(d, call, root, notes, suggestions = []) {
+  if (call?.actions === "opaque") notes.push("aiReady's actions option isn't an object literal: which actions it lists can't be read, so they show as not listed.");
+  const config = call?.actions && call.actions !== "opaque" ? call.actions : {};
+  const counts = /* @__PURE__ */ new Map();
+  for (const a of d.actions) counts.set(a.action.name, (counts.get(a.action.name) ?? 0) + 1);
+  const rows = d.actions.map((found) => {
+    const a = found.action;
+    const unique = counts.get(a.name) === 1 && a.name !== "default";
+    const configKey = unique ? a.name : found.key;
+    const conf = config[found.key] ?? (unique ? config[a.name] : void 0);
+    const marker = a.marker;
+    const written = conf?.input ?? (marker?.kind === "described" ? marker.input : void 0);
+    const view = { key: found.key, ...a.setsCookies ? { setsCookies: true } : {}, fields: a.fields, readsAll: a.readsAll, unresolved: a.unresolved, ...a.forms ? { forms: a.forms } : {} };
+    const problem = inputProblem(view);
+    const auth = looksLikeAuth(view);
+    const takesInput = a.params.some((p) => p.role !== "prev") || a.unresolved.length > 0;
+    const status = auth || a.fields.some((f) => f.type === "file") ? "flagged" : problem ? "partial" : "complete";
+    const route = actionRoute(d.mcpPath, found.key);
+    const files = a.fields.filter((f) => f.type === "file").map((f) => f.name);
+    const optedIn = marker?.kind !== "hidden" && Boolean(conf || marker);
+    const proposable = optedIn && !written && takesInput && Boolean(problem) && files.length === 0;
+    const accepted = proposable && found.proposed?.status === "current";
+    const formsSent = proposable && a.forms?.length ? formSources(root, a.forms) : void 0;
+    let exposed = false;
+    let reason;
+    if (marker?.kind === "hidden") reason = "hidden() in code";
+    else if (!conf && !marker) reason = "not listed in aiReady({ actions }) (actions are writes)";
+    else if (!written && takesInput && problem && !accepted) {
+      reason = `opted in, but hidden until its input is written: ${problem}${proposable ? `${found.proposed?.status === "stale" ? "; the input accepted for it is out of date" : ""} (\`describe\` can propose it)` : ""}`;
+    } else if (!d.mcpPath) reason = "can't be served: the MCP route isn't app/mcp/[[...transport]]/route.ts";
+    else {
+      exposed = true;
+      const how = conf ? "listed in aiReady({ actions })" : `${marker.kind === "described" ? "describe()" : `${marker.kind}()`} in code`;
+      const input = written ? "input written by hand" : accepted ? "input proposed by describe and accepted" : !takesInput ? "takes no input" : `input from its code${a.forms?.length ? " and form" : ""}`;
+      reason = `${how}; ${input}`;
+    }
+    const rowNotes = [];
+    for (const f of a.forms ?? []) rowNotes.push(`form: ${f.file}:${f.line}`);
+    if (takesInput && !a.forms?.length && a.fields.some((f) => f.origin !== "action" || !f.required)) rowNotes.push("no form found that submits to it: its form fields are all optional");
+    for (const u of a.unresolved) rowNotes.push(`can't tell: ${located(found.file, u)}`);
+    if (a.readsAll && !a.forms?.length) rowNotes.push("reads the whole form, and no form says which fields it gets");
+    if (files.length > 0) rowNotes.push(`takes a file (${files.join(", ")}), which agents can't send yet`);
+    if (auth) rowNotes.push(AUTH_NOTE);
+    return {
+      configKey,
+      export: a.name,
+      file: found.file,
+      line: a.line,
+      tool: conf?.name ?? (marker?.kind === "described" ? marker.name : void 0) ?? found.key,
+      route,
+      status,
+      notes: rowNotes,
+      ...marker ? { marker: marker.kind } : {},
+      exposed,
+      reason,
+      drift: driftOf(a.name, written, a.fields, !problem),
+      // An entry the app already has stays as written.
+      stub: conf ? `${conf.source.replace(/,\s*$/, "")},` : stubFor(configKey, found, problem, auth),
+      ...a.source ? { source: a.source } : {},
+      ...conf?.description ?? marker?.description ? { describedText: conf?.description ?? marker?.description } : {},
+      ...proposable ? {
+        proposal: {
+          status: found.proposed?.status ?? "needed",
+          ...formsSent?.files.length ? { formFiles: formsSent.files } : {},
+          request: {
+            name: a.name,
+            file: found.file,
+            ...a.source ? { source: a.source } : {},
+            ...formsSent?.sources.length ? { forms: formsSent.sources } : {},
+            fields: a.fields.map((f) => ({ name: f.name, type: f.type, ...f.required ? { required: true } : {}, ...f.enum ? { enum: f.enum } : {} })),
+            unresolved: a.unresolved.map((u) => located(found.file, u))
+          }
+        }
+      } : {}
+    };
+  });
+  for (const inline of d.inlineActions) {
+    let move;
+    try {
+      move = suggestInlineMove(readFileSync7(join7(root, inline.file), "utf8"), inline.file, inline.line);
+    } catch {
+      move = void 0;
+    }
+    notes.push(
+      `${inline.file}:${inline.line}: an inline "use server" function${inline.name ? ` (${inline.name})` : ""} can't be a tool: it closes over values from the render. Move it to a "use server" file to expose it${move ? " (setup prints the change)" : ""}.`
+    );
+    if (move) {
+      suggestions.push({
+        title: `Move the inline action at ${inline.file}:${inline.line} to ${move.newFile} as ${move.name}${move.captured.length ? `, passing ${move.captured.join(", ")} with .bind` : ""}:`,
+        diff: move.diff
+      });
+    }
+  }
+  notes.push(...crossCheck(root, d));
+  return rows;
+}
+
+// bin/adapter.ts
+var MCP_ROUTE_DIR = "mcp/[[...transport]]";
+function isNextProject(dir) {
+  try {
+    const pkg = JSON.parse(readFileSync8(join8(dir, "package.json"), "utf8"));
+    const hasNext = Boolean(pkg.dependencies?.next ?? pkg.devDependencies?.next);
+    return hasNext && ["app", "src/app", "pages", "src/pages"].some((d) => existsSync4(join8(dir, d)));
+  } catch {
+    return false;
+  }
+}
+function findNextRoot(start) {
+  for (let dir = start; ; dir = dirname4(dir)) {
+    if (isNextProject(dir)) return dir;
+    if (dirname4(dir) === dir) return void 0;
+  }
+}
+var nextAdapter = {
+  bin: "exposify-next",
+  entryExample: "apps/web",
+  entryHelp: "The Next.js project directory",
+  locate(cwd, entryFlag) {
+    const root = findNextRoot(entryFlag ? resolve2(cwd, entryFlag) : cwd);
+    return root ? { entry: root, root, via: "package.json" } : void 0;
+  },
+  async scan(location) {
+    try {
+      return { ok: true, result: scanProject(location.root) };
+    } catch (err) {
+      return { ok: false, error: err.message };
+    }
+  },
+  configStep({ result, config, current, root }) {
+    const d = discover(root);
+    const otherKeys = current?.otherKeys;
+    let options = renderConfig(config, otherKeys ? { otherKeys } : {}).replace(/^app\.use\(aiReady\(\)\);$/, "const handler = aiReady(exposify);").replace(/^app\.use\(aiReady\(\{/, "const handler = aiReady(exposify, {").replace(/\}\)\);$/, "});");
+    const entries = Object.fromEntries((config.actions ?? []).map((key) => [key, result.actions?.find((a) => a.configKey === key)?.stub ?? `${key}: true,`]));
+    const stubs = Object.values(entries);
+    if (stubs.length > 0) {
+      const block = ["  actions: {", ...stubs.flatMap((s) => s.split("\n").map((l) => `    ${l}`)), "  },"].join("\n");
+      options = options.endsWith("aiReady(exposify);") ? options.replace("aiReady(exposify);", `aiReady(exposify, {
+${block}
+});`) : options.replace(/\n\}\);$/, `
+${block}
+});`);
+    }
+    const usesZod = stubs.some((s) => s.includes("z."));
+    const lines = [];
+    if (stubs.some((s) => s.includes("TODO(exposify)"))) {
+      lines.push("Go through the TODO(exposify) lines: an action whose input is still incomplete stays hidden until you write it out.");
+    }
+    if (!hasWithExposify(root)) {
+      lines.push(
+        'Wrap your next.config export: `export default withExposify(nextConfig)`, imported from "@exposify/next/config". It keeps exposify.generated.ts current on `next dev` and `next build`.'
+      );
+    }
+    const existing = ["exposify.generated.ts", "exposify.generated.js"].map((f) => join8(root, f)).find((f) => existsSync4(f));
+    const manifestFile = existing ?? generate(root, {}, () => {
+    }).file;
+    const generated = relative3(root, manifestFile);
+    if (result.aiReady?.site) {
+      const file = relative3(root, result.aiReady.site.file);
+      if (usesZod) lines.push('The input stubs use zod: `import { z } from "zod";` in that file, if it isn\'t there.');
+      return {
+        code: options,
+        hint: { lines: [`Replace the aiReady(...) call in ${file}:${result.aiReady.site.line} with this.`, ...lines] },
+        apply: applyReplace(result.aiReady.site, config, entries, usesZod, file)
+      };
+    }
+    const routeFile = `${d.appDir ?? "app"}/${MCP_ROUTE_DIR}/route.${generated.endsWith(".ts") ? "ts" : "js"}`;
+    const manifestImport = relative3(join8(root, dirname4(routeFile)), manifestFile).replace(/\.[jt]s$/, "");
+    const code = [
+      'import { aiReady } from "@exposify/next";',
+      ...usesZod ? ['import { z } from "zod";'] : [],
+      `import { exposify } from "${manifestImport.startsWith(".") ? manifestImport : `./${manifestImport}`}";`,
+      "",
+      options,
+      "",
+      "export { handler as GET, handler as POST, handler as DELETE };"
+    ].join("\n");
+    return {
+      code,
+      apply: { plan: { file: join8(root, routeFile), summary: `Create ${routeFile}`, before: null, after: `${code}
+` } },
+      hint: { lines: [`Create ${routeFile} with this (agents connect to /mcp). It imports ${generated}${existing ? "" : ", written just now"}.`, ...lines] }
+    };
+  }
+};
+function hasWithExposify(root) {
+  for (const name of ["next.config.ts", "next.config.mjs", "next.config.js", "next.config.cjs", "next.config.mts"]) {
+    try {
+      if (readFileSync8(join8(root, name), "utf8").includes("withExposify")) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function scanProject(root) {
+  const d = discover(root);
+  if (!d.appDir && !d.pagesDir) throw new Error("no app/ or pages/ directory");
+  const call = d.mcpRoute ? findAiReadyCall(d.mcpRoute.source, d.mcpRoute.file) : null;
+  const cfg = resolveOptions({ ...call?.expose ? { expose: call.expose } : {}, ...call?.exclude ? { exclude: call.exclude } : {} });
+  const listed = Array.isArray(call?.expose) ? call.expose : [];
+  const notes = [];
+  const descriptions = readDescriptions(root, (m) => notes.push(m));
+  const rows = [];
+  for (const r of d.routes) {
+    if (r.router === "app") {
+      for (const method of r.module.methods.filter((m) => m !== "OPTIONS")) {
+        const m = r.module.markers[method];
+        const marker = m ? m.kind === "described" ? { kind: "described", ...m.name ? { name: m.name } : {}, ...m.description ? { description: m.description } : {} } : { kind: m.kind } : void 0;
+        const source = r.module.sources[method];
+        rows.push({ info: { method, path: r.path, params: r.params, ...marker ? { marker } : {} }, ...m?.name ? { describedName: m.name } : {}, ...m?.description ? { describedText: m.description } : {}, ...source ? { source } : {} });
+      }
+      continue;
+    }
+    const methods = new Set(r.detected?.methods ?? []);
+    for (const entry of listed) {
+      const [method, ...rest] = entry.trim().split(/\s+/);
+      if (method && rest.join(" ") === r.path) methods.add(method.toUpperCase());
+    }
+    if (methods.size === 0) {
+      notes.push(`${r.file}: methods not detected; to expose it, add "METHOD ${r.path}" to expose by hand.`);
+      continue;
+    }
+    for (const method of methods) rows.push({ info: { method, path: r.path, params: r.params, optIn: true }, ...r.source ? { source: r.source } : {} });
+  }
+  for (const p of d.pages) {
+    let source;
+    try {
+      source = readFileSync8(join8(root, p.file), "utf8");
+    } catch {
+      source = void 0;
+    }
+    if (source && source.length > 6e3) source = `${source.slice(0, 6e3)}
+/* \u2026 truncated */`;
+    rows.push({
+      info: { method: "GET", path: p.path, params: p.params, ...p.formOnly ? { optIn: true } : {} },
+      describedName: p.name,
+      ...p.description ? { describedText: p.description } : {},
+      ...source ? { source } : {},
+      ...p.formOnly ? { formOnly: true } : {},
+      page: true
+    });
+  }
+  const exposure = new Map(rows.map((row) => [`${row.info.method} ${row.info.path}`, decideExposure(row.info, cfg)]));
+  const named2 = rows.map((row) => ({
+    method: row.info.method,
+    path: row.info.path,
+    params: row.info.params,
+    ...row.info.marker ? { marker: row.info.marker.kind } : {},
+    ...row.describedName ? { describedName: row.describedName } : {}
+  }));
+  const names = toolNames(named2, (r) => exposure.get(`${r.method} ${r.path}`).exposed);
+  for (const row of rows) if (row.page && row.describedName) names.set(`GET ${row.info.path}`, row.describedName);
+  const suggestions = [];
+  const actions = scanActions(d, call, root, notes, suggestions);
+  const routes = rows.map((row) => {
+    const key = `${row.info.method} ${row.info.path}`;
+    const decision = exposure.get(key);
+    const derived = deriveDescription({ ...row.info, ...descriptions[key] ? { description: descriptions[key] } : {} });
+    return {
+      method: row.info.method,
+      path: row.info.path,
+      params: row.info.params,
+      ...row.info.marker ? { marker: row.info.marker.kind } : {},
+      ...row.describedName ? { describedName: row.describedName } : {},
+      ...row.describedText ? { describedText: row.describedText } : {},
+      tool: names.get(key),
+      ...derived ? { derived } : {},
+      exposed: decision.exposed,
+      reason: row.formOnly && !decision.exposed ? `a page that's just a form posting to a Server Action (the action is the tool); list "GET ${row.info.path}" in expose to read it anyway` : row.page && decision.exposed ? "a page: read like a browser reads it" : decision.reason,
+      ...row.info.optIn ? { optIn: true } : {},
+      ...row.page ? { kind: "page" } : {},
+      ...row.source ? { source: row.source } : {}
+    };
+  });
+  return {
+    ok: true,
+    routes,
+    ...actions.length > 0 ? {
+      actions,
+      actionsNote: `Server Actions are called the way a browser's form calls them, on a page that uses them (one no page uses runs at ${(d.mcpPath ?? "/mcp").replace(/\/$/, "")}/actions/* instead), so each action must check auth itself, as Next advises.`
+    } : {},
+    ...notes.length > 0 ? { notes } : {},
+    ...suggestions.length > 0 ? { suggestions } : {},
+    ...d.login ? { login: { what: loginLabel(d.login), fields: d.login.fields.map((f) => f.name), ...d.loginOthers?.length ? { others: d.loginOthers.map(loginLabel) } : {} } } : {},
+    ...call && d.mcpRoute ? {
+      aiReady: {
+        site: { file: join8(root, d.mcpRoute.file), line: call.line },
+        options: {
+          ...call.expose ? { expose: call.expose } : {},
+          ...call.exclude ? { exclude: call.exclude } : {},
+          ...call.startupLog !== void 0 ? { startupLog: call.startupLog } : {},
+          ...call.actions && call.actions !== "opaque" ? { actions: Object.keys(call.actions) } : {},
+          otherKeys: call.otherKeys
+        }
+      }
+    } : {}
+  };
+}
+function applyReplace(site, config, entries, usesZod, relFile) {
+  try {
+    const before = readFileSync8(site.file, "utf8");
+    const edit = replaceAiReadyOptions({
+      source: before,
+      file: site.file,
+      line: site.line,
+      callNames: ["aiReady"],
+      optionsArg: 1,
+      config,
+      actionEntries: entries,
+      ...usesZod ? { needsImport: { from: "zod", name: "z" } } : {}
+    });
+    if ("blocked" in edit) return edit;
+    return { plan: { file: site.file, summary: `Replace the aiReady() options in ${relFile}`, before, after: edit.after } };
+  } catch (err) {
+    return { blocked: err.message };
+  }
+}
+
+// bin/exposify-next.ts
+var GENERATE_USAGE = `Usage: exposify-next generate [options]
+
+Writes exposify.generated.ts (the route table and docs the MCP route uses).
+withExposify() in next.config runs this on \`next dev\` and \`next build\`.
+
+Options:
+  --entry <path>   The Next.js project directory (default: detected)
+  --out <file>     Output file (default: exposify.generated.ts, .js without tsconfig.json)
+  --docs <glob>    Docs for search_docs (repeatable; default README.md, docs/**/*.md)
+  --base-path <p>  next.config's basePath, if you don't use withExposify()`;
+function runGenerate(argv2, cwd) {
+  let entry;
+  let out;
+  let basePath;
+  const docs = [];
+  for (let i = 0; i < argv2.length; i++) {
+    const flag = argv2[i];
+    const value = () => {
+      const v = argv2[++i];
+      if (v === void 0) throw new Error(`${flag} needs a value`);
+      return v;
+    };
+    if (flag === "--entry") entry = value();
+    else if (flag === "--out") out = value();
+    else if (flag === "--docs") docs.push(value());
+    else if (flag === "--base-path") basePath = value();
+    else if (flag === "--help" || flag === "-h") {
+      console.log(GENERATE_USAGE);
+      return 0;
+    } else {
+      console.error(`Unknown option: ${flag}
+
+${GENERATE_USAGE}`);
+      return 1;
+    }
+  }
+  const root = findNextRoot(entry ? `${cwd}/${entry}` : cwd);
+  if (!root) {
+    console.error("Couldn't find a Next.js project (a package.json with next, and an app/ or pages/ directory).");
+    return 1;
+  }
+  const result = generate(root, { ...out ? { out } : {}, ...docs.length > 0 ? { docs } : {}, ...basePath ? { basePath } : {} });
+  const routes = result.discovery.routes;
+  const app = routes.filter((r) => r.router === "app").length;
+  console.log(
+    `${result.changed ? "Wrote" : "Unchanged:"} ${relative4(cwd, result.file) || result.file}: ${app} App Router route file${app === 1 ? "" : "s"}, ${routes.length - app} Pages Router API file${routes.length - app === 1 ? "" : "s"}.`
+  );
+  if (!result.discovery.mcpRoute) console.log("No MCP route yet: run `npx exposify-next setup`.");
+  return 0;
+}
+var argv = process.argv.slice(2);
+(argv[0] === "generate" ? Promise.resolve().then(() => runGenerate(argv.slice(1), process.cwd())) : runCli(argv, nextAdapter)).then(
+  (code) => process.exit(code),
+  (err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+);