@dudousxd/nestjs-codegen 0.25.2 → 0.27.0

package/dist/nest/index.cjs

@@ -109,11 +109,32 @@ function validateUserConfig(userConfig) {
       "validation adapter is required \u2014 install @dudousxd/nestjs-codegen-zod and pass zodAdapter, or use @dudousxd/nestjs-codegen-valibot / -arktype"
     );
   }
-  if (userConfig.pages && typeof userConfig.pages.glob !== "string") {
+  if (userConfig.pages && !isGlobInput(userConfig.pages.glob)) {
     throw new ConfigError(
-      "Config validation failed: `pages.glob` must be a string when `pages` is set"
+      "Config validation failed: `pages.glob` must be a string or a non-empty array of strings when `pages` is set"
     );
   }
+  for (const [scope, scopeConfig] of Object.entries(userConfig.pages?.scopes ?? {})) {
+    if (scope === "default") {
+      throw new ConfigError(
+        'Config validation failed: `pages.scopes` cannot declare "default" \u2014 the default app is `pages.glob` (InertiaModule.forRoot).'
+      );
+    }
+    if (!isGlobInput(scopeConfig?.glob)) {
+      throw new ConfigError(
+        `Config validation failed: \`pages.scopes.${scope}.glob\` must be a string or a non-empty array of strings`
+      );
+    }
+  }
+  if (userConfig.scopes && Object.keys(userConfig.scopes).length > 0) {
+    console.warn(
+      "[nestjs-codegen] The top-level `scopes` option has no effect and is deprecated. For several Inertia apps use `pages.scopes` (one entry per InertiaModule.forFeature scope); for several controller sets use one `contracts.glob` (e.g. a brace glob)."
+    );
+  }
+}
+function isGlobInput(value) {
+  if (typeof value === "string") return true;
+  return Array.isArray(value) && value.length > 0 && value.every((glob) => typeof glob === "string");
 }
 function applyDefaults(userConfig, cwd) {
   validateUserConfig(userConfig);
@@ -141,7 +162,17 @@ function applyDefaults(userConfig, cwd) {
     pages: userConfig.pages ? {
       glob: userConfig.pages.glob,
       propsExport: userConfig.pages.propsExport ?? "ComponentProps",
-      componentNameStrategy: userConfig.pages.componentNameStrategy ?? "relative-no-ext"
+      componentNameStrategy: userConfig.pages.componentNameStrategy ?? "relative-no-ext",
+      scopes: Object.fromEntries(
+        Object.entries(userConfig.pages.scopes ?? {}).map(([scope, scopeConfig]) => [
+          scope,
+          {
+            glob: scopeConfig.glob,
+            prefix: scopeConfig.prefix ?? `${scope}/`,
+            componentNameStrategy: scopeConfig.componentNameStrategy ?? userConfig.pages?.componentNameStrategy ?? "relative-no-ext"
+          }
+        ])
+      )
     } : null,
     contracts: {
       glob: userConfig.contracts?.glob ?? "src/**/*.controller.ts",
@@ -187,10 +218,10 @@ var import_fast_glob3 = __toESM(require("fast-glob"), 1);
 var import_node_fs = require("fs");
 var import_node_path3 = require("path");
 var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_ts_morph8 = require("ts-morph");
+var import_ts_morph11 = require("ts-morph");
 
 // src/discovery/dto-type-resolver.ts
-var import_ts_morph6 = require("ts-morph");
+var import_ts_morph10 = require("ts-morph");
 
 // src/discovery/dto-to-ir.ts
 var import_ts_morph2 = require("ts-morph");
@@ -1718,6 +1749,672 @@ function extractFilterableEntityFields(filterClass, project, entityOverride, pre
   return fields;
 }
 
+// src/discovery/pipe-schema.ts
+var import_ts_morph9 = require("ts-morph");
+
+// src/discovery/schema-type-inference.ts
+var import_ts_morph7 = require("ts-morph");
+
+// src/discovery/schema-type-program.ts
+var import_ts_morph6 = require("ts-morph");
+var PARAM_DECORATORS = /* @__PURE__ */ new Set(["Body", "Query", "Param"]);
+var SchemaTypeProgram = class {
+  constructor(discovery) {
+    this.discovery = discovery;
+    const base = discovery.getCompilerOptions();
+    this.options = {
+      ...base,
+      // A tsconfig-less consumer gets ES5 by default, whose lib has no `Map`/`Set`/
+      // `Promise` for the schema libraries' declarations to lean on.
+      target: base.target ?? import_ts_morph6.ts.ScriptTarget.ES2022,
+      // With neither set, resolve the way a bundler does: package `exports`
+      // (`zod/v4`) and extensionless or `.js` relative imports all resolve.
+      ...base.module === void 0 && base.moduleResolution === void 0 ? { module: import_ts_morph6.ts.ModuleKind.ESNext, moduleResolution: import_ts_morph6.ts.ModuleResolutionKind.Bundler } : {},
+      // Without it `.nullable()` and `.optional()` would erase to the bare type.
+      strictNullChecks: true,
+      // No ambient `@types/*` (a tsconfig's `types: ['node']`): a schema does not
+      // need them, and they are a hundred-odd files of program to build.
+      types: [],
+      noEmit: true
+    };
+    this.project = new import_ts_morph6.Project({
+      skipAddingFilesFromTsConfig: true,
+      compilerOptions: this.options
+    });
+    for (const sf of discovery.getSourceFiles()) this.request(sf.getFilePath(), { schema: true });
+    this.flush();
+  }
+  project;
+  options;
+  /** Parses a file that is not in discovery's Project, without adding it there. */
+  scratch = new import_ts_morph6.Project({
+    skipAddingFilesFromTsConfig: true,
+    skipLoadingLibFiles: true,
+    skipFileDependencyResolution: true
+  });
+  needs = /* @__PURE__ */ new Map();
+  /** Pruned text per file, as last written into {@link project}. */
+  written = /* @__PURE__ */ new Map();
+  /**
+   * The typed copy of a discovery file, with its schema positions kept. Adding one
+   * that was not there yet (a contract file discovery reached lazily) rebuilds the
+   * program once.
+   */
+  sourceFileFor(sf) {
+    this.request(sf.getFilePath(), { schema: true });
+    this.flush();
+    return this.project.getSourceFile(sf.getFilePath());
+  }
+  // -------------------------------------------------------------------------
+  queue = [];
+  request(path, want) {
+    let needs = this.needs.get(path);
+    const isNew = !needs;
+    needs ??= { schema: false, all: false, names: /* @__PURE__ */ new Set() };
+    let grew = isNew;
+    if (want.schema && !needs.schema) {
+      needs.schema = true;
+      grew = true;
+    }
+    if (want.all && !needs.all) {
+      needs.all = true;
+      grew = true;
+    }
+    for (const name of want.names ?? []) {
+      if (!needs.names.has(name)) {
+        needs.names.add(name);
+        grew = true;
+      }
+    }
+    this.needs.set(path, needs);
+    if (grew) this.queue.push(path);
+  }
+  /** Run the worklist to a fixpoint, then write every changed file into the program. */
+  flush() {
+    const changed = /* @__PURE__ */ new Map();
+    while (this.queue.length > 0) {
+      const path = this.queue.pop();
+      const original = this.original(path);
+      if (!original) continue;
+      const needs = this.needs.get(path);
+      const text = this.prune(original, needs);
+      if (this.written.get(path) !== text) changed.set(path, text);
+    }
+    for (const [path, text] of changed) {
+      this.project.createSourceFile(path, text, { overwrite: true });
+      this.written.set(path, text);
+    }
+  }
+  /** The file as discovery sees it (its in-memory text), else as it is on disk. */
+  original(path) {
+    return this.discovery.getSourceFile(path) ?? this.scratch.getSourceFile(path) ?? this.scratch.addSourceFileAtPathIfExists(path);
+  }
+  /**
+   * `sf`'s text with every import/re-export nothing in `needs` references blanked,
+   * requesting from each kept one's target the names it brings in.
+   */
+  prune(sf, needs) {
+    const locals = topLevelDeclarations(sf);
+    const roots = [];
+    if (needs.all) roots.push(...sf.getStatements());
+    if (needs.schema) roots.push(...schemaPositions(sf));
+    const reexported = /* @__PURE__ */ new Map();
+    for (const exp of sf.getExportDeclarations()) {
+      const spec = exp.getModuleSpecifierValue();
+      if (spec === void 0) {
+        for (const named of exp.getNamedExports()) {
+          const exposed = (named.getAliasNode() ?? named.getNameNode()).getText();
+          if (needs.all || needs.names.has(exposed)) roots.push(named.getNameNode());
+        }
+        continue;
+      }
+      if (exp.isNamespaceExport() || exp.getNamedExports().length === 0) continue;
+      for (const named of exp.getNamedExports()) {
+        const exposed = (named.getAliasNode() ?? named.getNameNode()).getText();
+        const list = reexported.get(exposed) ?? [];
+        list.push({ from: spec, name: named.getNameNode().getText() });
+        reexported.set(exposed, list);
+      }
+    }
+    const unresolvedNames = [];
+    for (const name of needs.names) {
+      const decls = name === "default" ? defaultExport(sf) : locals.get(name) ?? [];
+      if (decls.length > 0) roots.push(...decls);
+      else if (!reexported.has(name)) unresolvedNames.push(name);
+    }
+    const referenced = /* @__PURE__ */ new Set();
+    const queue = [...roots];
+    const seen = new Set(queue);
+    while (queue.length > 0) {
+      const node = queue.pop();
+      const ids = import_ts_morph6.Node.isIdentifier(node) ? [node] : node.getDescendantsOfKind(import_ts_morph6.ts.SyntaxKind.Identifier);
+      for (const id of ids) {
+        const name = id.getText();
+        if (referenced.has(name)) continue;
+        referenced.add(name);
+        for (const local of locals.get(name) ?? []) {
+          if (seen.has(local)) continue;
+          seen.add(local);
+          queue.push(local);
+        }
+      }
+    }
+    const chars = sf.getFullText().split("");
+    const blank = (node) => {
+      for (let i = node.getStart(); i < node.getEnd(); i++) {
+        if (chars[i] !== "\n" && chars[i] !== "\r") chars[i] = " ";
+      }
+    };
+    for (const decl of sf.getImportDeclarations()) {
+      const target = this.resolve(decl.getModuleSpecifierValue(), sf);
+      const namespace = decl.getNamespaceImport()?.getText();
+      const def = decl.getDefaultImport()?.getText();
+      const named = decl.getNamedImports().map((n) => ({
+        local: (n.getAliasNode() ?? n.getNameNode()).getText(),
+        imported: n.getName()
+      })).filter((n) => referenced.has(n.local));
+      const wantsNamespace = namespace !== void 0 && referenced.has(namespace);
+      const wantsDefault = def !== void 0 && referenced.has(def);
+      if (!wantsNamespace && !wantsDefault && named.length === 0) {
+        blank(decl);
+        continue;
+      }
+      if (target) {
+        this.request(target, {
+          all: wantsNamespace,
+          names: [...wantsDefault ? ["default"] : [], ...named.map((n) => n.imported)]
+        });
+      }
+    }
+    for (const exp of sf.getExportDeclarations()) {
+      const spec = exp.getModuleSpecifierValue();
+      if (spec === void 0) continue;
+      const target = this.resolve(spec, sf);
+      if (exp.isNamespaceExport() || exp.getNamedExports().length === 0) {
+        if (!needs.all && unresolvedNames.length === 0) {
+          blank(exp);
+        } else if (target) {
+          this.request(target, { all: needs.all, names: unresolvedNames });
+        }
+        continue;
+      }
+      const wanted = exp.getNamedExports().filter(
+        (n) => needs.all || needs.names.has((n.getAliasNode() ?? n.getNameNode()).getText())
+      ).map((n) => n.getNameNode().getText());
+      if (wanted.length === 0) blank(exp);
+      else if (target) this.request(target, { names: wanted });
+    }
+    return chars.join("");
+  }
+  /**
+   * The project source file a module specifier resolves to, or undefined for a
+   * package (read unpruned by the program itself) or an unresolvable one.
+   */
+  resolve(specifier, from) {
+    const resolved = import_ts_morph6.ts.resolveModuleName(
+      specifier,
+      from.getFilePath(),
+      this.options,
+      import_ts_morph6.ts.sys
+    ).resolvedModule;
+    if (!resolved || resolved.isExternalLibraryImport) return void 0;
+    const file = resolved.resolvedFileName;
+    if (file.endsWith(".d.ts") || !/\.(m|c)?tsx?$/.test(file)) return void 0;
+    return file;
+  }
+};
+function schemaPositions(sf) {
+  const roots = [];
+  sf.forEachDescendant((node) => {
+    if (import_ts_morph6.Node.isDecorator(node)) {
+      const name = node.getName();
+      if (name === "ApplyContract") {
+        roots.push(...node.getArguments());
+      } else if (PARAM_DECORATORS.has(name)) {
+        for (const arg of node.getArguments()) {
+          if (import_ts_morph6.Node.isNewExpression(arg) || import_ts_morph6.Node.isCallExpression(arg)) {
+            roots.push(...arg.getArguments());
+          }
+        }
+      }
+    } else if (import_ts_morph6.Node.isCallExpression(node)) {
+      const callee = node.getExpression();
+      const name = import_ts_morph6.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph6.Node.isPropertyAccessExpression(callee) ? callee.getName() : void 0;
+      if (name === "defineContract") roots.push(...node.getArguments());
+    }
+  });
+  return roots;
+}
+function topLevelDeclarations(sf) {
+  const byName = /* @__PURE__ */ new Map();
+  const add = (name, node) => {
+    if (!name) return;
+    const list = byName.get(name);
+    if (list) list.push(node);
+    else byName.set(name, [node]);
+  };
+  for (const decl of sf.getVariableDeclarations()) add(decl.getName(), decl);
+  for (const decl of sf.getFunctions()) add(decl.getName(), decl);
+  for (const decl of sf.getClasses()) add(decl.getName(), decl);
+  for (const decl of sf.getEnums()) add(decl.getName(), decl);
+  for (const decl of sf.getInterfaces()) add(decl.getName(), decl);
+  for (const decl of sf.getTypeAliases()) add(decl.getName(), decl);
+  for (const decl of sf.getModules()) add(decl.getName(), decl);
+  return byName;
+}
+function defaultExport(sf) {
+  const nodes = [];
+  for (const assignment of sf.getExportAssignments()) nodes.push(assignment);
+  for (const fn of sf.getFunctions()) if (fn.isDefaultExport()) nodes.push(fn);
+  for (const cls of sf.getClasses()) if (cls.isDefaultExport()) nodes.push(cls);
+  return nodes;
+}
+
+// src/discovery/schema-type-inference.ts
+var programs = /* @__PURE__ */ new WeakMap();
+function programFor(discovery) {
+  let program = programs.get(discovery);
+  if (!program) {
+    program = new SchemaTypeProgram(discovery);
+    programs.set(discovery, program);
+  }
+  return program;
+}
+function clearSchemaTypeProject(discovery) {
+  programs.delete(discovery);
+}
+function counterpart(typedSf, node) {
+  const start = node.getStart();
+  const end = node.getEnd();
+  const kind = node.getKind();
+  let candidate = typedSf.getDescendantAtPos(start);
+  while (candidate) {
+    if (candidate.getStart() === start && candidate.getEnd() === end && candidate.getKind() === kind) {
+      return candidate;
+    }
+    if (candidate.getStart() < start || candidate.getEnd() > end) return void 0;
+    candidate = candidate.getParent();
+  }
+  return void 0;
+}
+function propType(type, name, at) {
+  return type.getProperty(name)?.getTypeAtLocation(at);
+}
+function isAnyOrUnknown(type) {
+  return type.isAny() || type.isUnknown();
+}
+function inferSchema(expr, discovery) {
+  try {
+    const typedSf = programFor(discovery).sourceFileFor(expr.getSourceFile());
+    const at = typedSf && counterpart(typedSf, expr);
+    if (!at) return { kind: "unresolved" };
+    const schemaType = at.getType();
+    if (isAnyOrUnknown(schemaType)) return { kind: "unresolved" };
+    const standard = propType(schemaType, "~standard", at);
+    const stdTypes = standard ? propType(standard, "types", at)?.getNonNullableType() : void 0;
+    const stdInput = stdTypes ? propType(stdTypes, "input", at) : void 0;
+    const stdOutput = stdTypes ? propType(stdTypes, "output", at) : void 0;
+    if (stdInput && stdOutput) {
+      return { kind: "schema", types: { input: stdInput, output: stdOutput, at } };
+    }
+    const zodInput = propType(schemaType, "_input", at);
+    const zodOutput = propType(schemaType, "_output", at);
+    if (zodInput && zodOutput) {
+      return { kind: "schema", types: { input: zodInput, output: zodOutput, at } };
+    }
+    return { kind: "not-schema" };
+  } catch (err) {
+    dbg("schema inference failed:", err);
+    return { kind: "unresolved" };
+  }
+}
+var GLOBAL_NAMED_TYPES = /* @__PURE__ */ new Set([
+  "Date",
+  "File",
+  "Blob",
+  "FormData",
+  "URL",
+  "RegExp",
+  "Map",
+  "Set",
+  "ArrayBuffer",
+  "Uint8Array"
+]);
+var MAX_DEPTH = 12;
+function objectKey(name) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function isOptionalSymbol(sym) {
+  return (sym.getFlags() & import_ts_morph7.ts.SymbolFlags.Optional) !== 0;
+}
+function isSymbolKeyed(sym) {
+  return sym.getName().startsWith("__@");
+}
+function orderedProperties(type) {
+  const position = (sym) => {
+    const decl = sym.getDeclarations()[0];
+    return decl ? [decl.getSourceFile().getFilePath(), decl.getStart()] : void 0;
+  };
+  return type.getProperties().map((sym, index) => ({ sym, index, at: position(sym) })).sort((a, b) => {
+    if (a.at && b.at) {
+      if (a.at[0] !== b.at[0]) return a.at[0] < b.at[0] ? -1 : 1;
+      if (a.at[1] !== b.at[1]) return a.at[1] - b.at[1];
+    } else if (a.at || b.at) {
+      return a.at ? -1 : 1;
+    }
+    return a.index - b.index;
+  }).map((entry) => entry.sym);
+}
+function isFromDeclarationFile(sym) {
+  const decl = sym?.getDeclarations()[0];
+  return !!decl && decl.getSourceFile().isDeclarationFile();
+}
+function render(type, state, paired) {
+  if (state.depth > MAX_DEPTH) return "unknown";
+  if (isAnyOrUnknown(type)) {
+    return paired && !isAnyOrUnknown(paired) ? render(paired, state) : "unknown";
+  }
+  if (type.isNever()) return "never";
+  if (type.isString() || type.isTemplateLiteral()) return "string";
+  if (type.isNumber()) return "number";
+  if (type.isBoolean()) return "boolean";
+  if (type.isBigInt()) return "bigint";
+  if (type.isNull()) return "null";
+  if (type.isUndefined() || type.isVoid()) return "undefined";
+  if (type.isBooleanLiteral()) return type.getText();
+  if (type.isStringLiteral() || type.isNumberLiteral() || type.isEnumLiteral()) {
+    const value = type.getLiteralValue();
+    return typeof value === "string" ? JSON.stringify(value) : String(value);
+  }
+  if (type.isBigIntLiteral()) return type.getText();
+  if (type.isTypeParameter()) return "unknown";
+  if (type.isUnion()) return renderUnion(type, state, paired);
+  if (type.isIntersection()) return renderIntersection(type, state);
+  const next = { ...state, depth: state.depth + 1 };
+  if (type.isArray() || type.isReadonlyArray()) {
+    const element = type.getArrayElementType() ?? type.getTypeArguments()[0];
+    const pairedElement = paired?.getArrayElementType() ?? paired?.getTypeArguments()[0];
+    return element ? `Array<${render(element, next, pairedElement)}>` : "Array<unknown>";
+  }
+  if (type.isTuple()) {
+    const elements = type.getTupleElements();
+    const pairedElements = paired?.isTuple() ? paired.getTupleElements() : [];
+    return `[${elements.map((e, i) => render(e, next, pairedElements[i])).join(", ")}]`;
+  }
+  if (type.isObject()) return renderObject(type, next, paired);
+  return "unknown";
+}
+function renderUnion(type, state, paired) {
+  const members = type.getUnionTypes();
+  const hasTrue = members.some((m) => m.isBooleanLiteral() && m.getText() === "true");
+  const hasFalse = members.some((m) => m.isBooleanLiteral() && m.getText() === "false");
+  const pairedNonNull = paired?.getNonNullableType();
+  const arms = [];
+  let sawBoolean = false;
+  let hasNull = false;
+  let hasUndefined = false;
+  for (const member of members) {
+    if (member.isNull()) {
+      hasNull = true;
+      continue;
+    }
+    if (member.isUndefined()) {
+      hasUndefined = true;
+      continue;
+    }
+    if (member.isBooleanLiteral() && hasTrue && hasFalse) {
+      if (!sawBoolean) arms.push("boolean");
+      sawBoolean = true;
+      continue;
+    }
+    arms.push(render(member, state, members.length === 1 ? paired : pairedNonNull));
+  }
+  if (hasNull) arms.push("null");
+  if (hasUndefined) arms.push("undefined");
+  const unique = [...new Set(arms)];
+  if (unique.includes("unknown")) return "unknown";
+  return unique.join(" | ");
+}
+function renderIntersection(type, state) {
+  const members = type.getIntersectionTypes();
+  const primitive = members.find((m) => !m.isObject());
+  if (primitive) return render(primitive, state);
+  return renderObject(type, { ...state, depth: state.depth + 1 }, void 0);
+}
+function renderObject(type, state, paired) {
+  const symbol = type.getSymbol() ?? type.getAliasSymbol();
+  const name = symbol?.getName();
+  if (name && GLOBAL_NAMED_TYPES.has(name) && isFromDeclarationFile(symbol)) {
+    const args = type.getTypeArguments();
+    return args.length ? `${name}<${args.map((a) => render(a, state)).join(", ")}>` : name;
+  }
+  if (type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0) {
+    return "unknown";
+  }
+  if (type.isClassOrInterface() && isFromDeclarationFile(symbol)) return "unknown";
+  if (state.stack.has(type.compilerType)) return "unknown";
+  const stack = new Set(state.stack).add(type.compilerType);
+  const inner = { ...state, stack };
+  const fields = [];
+  for (const prop of orderedProperties(type)) {
+    if (isSymbolKeyed(prop)) continue;
+    const propName = prop.getName();
+    const propT = prop.getTypeAtLocation(state.at);
+    if (propT.getCallSignatures().length > 0 && !propT.isUnion()) continue;
+    const pairedProp = paired?.getProperty(propName)?.getTypeAtLocation(state.at);
+    const optional = isOptionalSymbol(prop) ? "?" : "";
+    fields.push(`${objectKey(propName)}${optional}: ${render(propT, inner, pairedProp)}`);
+  }
+  const stringIndex = type.getStringIndexType();
+  if (stringIndex) {
+    const pairedIndex = paired?.getStringIndexType();
+    const value = render(stringIndex, inner, pairedIndex);
+    if (fields.length === 0) return `Record<string, ${value}>`;
+    fields.push(`[key: string]: ${value}`);
+  }
+  return fields.length ? `{ ${fields.join("; ")} }` : "{}";
+}
+function stateAt(at) {
+  return { at, stack: /* @__PURE__ */ new Set(), depth: 0 };
+}
+function requestTypeOf(types) {
+  return render(types.input, stateAt(types.at), types.output);
+}
+function responseTypeOf(types) {
+  return render(types.output, stateAt(types.at));
+}
+function requestFieldsOf(types) {
+  const { input, output, at } = types;
+  const objectInput = input.getNonNullableType();
+  if (!objectInput.isObject() || objectInput.isArray() || objectInput.isTuple()) return null;
+  const state = stateAt(at);
+  return orderedProperties(objectInput).filter((prop) => !isSymbolKeyed(prop)).map((prop) => ({
+    name: prop.getName(),
+    type: render(
+      prop.getTypeAtLocation(at),
+      state,
+      output.getProperty(prop.getName())?.getTypeAtLocation(at)
+    ),
+    optional: isOptionalSymbol(prop)
+  }));
+}
+function acceptsUndefined(types) {
+  const { input, output } = types;
+  const accepted = isAnyOrUnknown(input) ? output : input;
+  if (isAnyOrUnknown(accepted) || accepted.isUndefined()) return true;
+  return accepted.isUnion() && accepted.getUnionTypes().some((t) => t.isUndefined());
+}
+
+// src/discovery/zod-ast-to-ts.ts
+var import_ts_morph8 = require("ts-morph");
+function zodAstToTs(node) {
+  if (!import_ts_morph8.Node.isCallExpression(node)) return "unknown";
+  const expr = node.getExpression();
+  if (import_ts_morph8.Node.isPropertyAccessExpression(expr)) {
+    const methodName = expr.getName();
+    const receiver = expr.getExpression();
+    if (methodName === "optional") {
+      return `${zodAstToTs(receiver)} | undefined`;
+    }
+    if (methodName === "nullable") {
+      return `${zodAstToTs(receiver)} | null`;
+    }
+    const args = node.getArguments();
+    switch (methodName) {
+      case "string":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "unknown":
+        return "unknown";
+      case "any":
+        return "unknown";
+      case "literal": {
+        const lit = args[0];
+        if (!lit) return "unknown";
+        if (import_ts_morph8.Node.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
+        if (import_ts_morph8.Node.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
+        if (lit.getKind() === import_ts_morph8.SyntaxKind.TrueKeyword) return "true";
+        if (lit.getKind() === import_ts_morph8.SyntaxKind.FalseKeyword) return "false";
+        return "unknown";
+      }
+      case "enum": {
+        const arrArg = args[0];
+        if (!arrArg || !import_ts_morph8.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        const members = arrArg.getElements().map(
+          (el) => import_ts_morph8.Node.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown"
+        );
+        return members.join(" | ");
+      }
+      case "array": {
+        const inner = args[0];
+        if (!inner) return "unknown";
+        return `Array<${zodAstToTs(inner)}>`;
+      }
+      case "object": {
+        const objArg = args[0];
+        if (!objArg || !import_ts_morph8.Node.isObjectLiteralExpression(objArg)) return "unknown";
+        const lines = [];
+        for (const prop of objArg.getProperties()) {
+          if (!import_ts_morph8.Node.isPropertyAssignment(prop)) continue;
+          const key = prop.getName();
+          const valNode = prop.getInitializer();
+          if (!valNode) continue;
+          const tsType = zodAstToTs(valNode);
+          const isOpt = isOptionalChain(valNode);
+          lines.push(`${key}${isOpt ? "?" : ""}: ${tsType}`);
+        }
+        return `{ ${lines.join("; ")} }`;
+      }
+      case "union": {
+        const arrArg = args[0];
+        if (!arrArg || !import_ts_morph8.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        return arrArg.getElements().map(zodAstToTs).join(" | ");
+      }
+      case "record": {
+        const valArg = args.length === 1 ? args[0] : args[1];
+        if (!valArg) return "unknown";
+        return `Record<string, ${zodAstToTs(valArg)}>`;
+      }
+      case "tuple": {
+        const arrArg = args[0];
+        if (!arrArg || !import_ts_morph8.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
+      }
+      default:
+        return "unknown";
+    }
+  }
+  return "unknown";
+}
+function isOptionalChain(node) {
+  if (!import_ts_morph8.Node.isCallExpression(node)) return false;
+  const expr = node.getExpression();
+  return import_ts_morph8.Node.isPropertyAccessExpression(expr) && expr.getName() === "optional";
+}
+function memberType(val, position, project) {
+  if (project) {
+    const inferred = inferSchema(val, project);
+    if (inferred.kind === "schema") {
+      return position === "request" ? requestTypeOf(inferred.types) : responseTypeOf(inferred.types);
+    }
+  }
+  return zodAstToTs(val);
+}
+function parseDefineContractCall(callExpr, project) {
+  if (!import_ts_morph8.Node.isCallExpression(callExpr)) return null;
+  const callee = callExpr.getExpression();
+  const calleeName = import_ts_morph8.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph8.Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
+  if (calleeName !== "defineContract") return null;
+  const args = callExpr.getArguments();
+  const optsArg = args[0];
+  if (!optsArg || !import_ts_morph8.Node.isObjectLiteralExpression(optsArg)) return null;
+  let query = null;
+  let body = null;
+  let response = "unknown";
+  let error = null;
+  let bodyZodText = null;
+  let queryZodText = null;
+  for (const prop of optsArg.getProperties()) {
+    if (!import_ts_morph8.Node.isPropertyAssignment(prop)) continue;
+    const propName = prop.getName();
+    const val = prop.getInitializer();
+    if (!val) continue;
+    if (propName === "query") {
+      query = memberType(val, "request", project);
+      queryZodText = val.getText();
+    } else if (propName === "body") {
+      body = memberType(val, "request", project);
+      bodyZodText = val.getText();
+    } else if (propName === "response") {
+      response = memberType(val, "response", project);
+    } else if (propName === "error") {
+      error = memberType(val, "response", project);
+    }
+  }
+  return { query, body, response, error, bodyZodText, queryZodText };
+}
+
+// src/discovery/pipe-schema.ts
+function pipeSchemaOf(decorator, project) {
+  for (const pipe of decorator.getArguments()) {
+    if (!import_ts_morph9.Node.isNewExpression(pipe) && !import_ts_morph9.Node.isCallExpression(pipe)) continue;
+    for (const arg of pipe.getArguments()) {
+      if (!couldBeSchema(arg)) continue;
+      const inferred = inferSchema(arg, project);
+      if (inferred.kind === "schema") {
+        return {
+          type: requestTypeOf(inferred.types),
+          optional: acceptsUndefined(inferred.types),
+          fields: requestFieldsOf(inferred.types)
+        };
+      }
+      if (inferred.kind === "unresolved") {
+        const fallback = syntacticZodType(arg, project);
+        if (fallback) {
+          return { type: fallback, optional: fallback.endsWith("| undefined"), fields: null };
+        }
+      }
+    }
+  }
+  return null;
+}
+function couldBeSchema(arg) {
+  return import_ts_morph9.Node.isIdentifier(arg) || import_ts_morph9.Node.isPropertyAccessExpression(arg) || import_ts_morph9.Node.isCallExpression(arg) || import_ts_morph9.Node.isAsExpression(arg) || import_ts_morph9.Node.isSatisfiesExpression(arg) || import_ts_morph9.Node.isParenthesizedExpression(arg);
+}
+function syntacticZodType(arg, project) {
+  let expr = arg;
+  if (import_ts_morph9.Node.isIdentifier(arg)) {
+    const resolved = resolveImportedVariable(arg.getText(), arg.getSourceFile(), project);
+    expr = resolved?.decl.getInitializer();
+  }
+  if (!expr || !import_ts_morph9.Node.isCallExpression(expr)) return null;
+  const type = zodAstToTs(expr);
+  return type === "unknown" ? null : type;
+}
+
 // src/discovery/dto-type-resolver.ts
 var WRAPPER_TYPES = {
   // MikroORM Ref/Reference/LoadedReference/IdentifiedReference are server-side
@@ -1749,22 +2446,22 @@ var PASSTHROUGH_UTILITY = /* @__PURE__ */ new Set([
 ]);
 function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /* @__PURE__ */ new Map()) {
   if (depth <= 0) return "unknown";
-  if (import_ts_morph6.Node.isArrayTypeNode(typeNode)) {
+  if (import_ts_morph10.Node.isArrayTypeNode(typeNode)) {
     const elementType = typeNode.getElementTypeNode();
     return `Array<${resolveTypeNodeToString(elementType, sourceFile, project, depth, subst)}>`;
   }
-  if (import_ts_morph6.Node.isUnionTypeNode(typeNode)) {
+  if (import_ts_morph10.Node.isUnionTypeNode(typeNode)) {
     return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth, subst)).join(" | ");
   }
-  if (import_ts_morph6.Node.isIntersectionTypeNode(typeNode)) {
+  if (import_ts_morph10.Node.isIntersectionTypeNode(typeNode)) {
     return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth, subst)).join(" & ");
   }
-  if (import_ts_morph6.Node.isParenthesizedTypeNode(typeNode)) {
+  if (import_ts_morph10.Node.isParenthesizedTypeNode(typeNode)) {
     return `(${resolveTypeNodeToString(typeNode.getTypeNode(), sourceFile, project, depth, subst)})`;
   }
-  if (import_ts_morph6.Node.isTypeReference(typeNode)) {
+  if (import_ts_morph10.Node.isTypeReference(typeNode)) {
     const typeName = typeNode.getTypeName();
-    const name = import_ts_morph6.Node.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
+    const name = import_ts_morph10.Node.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
     const bound = subst.get(name);
     if (bound !== void 0) return bound;
     if (name === "string" || name === "number" || name === "boolean") return name;
@@ -1787,13 +2484,13 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /
     dbg("unresolvable type:", name, "in", sourceFile.getFilePath());
     return "unknown";
   }
-  if (import_ts_morph6.Node.isTypeLiteral(typeNode)) {
+  if (import_ts_morph10.Node.isTypeLiteral(typeNode)) {
     const members = [];
     for (const member of typeNode.getMembers()) {
-      if (import_ts_morph6.Node.isPropertySignature(member)) {
+      if (import_ts_morph10.Node.isPropertySignature(member)) {
         const memberTypeNode = member.getTypeNode();
-        const memberType = memberTypeNode ? resolveTypeNodeToString(memberTypeNode, sourceFile, project, depth, subst) : "unknown";
-        members.push(`${member.getName()}${member.hasQuestionToken() ? "?" : ""}: ${memberType}`);
+        const memberType2 = memberTypeNode ? resolveTypeNodeToString(memberTypeNode, sourceFile, project, depth, subst) : "unknown";
+        members.push(`${member.getName()}${member.hasQuestionToken() ? "?" : ""}: ${memberType2}`);
       } else {
         members.push(member.getText());
       }
@@ -1801,11 +2498,11 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /
     return members.length > 0 ? `{ ${members.join("; ")} }` : "{}";
   }
   const kind = typeNode.getKind();
-  if (kind === import_ts_morph6.SyntaxKind.StringKeyword) return "string";
-  if (kind === import_ts_morph6.SyntaxKind.NumberKeyword) return "number";
-  if (kind === import_ts_morph6.SyntaxKind.BooleanKeyword) return "boolean";
-  if (kind === import_ts_morph6.SyntaxKind.UnknownKeyword) return "unknown";
-  if (kind === import_ts_morph6.SyntaxKind.AnyKeyword) return "unknown";
+  if (kind === import_ts_morph10.SyntaxKind.StringKeyword) return "string";
+  if (kind === import_ts_morph10.SyntaxKind.NumberKeyword) return "number";
+  if (kind === import_ts_morph10.SyntaxKind.BooleanKeyword) return "boolean";
+  if (kind === import_ts_morph10.SyntaxKind.UnknownKeyword) return "unknown";
+  if (kind === import_ts_morph10.SyntaxKind.AnyKeyword) return "unknown";
   return typeNode.getText();
 }
 function unwrapFirstTypeArg(typeNode, sourceFile, project, depth, mode, subst = /* @__PURE__ */ new Map()) {
@@ -1853,20 +2550,24 @@ function resolvePropertied(decl, sourceFile, project, depth, subst = /* @__PURE_
     const propName = prop.getName();
     const isOptional = prop.hasQuestionToken();
     const propTypeNode = prop.getTypeNode();
-    let propType = "unknown";
+    let propType2 = "unknown";
     if (propTypeNode) {
-      propType = resolveTypeNodeToString(propTypeNode, sourceFile, project, depth, subst);
+      propType2 = resolveTypeNodeToString(propTypeNode, sourceFile, project, depth, subst);
     }
-    lines.push(`${propName}${isOptional ? "?" : ""}: ${propType}`);
+    lines.push(`${propName}${isOptional ? "?" : ""}: ${propType2}`);
   }
   return `{ ${lines.join("; ")} }`;
 }
+function namedField(decorator) {
+  const first = decorator.getArguments()[0];
+  return first && import_ts_morph10.Node.isStringLiteral(first) ? first.getLiteralValue() : null;
+}
 function extractBodyType(method, sourceFile, project) {
   for (const param of method.getParameters()) {
     const bodyDecorator = param.getDecorators().find((d) => d.getName() === "Body");
-    if (!bodyDecorator) continue;
-    const bodyArgs = bodyDecorator.getArguments();
-    if (bodyArgs.length > 0) continue;
+    if (!bodyDecorator || namedField(bodyDecorator) !== null) continue;
+    const piped = pipeSchemaOf(bodyDecorator, project);
+    if (piped) return piped.type;
     const typeNode = param.getTypeNode();
     if (typeNode) {
       return resolveTypeNodeToString(typeNode, sourceFile, project, 3);
@@ -1874,11 +2575,16 @@ function extractBodyType(method, sourceFile, project) {
   }
   return null;
 }
+function hasPipeSchema(param, decoratorName, project) {
+  const decorator = param.getDecorators().find((d) => d.getName() === decoratorName);
+  return !!decorator && pipeSchemaOf(decorator, project) !== null;
+}
 function extractQueryType(method, sourceFile, project) {
   for (const param of method.getParameters()) {
     const queryDecorator = param.getDecorators().find((d) => d.getName() === "Query");
-    if (!queryDecorator) continue;
-    if (queryDecorator.getArguments().length > 0) continue;
+    if (!queryDecorator || namedField(queryDecorator) !== null) continue;
+    const piped = pipeSchemaOf(queryDecorator, project);
+    if (piped) return piped.type;
     const typeNode = param.getTypeNode();
     if (typeNode) {
       return resolveTypeNodeToString(typeNode, sourceFile, project, 3);
@@ -1888,10 +2594,13 @@ function extractQueryType(method, sourceFile, project) {
   for (const param of method.getParameters()) {
     const queryDecorator = param.getDecorators().find((d) => d.getName() === "Query");
     if (!queryDecorator) continue;
-    const queryArgs = queryDecorator.getArguments();
-    const nameArg = queryArgs[0];
-    if (!nameArg || !import_ts_morph6.Node.isStringLiteral(nameArg)) continue;
-    const queryName = nameArg.getLiteralValue();
+    const queryName = namedField(queryDecorator);
+    if (queryName === null) continue;
+    const piped = pipeSchemaOf(queryDecorator, project);
+    if (piped) {
+      entries.push(`${queryName}${piped.optional ? "?" : ""}: ${piped.type}`);
+      continue;
+    }
     const typeNode = param.getTypeNode();
     const queryType = typeNode ? resolveTypeNodeToString(typeNode, sourceFile, project, 3) : "string";
     entries.push(`${queryName}${isParamOptional(param) ? "?" : ""}: ${queryType}`);
@@ -1901,8 +2610,8 @@ function extractQueryType(method, sourceFile, project) {
 function isParamOptional(param) {
   if (param.hasQuestionToken() || param.hasInitializer()) return true;
   const typeNode = param.getTypeNode();
-  if (typeNode && import_ts_morph6.Node.isUnionTypeNode(typeNode)) {
-    return typeNode.getTypeNodes().some((t) => t.getKind() === import_ts_morph6.SyntaxKind.UndefinedKeyword);
+  if (typeNode && import_ts_morph10.Node.isUnionTypeNode(typeNode)) {
+    return typeNode.getTypeNodes().some((t) => t.getKind() === import_ts_morph10.SyntaxKind.UndefinedKeyword);
   }
   return false;
 }
@@ -1914,7 +2623,7 @@ function extractParamsType(method, sourceFile, project) {
     const paramArgs = paramDecorator.getArguments();
     if (paramArgs.length === 0) continue;
     const nameArg = paramArgs[0];
-    if (!import_ts_morph6.Node.isStringLiteral(nameArg)) continue;
+    if (!import_ts_morph10.Node.isStringLiteral(nameArg)) continue;
     const paramName = nameArg.getLiteralValue();
     const typeNode = param.getTypeNode();
     const paramType = typeNode ? resolveTypeNodeToString(typeNode, sourceFile, project, 3) : "string";
@@ -1922,6 +2631,22 @@ function extractParamsType(method, sourceFile, project) {
   }
   return entries.length > 0 ? `{ ${entries.join("; ")} }` : null;
 }
+function extractPipedParamTypes(method, project) {
+  const types = {};
+  for (const param of method.getParameters()) {
+    const paramDecorator = param.getDecorators().find((d) => d.getName() === "Param");
+    if (!paramDecorator) continue;
+    const piped = pipeSchemaOf(paramDecorator, project);
+    if (!piped) continue;
+    const name = namedField(paramDecorator);
+    if (name !== null) {
+      types[name] = piped.type;
+    } else {
+      for (const field of piped.fields ?? []) types[field.name] = field.type;
+    }
+  }
+  return Object.keys(types).length > 0 ? types : null;
+}
 function extractUploadedFiles(method) {
   const FILE = "File | Blob";
   const entries = [];
@@ -1935,28 +2660,28 @@ function extractUploadedFiles(method) {
   for (const decorator of method.getDecorators()) {
     if (decorator.getName() !== "UseInterceptors") continue;
     for (const arg of decorator.getArguments()) {
-      if (!import_ts_morph6.Node.isCallExpression(arg)) continue;
+      if (!import_ts_morph10.Node.isCallExpression(arg)) continue;
       const interceptor = arg.getExpression().getText();
       const callArgs = arg.getArguments();
       const firstArg2 = callArgs[0];
       if (interceptor === "FileInterceptor") {
-        if (firstArg2 && import_ts_morph6.Node.isStringLiteral(firstArg2)) {
+        if (firstArg2 && import_ts_morph10.Node.isStringLiteral(firstArg2)) {
           entries.push(`${firstArg2.getLiteralValue()}: ${FILE}`);
           multipart = true;
         }
       } else if (interceptor === "FilesInterceptor") {
-        if (firstArg2 && import_ts_morph6.Node.isStringLiteral(firstArg2)) {
+        if (firstArg2 && import_ts_morph10.Node.isStringLiteral(firstArg2)) {
           entries.push(`${firstArg2.getLiteralValue()}: Array<${FILE}>`);
           multipart = true;
         }
       } else if (interceptor === "FileFieldsInterceptor") {
-        if (firstArg2 && import_ts_morph6.Node.isArrayLiteralExpression(firstArg2)) {
+        if (firstArg2 && import_ts_morph10.Node.isArrayLiteralExpression(firstArg2)) {
           for (const el of firstArg2.getElements()) {
-            if (!import_ts_morph6.Node.isObjectLiteralExpression(el)) continue;
+            if (!import_ts_morph10.Node.isObjectLiteralExpression(el)) continue;
             const nameProp = el.getProperty("name");
-            if (nameProp && import_ts_morph6.Node.isPropertyAssignment(nameProp)) {
+            if (nameProp && import_ts_morph10.Node.isPropertyAssignment(nameProp)) {
               const init = nameProp.getInitializer();
-              if (init && import_ts_morph6.Node.isStringLiteral(init)) {
+              if (init && import_ts_morph10.Node.isStringLiteral(init)) {
                 entries.push(`${init.getLiteralValue()}: Array<${FILE}>`);
               }
             }
@@ -1976,13 +2701,13 @@ function extractResponseType(method, sourceFile, project) {
   if (apiResponseDecorator) {
     const args = apiResponseDecorator.getArguments();
     const optsArg = args[0];
-    if (optsArg && import_ts_morph6.Node.isObjectLiteralExpression(optsArg)) {
+    if (optsArg && import_ts_morph10.Node.isObjectLiteralExpression(optsArg)) {
       for (const prop of optsArg.getProperties()) {
-        if (!import_ts_morph6.Node.isPropertyAssignment(prop)) continue;
+        if (!import_ts_morph10.Node.isPropertyAssignment(prop)) continue;
         if (prop.getName() !== "type") continue;
         const val = prop.getInitializer();
         if (!val) continue;
-        if (import_ts_morph6.Node.isArrayLiteralExpression(val)) {
+        if (import_ts_morph10.Node.isArrayLiteralExpression(val)) {
           const elements = val.getElements();
           const firstEl = elements[0];
           if (elements.length > 0 && firstEl !== void 0) {
@@ -2003,24 +2728,24 @@ function extractResponseType(method, sourceFile, project) {
 }
 function apiResponseStatus(decorator) {
   const optsArg = decorator.getArguments()[0];
-  if (!optsArg || !import_ts_morph6.Node.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !import_ts_morph10.Node.isObjectLiteralExpression(optsArg)) return null;
   for (const prop of optsArg.getProperties()) {
-    if (!import_ts_morph6.Node.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph10.Node.isPropertyAssignment(prop)) continue;
     if (prop.getName() !== "status") continue;
     const val = prop.getInitializer();
-    if (val && import_ts_morph6.Node.isNumericLiteral(val)) return Number(val.getLiteralValue());
+    if (val && import_ts_morph10.Node.isNumericLiteral(val)) return Number(val.getLiteralValue());
   }
   return null;
 }
 function apiResponseTypeNode(decorator) {
   const optsArg = decorator.getArguments()[0];
-  if (!optsArg || !import_ts_morph6.Node.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !import_ts_morph10.Node.isObjectLiteralExpression(optsArg)) return null;
   for (const prop of optsArg.getProperties()) {
-    if (!import_ts_morph6.Node.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph10.Node.isPropertyAssignment(prop)) continue;
     if (prop.getName() !== "type") continue;
     const val = prop.getInitializer();
     if (!val) return null;
-    if (import_ts_morph6.Node.isArrayLiteralExpression(val)) {
+    if (import_ts_morph10.Node.isArrayLiteralExpression(val)) {
       const first = val.getElements()[0];
       return first ? { node: first, isArray: true } : null;
     }
@@ -2038,7 +2763,7 @@ function extractErrorType(method, sourceFile, project) {
     const inner = resolveIdentifierToClassType(typeInfo.node, sourceFile, project, 3);
     const type = typeInfo.isArray ? `Array<${inner}>` : inner;
     let ref = null;
-    if (import_ts_morph6.Node.isIdentifier(typeInfo.node)) {
+    if (import_ts_morph10.Node.isIdentifier(typeInfo.node)) {
       const name = typeInfo.node.getText();
       const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
       if (localDecl?.isExported()) {
@@ -2055,7 +2780,7 @@ function extractErrorType(method, sourceFile, project) {
   return null;
 }
 function resolveIdentifierToClassType(node, sourceFile, project, depth) {
-  if (!import_ts_morph6.Node.isIdentifier(node)) return "unknown";
+  if (!import_ts_morph10.Node.isIdentifier(node)) return "unknown";
   const name = node.getText();
   const resolved = findType(name, sourceFile, project);
   if (resolved) {
@@ -2075,9 +2800,9 @@ var STREAM_ENVELOPES = /* @__PURE__ */ new Set(["MessageEvent", "MessageEventLik
 var BINARY_RESPONSE_TYPES = /* @__PURE__ */ new Set(["StreamableFile", "Buffer"]);
 function detectBinaryResponse(method) {
   const node = unwrapNamedContainer(method.getReturnTypeNode(), /* @__PURE__ */ new Set(["Promise"]));
-  if (!node || !import_ts_morph6.Node.isTypeReference(node)) return false;
+  if (!node || !import_ts_morph10.Node.isTypeReference(node)) return false;
   const typeName = node.getTypeName();
-  const name = import_ts_morph6.Node.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = import_ts_morph10.Node.isIdentifier(typeName) ? typeName.getText() : "";
   return BINARY_RESPONSE_TYPES.has(name);
 }
 function detectStreamElement(method) {
@@ -2092,9 +2817,9 @@ function detectStreamElement(method) {
   return null;
 }
 function streamContainerElement(node) {
-  if (!node || !import_ts_morph6.Node.isTypeReference(node)) return null;
+  if (!node || !import_ts_morph10.Node.isTypeReference(node)) return null;
   const typeName = node.getTypeName();
-  const name = import_ts_morph6.Node.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = import_ts_morph10.Node.isIdentifier(typeName) ? typeName.getText() : "";
   if (STREAM_CONTAINERS.has(name) || STREAM_CONTAINERS_GENERATOR.has(name)) {
     return node.getTypeArguments()[0] ?? null;
   }
@@ -2104,9 +2829,9 @@ function hasAsQueryDecorator(method) {
   return method.getDecorators().some((d) => d.getName() === "AsQuery");
 }
 function unwrapNamedContainer(node, names) {
-  if (!node || !import_ts_morph6.Node.isTypeReference(node)) return node;
+  if (!node || !import_ts_morph10.Node.isTypeReference(node)) return node;
   const typeName = node.getTypeName();
-  const name = import_ts_morph6.Node.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = import_ts_morph10.Node.isIdentifier(typeName) ? typeName.getText() : "";
   if (names.has(name)) {
     return node.getTypeArguments()[0] ?? node;
   }
@@ -2127,19 +2852,20 @@ function extractDtoContract(method, sourceFile, project, mixin, controllerClass)
     body = body ?? bodyType;
   }
   const paramsType = extractParamsType(method, sourceFile, project);
+  const paramTypes = extractPipedParamTypes(method, project);
   const response = isStream ? resolveTypeNodeToString(streamElement, sourceFile, project, 3) : extractResponseType(method, sourceFile, project);
   const errorInfo = extractErrorType(method, sourceFile, project);
-  if (body === null && query === null && paramsType === null && response === "unknown" && errorInfo === null && filterInfo === null && !isStream && !uploads.multipart && !binaryResponse && !asQuery) {
+  if (body === null && query === null && paramsType === null && paramTypes === null && response === "unknown" && errorInfo === null && filterInfo === null && !isStream && !uploads.multipart && !binaryResponse && !asQuery) {
     return null;
   }
   let bodyRef = null;
   let queryRef = null;
   let responseRef = null;
   for (const param of method.getParameters()) {
-    if (param.getDecorators().some((d) => d.getName() === "Body") && param.getTypeNode()) {
+    if (param.getDecorators().some((d) => d.getName() === "Body") && param.getTypeNode() && !hasPipeSchema(param, "Body", project)) {
       bodyRef = resolveBodyQueryResponseRef(param.getTypeNode(), sourceFile, project);
     }
-    if (param.getDecorators().some((d) => d.getName() === "Query") && param.getTypeNode()) {
+    if (param.getDecorators().some((d) => d.getName() === "Query") && param.getTypeNode() && !hasPipeSchema(param, "Query", project)) {
       queryRef = resolveBodyQueryResponseRef(param.getTypeNode(), sourceFile, project);
     }
   }
@@ -2152,11 +2878,11 @@ function extractDtoContract(method, sourceFile, project, mixin, controllerClass)
     if (apiResp) {
       const args = apiResp.getArguments();
       const optsArg = args[0];
-      if (optsArg && import_ts_morph6.Node.isObjectLiteralExpression(optsArg)) {
+      if (optsArg && import_ts_morph10.Node.isObjectLiteralExpression(optsArg)) {
         for (const prop of optsArg.getProperties()) {
-          if (import_ts_morph6.Node.isPropertyAssignment(prop) && prop.getName() === "type") {
+          if (import_ts_morph10.Node.isPropertyAssignment(prop) && prop.getName() === "type") {
             const val = prop.getInitializer();
-            if (val && import_ts_morph6.Node.isIdentifier(val)) {
+            if (val && import_ts_morph10.Node.isIdentifier(val)) {
               const name = val.getText();
               const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
               if (localDecl?.isExported()) {
@@ -2192,6 +2918,7 @@ function extractDtoContract(method, sourceFile, project, mixin, controllerClass)
     response,
     error: errorInfo?.type ?? null,
     params: paramsType,
+    paramTypes,
     queryRef,
     bodyRef,
     responseRef,
@@ -2212,6 +2939,7 @@ function extractDtoContract(method, sourceFile, project, mixin, controllerClass)
 function resolveParamClass(method, decoratorName, sourceFile, project) {
   for (const param of method.getParameters()) {
     if (!param.getDecorators().some((d) => d.getName() === decoratorName)) continue;
+    if (hasPipeSchema(param, decoratorName, project)) continue;
     const typeNode = param.getTypeNode();
     if (!typeNode) continue;
     const text = typeNode.getText().replace(/\[\]$/, "");
@@ -2224,129 +2952,6 @@ function resolveParamClass(method, decoratorName, sourceFile, project) {
   return null;
 }
 
-// src/discovery/zod-ast-to-ts.ts
-var import_ts_morph7 = require("ts-morph");
-function zodAstToTs(node) {
-  if (!import_ts_morph7.Node.isCallExpression(node)) return "unknown";
-  const expr = node.getExpression();
-  if (import_ts_morph7.Node.isPropertyAccessExpression(expr)) {
-    const methodName = expr.getName();
-    const receiver = expr.getExpression();
-    if (methodName === "optional") {
-      return `${zodAstToTs(receiver)} | undefined`;
-    }
-    if (methodName === "nullable") {
-      return `${zodAstToTs(receiver)} | null`;
-    }
-    const args = node.getArguments();
-    switch (methodName) {
-      case "string":
-        return "string";
-      case "number":
-        return "number";
-      case "boolean":
-        return "boolean";
-      case "unknown":
-        return "unknown";
-      case "any":
-        return "unknown";
-      case "literal": {
-        const lit = args[0];
-        if (!lit) return "unknown";
-        if (import_ts_morph7.Node.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
-        if (import_ts_morph7.Node.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
-        if (lit.getKind() === import_ts_morph7.SyntaxKind.TrueKeyword) return "true";
-        if (lit.getKind() === import_ts_morph7.SyntaxKind.FalseKeyword) return "false";
-        return "unknown";
-      }
-      case "enum": {
-        const arrArg = args[0];
-        if (!arrArg || !import_ts_morph7.Node.isArrayLiteralExpression(arrArg)) return "unknown";
-        const members = arrArg.getElements().map(
-          (el) => import_ts_morph7.Node.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown"
-        );
-        return members.join(" | ");
-      }
-      case "array": {
-        const inner = args[0];
-        if (!inner) return "unknown";
-        return `Array<${zodAstToTs(inner)}>`;
-      }
-      case "object": {
-        const objArg = args[0];
-        if (!objArg || !import_ts_morph7.Node.isObjectLiteralExpression(objArg)) return "unknown";
-        const lines = [];
-        for (const prop of objArg.getProperties()) {
-          if (!import_ts_morph7.Node.isPropertyAssignment(prop)) continue;
-          const key = prop.getName();
-          const valNode = prop.getInitializer();
-          if (!valNode) continue;
-          const tsType = zodAstToTs(valNode);
-          const isOpt = isOptionalChain(valNode);
-          lines.push(`${key}${isOpt ? "?" : ""}: ${tsType}`);
-        }
-        return `{ ${lines.join("; ")} }`;
-      }
-      case "union": {
-        const arrArg = args[0];
-        if (!arrArg || !import_ts_morph7.Node.isArrayLiteralExpression(arrArg)) return "unknown";
-        return arrArg.getElements().map(zodAstToTs).join(" | ");
-      }
-      case "record": {
-        const valArg = args.length === 1 ? args[0] : args[1];
-        if (!valArg) return "unknown";
-        return `Record<string, ${zodAstToTs(valArg)}>`;
-      }
-      case "tuple": {
-        const arrArg = args[0];
-        if (!arrArg || !import_ts_morph7.Node.isArrayLiteralExpression(arrArg)) return "unknown";
-        return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
-      }
-      default:
-        return "unknown";
-    }
-  }
-  return "unknown";
-}
-function isOptionalChain(node) {
-  if (!import_ts_morph7.Node.isCallExpression(node)) return false;
-  const expr = node.getExpression();
-  return import_ts_morph7.Node.isPropertyAccessExpression(expr) && expr.getName() === "optional";
-}
-function parseDefineContractCall(callExpr) {
-  if (!import_ts_morph7.Node.isCallExpression(callExpr)) return null;
-  const callee = callExpr.getExpression();
-  const calleeName = import_ts_morph7.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph7.Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
-  if (calleeName !== "defineContract") return null;
-  const args = callExpr.getArguments();
-  const optsArg = args[0];
-  if (!optsArg || !import_ts_morph7.Node.isObjectLiteralExpression(optsArg)) return null;
-  let query = null;
-  let body = null;
-  let response = "unknown";
-  let error = null;
-  let bodyZodText = null;
-  let queryZodText = null;
-  for (const prop of optsArg.getProperties()) {
-    if (!import_ts_morph7.Node.isPropertyAssignment(prop)) continue;
-    const propName = prop.getName();
-    const val = prop.getInitializer();
-    if (!val) continue;
-    if (propName === "query") {
-      query = zodAstToTs(val);
-      queryZodText = val.getText();
-    } else if (propName === "body") {
-      body = zodAstToTs(val);
-      bodyZodText = val.getText();
-    } else if (propName === "response") {
-      response = zodAstToTs(val);
-    } else if (propName === "error") {
-      error = zodAstToTs(val);
-    }
-  }
-  return { query, body, response, error, bodyZodText, queryZodText };
-}
-
 // src/discovery/contracts-fast.ts
 function resolveTsconfigPath(cwd, tsconfig) {
   return tsconfig ? (0, import_node_path3.resolve)(tsconfig) : (0, import_node_path3.join)(cwd, "tsconfig.json");
@@ -2358,25 +2963,25 @@ var NO_TSCONFIG_OPTIONS = {
 };
 function loadDiscoveryTsconfig(tsconfigPath) {
   if (!(0, import_node_fs.existsSync)(tsconfigPath)) return { options: null, files: [] };
-  const read = import_ts_morph8.ts.readConfigFile(tsconfigPath, (path) => import_ts_morph8.ts.sys.readFile(path));
+  const read = import_ts_morph11.ts.readConfigFile(tsconfigPath, (path) => import_ts_morph11.ts.sys.readFile(path));
   if (read.error) {
     return {
       options: null,
       files: [tsconfigPath],
-      error: import_ts_morph8.ts.flattenDiagnosticMessageText(read.error.messageText, " ")
+      error: import_ts_morph11.ts.flattenDiagnosticMessageText(read.error.messageText, " ")
     };
   }
   const host = {
-    useCaseSensitiveFileNames: import_ts_morph8.ts.sys.useCaseSensitiveFileNames,
+    useCaseSensitiveFileNames: import_ts_morph11.ts.sys.useCaseSensitiveFileNames,
     // The one line that keeps a tsconfig from being a filesystem walk.
     readDirectory: () => [],
-    fileExists: (path) => import_ts_morph8.ts.sys.fileExists(path),
+    fileExists: (path) => import_ts_morph11.ts.sys.fileExists(path),
     // `extends` is resolved through the host, so a consumer whose `paths` live
     // in a base tsconfig keeps working.
-    readFile: (path) => import_ts_morph8.ts.sys.readFile(path)
+    readFile: (path) => import_ts_morph11.ts.sys.readFile(path)
   };
-  const sourceFile = import_ts_morph8.ts.readJsonConfigFile(tsconfigPath, (path) => import_ts_morph8.ts.sys.readFile(path));
-  const parsed = import_ts_morph8.ts.parseJsonSourceFileConfigFileContent(
+  const sourceFile = import_ts_morph11.ts.readJsonConfigFile(tsconfigPath, (path) => import_ts_morph11.ts.sys.readFile(path));
+  const parsed = import_ts_morph11.ts.parseJsonSourceFileConfigFileContent(
     sourceFile,
     host,
     (0, import_node_path3.dirname)(tsconfigPath),
@@ -2399,7 +3004,7 @@ function createDiscoveryProject(tsconfigPath, tsconfig = loadDiscoveryTsconfig(t
       `[nestjs-codegen/fast] Could not load ${tsconfigPath}: ${tsconfig.error} \u2014 continuing WITHOUT its compiler options, so path alias imports (e.g. '@/...') will not resolve and controllers extending an alias-imported factory will contribute NO routes to the generated client.`
     );
   }
-  return new import_ts_morph8.Project({
+  return new import_ts_morph11.Project({
     compilerOptions: tsconfig.options ?? { ...NO_TSCONFIG_OPTIONS },
     skipAddingFilesFromTsConfig: true,
     skipLoadingLibFiles: true,
@@ -2504,15 +3109,16 @@ var PersistentDiscovery = class _PersistentDiscovery {
     clearTypeResolutionCaches(this.project);
     clearEnumCache(this.project);
     clearMixinTypeProject();
+    clearSchemaTypeProject(this.project);
     return extractRoutesFrom(this.project, this.controllerPaths);
   }
 };
 function decoratorStringArg(decoratorExpr) {
   if (!decoratorExpr) return void 0;
-  if (import_ts_morph8.Node.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
-  if (import_ts_morph8.Node.isArrayLiteralExpression(decoratorExpr)) {
+  if (import_ts_morph11.Node.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
+  if (import_ts_morph11.Node.isArrayLiteralExpression(decoratorExpr)) {
     const first = decoratorExpr.getElements()[0];
-    if (first && import_ts_morph8.Node.isStringLiteral(first)) return first.getLiteralValue();
+    if (first && import_ts_morph11.Node.isStringLiteral(first)) return first.getLiteralValue();
   }
   return void 0;
 }
@@ -2633,9 +3239,9 @@ function extractContractRoute(args) {
   let contractDef = null;
   let bodyZodRef = null;
   let queryZodRef = null;
-  if (import_ts_morph8.Node.isCallExpression(firstDecoratorArg)) {
-    contractDef = parseDefineContractCall(firstDecoratorArg);
-  } else if (import_ts_morph8.Node.isIdentifier(firstDecoratorArg)) {
+  if (import_ts_morph11.Node.isCallExpression(firstDecoratorArg)) {
+    contractDef = parseDefineContractCall(firstDecoratorArg, project);
+  } else if (import_ts_morph11.Node.isIdentifier(firstDecoratorArg)) {
     const identName = firstDecoratorArg.getText();
     const resolvedVar = resolveImportedVariable(identName, sourceFile, project);
     if (!resolvedVar) {
@@ -2647,7 +3253,7 @@ function extractContractRoute(args) {
     const { decl: varDecl, file: declFile } = resolvedVar;
     const initializer = varDecl.getInitializer();
     if (!initializer) return null;
-    contractDef = parseDefineContractCall(initializer);
+    contractDef = parseDefineContractCall(initializer, project);
     if (contractDef && varDecl.isExported()) {
       const filePath = declFile.getFilePath();
       if (contractDef.body !== null) {
@@ -2718,6 +3324,7 @@ function extractDtoRoute(args) {
       body: dtoContract?.body ?? null,
       response: mixinResponse ?? dtoContract?.response ?? "unknown",
       error: dtoContract?.error ?? null,
+      paramTypes: dtoContract?.paramTypes ?? null,
       queryRef: dtoContract?.queryRef ?? null,
       bodyRef: dtoContract?.bodyRef ?? null,
       responseRef: dtoContract?.responseRef ?? null,
@@ -2789,32 +3396,86 @@ function extractFromSourceFile(sourceFile, project) {
   return routes;
 }
 
-// src/generate.ts
-var import_promises11 = require("fs/promises");
-var import_node_path15 = require("path");
-
 // src/discovery/pages.ts
 var import_promises2 = require("fs/promises");
 var import_node_path4 = require("path");
 var import_fast_glob2 = __toESM(require("fast-glob"), 1);
 var NON_PAGE_FILE_RE = /\.(?:test|spec|stories|story)\.(?:tsx?|jsx?|vue|svelte)$/i;
+var MAGIC_SEGMENT_RE = /[*?{}[\]()!]/;
+function globStaticBase(glob) {
+  const segments = glob.split("/");
+  const staticSegments = [];
+  for (const segment of segments.slice(0, -1)) {
+    if (MAGIC_SEGMENT_RE.test(segment)) break;
+    staticSegments.push(segment);
+  }
+  return staticSegments.join("/");
+}
 async function discoverPages(opts) {
-  const allFiles = await (0, import_fast_glob2.default)(opts.glob, { cwd: opts.cwd, absolute: true });
-  const files = allFiles.filter((f) => !NON_PAGE_FILE_RE.test(f));
-  files.sort();
-  const globStatic = opts.glob.split("*")[0]?.replace(/\/$/, "") ?? "";
-  const pagesBase = (0, import_node_path4.join)(opts.cwd, globStatic);
+  const globs = typeof opts.glob === "string" ? [opts.glob] : opts.glob;
+  const prefix = opts.prefix ?? "";
+  const scope = opts.scope ?? "default";
+  const seenFiles = /* @__PURE__ */ new Set();
   const out = [];
-  for (const file of files) {
-    const rel = (0, import_node_path4.relative)(opts.cwd, file);
-    const nameRel = (0, import_node_path4.relative)(pagesBase, file);
-    const name = computeName(nameRel, opts.componentNameStrategy);
-    const source = await (0, import_promises2.readFile)(file, "utf8");
-    const propsSource = extractPropsSource(source, opts.propsExport);
-    out.push({ name, absolutePath: file, relativePath: rel, propsSource });
+  for (const glob of globs) {
+    const files = (await (0, import_fast_glob2.default)(glob, { cwd: opts.cwd, absolute: true })).filter((f) => !NON_PAGE_FILE_RE.test(f) && !seenFiles.has(f)).sort();
+    const pagesBase = (0, import_node_path4.join)(opts.cwd, globStaticBase(glob));
+    for (const file of files) {
+      seenFiles.add(file);
+      const rel = (0, import_node_path4.relative)(opts.cwd, file);
+      const nameRel = (0, import_node_path4.relative)(pagesBase, file).split(import_node_path4.sep).join("/");
+      const name = `${prefix}${computeName(nameRel, opts.componentNameStrategy)}`;
+      const source = await (0, import_promises2.readFile)(file, "utf8");
+      const propsSource = extractPropsSource(source, opts.propsExport);
+      out.push({ name, absolutePath: file, relativePath: rel, propsSource, scope });
+    }
+  }
+  assertUniqueNames(out);
+  return out;
+}
+async function discoverPageScopes(config) {
+  const pages = config.pages;
+  if (!pages) return [];
+  const common = { cwd: config.codegen.cwd, propsExport: pages.propsExport };
+  const out = await discoverPages({
+    ...common,
+    glob: pages.glob,
+    componentNameStrategy: pages.componentNameStrategy
+  });
+  for (const [scope, scopeConfig] of Object.entries(pages.scopes ?? {})) {
+    out.push(
+      ...await discoverPages({
+        ...common,
+        glob: scopeConfig.glob,
+        componentNameStrategy: scopeConfig.componentNameStrategy,
+        prefix: scopeConfig.prefix,
+        scope
+      })
+    );
   }
+  assertUniqueNames(out);
   return out;
 }
+function allPageGlobs(config) {
+  if (!config.pages) return [];
+  const asList = (glob) => typeof glob === "string" ? [glob] : glob;
+  return [
+    ...asList(config.pages.glob),
+    ...Object.values(config.pages.scopes ?? {}).flatMap((scope) => asList(scope.glob))
+  ];
+}
+function assertUniqueNames(pages) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const previous = byName.get(page.name);
+    if (previous) {
+      throw new Error(
+        `Two Inertia pages resolve to the component name "${page.name}": ${previous.relativePath} (scope "${previous.scope}") and ${page.relativePath} (scope "${page.scope}"). Give one of them another name, directory or scope prefix.`
+      );
+    }
+    byName.set(page.name, page);
+  }
+}
 function computeName(rel, strat) {
   if (typeof strat === "function") return strat(rel);
   const noExt = rel.replace(/\.(tsx?|vue|svelte)$/, "");
@@ -2845,9 +3506,13 @@ function extractPropsSource(source, exportName) {
   return source.slice(start);
 }
 
+// src/generate.ts
+var import_promises11 = require("fs/promises");
+var import_node_path15 = require("path");
+
 // src/discovery/shared-props.ts
 var import_node_path5 = require("path");
-var import_ts_morph9 = require("ts-morph");
+var import_ts_morph12 = require("ts-morph");
 function discoverSharedProps(project, moduleEntry) {
   try {
     let sourceFile = project.getSourceFile(moduleEntry);
@@ -2873,14 +3538,14 @@ function discoverSharedPropsFromConfig(config) {
     const tsconfigPath = config.app.tsconfig ?? (0, import_node_path5.join)(config.codegen.cwd, "tsconfig.json");
     let project;
     try {
-      project = new import_ts_morph9.Project({
+      project = new import_ts_morph12.Project({
         tsConfigFilePath: tsconfigPath,
         skipAddingFilesFromTsConfig: true,
         skipLoadingLibFiles: true,
         skipFileDependencyResolution: true
       });
     } catch {
-      project = new import_ts_morph9.Project({
+      project = new import_ts_morph12.Project({
         skipAddingFilesFromTsConfig: true,
         skipLoadingLibFiles: true,
         skipFileDependencyResolution: true,
@@ -2893,13 +3558,13 @@ function discoverSharedPropsFromConfig(config) {
   }
 }
 function findForRootCall(sourceFile) {
-  const callExpressions = sourceFile.getDescendantsOfKind(import_ts_morph9.SyntaxKind.CallExpression);
+  const callExpressions = sourceFile.getDescendantsOfKind(import_ts_morph12.SyntaxKind.CallExpression);
   for (const call of callExpressions) {
     const expr = call.getExpression();
-    if (!import_ts_morph9.Node.isPropertyAccessExpression(expr)) continue;
+    if (!import_ts_morph12.Node.isPropertyAccessExpression(expr)) continue;
     const methodName = expr.getName();
     const objectExpr = expr.getExpression();
-    if (methodName === "forRoot" && import_ts_morph9.Node.isIdentifier(objectExpr)) {
+    if (methodName === "forRoot" && import_ts_morph12.Node.isIdentifier(objectExpr)) {
       const name = objectExpr.getText();
       if (name === "InertiaModule") {
         return call;
@@ -2909,19 +3574,19 @@ function findForRootCall(sourceFile) {
   return null;
 }
 function findShareInitializer(forRootCall) {
-  if (!import_ts_morph9.Node.isCallExpression(forRootCall)) return null;
+  if (!import_ts_morph12.Node.isCallExpression(forRootCall)) return null;
   const args = forRootCall.getArguments();
   const firstArg2 = args[0];
-  if (!firstArg2 || !import_ts_morph9.Node.isObjectLiteralExpression(firstArg2)) return null;
+  if (!firstArg2 || !import_ts_morph12.Node.isObjectLiteralExpression(firstArg2)) return null;
   for (const prop of firstArg2.getProperties()) {
-    if (import_ts_morph9.Node.isPropertyAssignment(prop) && prop.getName() === "share") {
+    if (import_ts_morph12.Node.isPropertyAssignment(prop) && prop.getName() === "share") {
       return prop.getInitializer() ?? null;
     }
   }
   return null;
 }
 function extractShareType(node, sourceFile, project) {
-  if (import_ts_morph9.Node.isIdentifier(node)) {
+  if (import_ts_morph12.Node.isIdentifier(node)) {
     const ref = resolveIdentifierToImportRef(node, sourceFile, project);
     if (ref) {
       return {
@@ -2931,22 +3596,22 @@ function extractShareType(node, sourceFile, project) {
       };
     }
   }
-  if (import_ts_morph9.Node.isArrowFunction(node)) {
+  if (import_ts_morph12.Node.isArrowFunction(node)) {
     const result = extractFromFunctionLike(node, sourceFile);
     return result ? { ...result, isImportRef: false } : null;
   }
-  if (import_ts_morph9.Node.isFunctionExpression(node)) {
+  if (import_ts_morph12.Node.isFunctionExpression(node)) {
     const result = extractFromFunctionLike(node, sourceFile);
     return result ? { ...result, isImportRef: false } : null;
   }
-  if (import_ts_morph9.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph12.Node.isObjectLiteralExpression(node)) {
     const result = extractFromObjectLiteral(node);
     return result ? { ...result, isImportRef: false } : null;
   }
   return null;
 }
 function resolveIdentifierToImportRef(id, sourceFile, project) {
-  if (!import_ts_morph9.Node.isIdentifier(id)) return null;
+  if (!import_ts_morph12.Node.isIdentifier(id)) return null;
   const name = id.getText();
   const localFunc = sourceFile.getFunction(name);
   if (localFunc?.isExported()) {
@@ -2980,37 +3645,37 @@ function resolveIdentifierToImportRef(id, sourceFile, project) {
   return null;
 }
 function extractFromFunctionLike(node, _sourceFile) {
-  const returnTypeNode = import_ts_morph9.Node.isArrowFunction(node) || import_ts_morph9.Node.isFunctionExpression(node) ? node.getReturnTypeNode() : null;
+  const returnTypeNode = import_ts_morph12.Node.isArrowFunction(node) || import_ts_morph12.Node.isFunctionExpression(node) ? node.getReturnTypeNode() : null;
   if (returnTypeNode) {
     return extractFromReturnTypeAnnotation(returnTypeNode);
   }
-  if (import_ts_morph9.Node.isArrowFunction(node)) {
+  if (import_ts_morph12.Node.isArrowFunction(node)) {
     const body = node.getBody();
-    if (import_ts_morph9.Node.isParenthesizedExpression(body)) {
+    if (import_ts_morph12.Node.isParenthesizedExpression(body)) {
       const inner = body.getExpression();
-      if (import_ts_morph9.Node.isObjectLiteralExpression(inner)) {
+      if (import_ts_morph12.Node.isObjectLiteralExpression(inner)) {
         return extractFromObjectLiteral(inner);
       }
     }
-    if (import_ts_morph9.Node.isObjectLiteralExpression(body)) {
+    if (import_ts_morph12.Node.isObjectLiteralExpression(body)) {
       return extractFromObjectLiteral(body);
     }
-    if (import_ts_morph9.Node.isBlock(body)) {
+    if (import_ts_morph12.Node.isBlock(body)) {
       return extractFromBlockReturn(body);
     }
   }
-  if (import_ts_morph9.Node.isFunctionExpression(node)) {
+  if (import_ts_morph12.Node.isFunctionExpression(node)) {
     const body = node.getBody();
-    if (import_ts_morph9.Node.isBlock(body)) {
+    if (import_ts_morph12.Node.isBlock(body)) {
       return extractFromBlockReturn(body);
     }
   }
   return null;
 }
 function extractFromReturnTypeAnnotation(typeNode) {
-  if (import_ts_morph9.Node.isTypeReference(typeNode)) {
+  if (import_ts_morph12.Node.isTypeReference(typeNode)) {
     const typeName = typeNode.getTypeName();
-    if (import_ts_morph9.Node.isIdentifier(typeName) && typeName.getText() === "Promise") {
+    if (import_ts_morph12.Node.isIdentifier(typeName) && typeName.getText() === "Promise") {
       const typeArgs = typeNode.getTypeArguments();
       const firstArg2 = typeArgs[0];
       if (firstArg2) {
@@ -3019,10 +3684,10 @@ function extractFromReturnTypeAnnotation(typeNode) {
       return null;
     }
   }
-  if (import_ts_morph9.Node.isTypeLiteral(typeNode)) {
+  if (import_ts_morph12.Node.isTypeLiteral(typeNode)) {
     const properties = [];
     for (const member of typeNode.getMembers()) {
-      if (import_ts_morph9.Node.isPropertySignature(member)) {
+      if (import_ts_morph12.Node.isPropertySignature(member)) {
         const name = member.getName();
         const memberTypeNode = member.getTypeNode();
         const type = memberTypeNode ? memberTypeNode.getText() : "unknown";
@@ -3036,19 +3701,19 @@ function extractFromReturnTypeAnnotation(typeNode) {
   return null;
 }
 function extractFromBlockReturn(block) {
-  if (!import_ts_morph9.Node.isBlock(block)) return null;
+  if (!import_ts_morph12.Node.isBlock(block)) return null;
   const statements = block.getStatements();
   for (let i = statements.length - 1; i >= 0; i--) {
     const stmt = statements[i];
-    if (!import_ts_morph9.Node.isReturnStatement(stmt)) continue;
+    if (!import_ts_morph12.Node.isReturnStatement(stmt)) continue;
     const expr = stmt.getExpression();
     if (!expr) continue;
-    if (import_ts_morph9.Node.isObjectLiteralExpression(expr)) {
+    if (import_ts_morph12.Node.isObjectLiteralExpression(expr)) {
       return extractFromObjectLiteral(expr);
     }
-    if (import_ts_morph9.Node.isParenthesizedExpression(expr)) {
+    if (import_ts_morph12.Node.isParenthesizedExpression(expr)) {
       const inner = expr.getExpression();
-      if (import_ts_morph9.Node.isObjectLiteralExpression(inner)) {
+      if (import_ts_morph12.Node.isObjectLiteralExpression(inner)) {
         return extractFromObjectLiteral(inner);
       }
     }
@@ -3057,10 +3722,10 @@ function extractFromBlockReturn(block) {
   return null;
 }
 function extractFromObjectLiteral(objLiteral) {
-  if (!import_ts_morph9.Node.isObjectLiteralExpression(objLiteral)) return null;
+  if (!import_ts_morph12.Node.isObjectLiteralExpression(objLiteral)) return null;
   const properties = [];
   for (const prop of objLiteral.getProperties()) {
-    if (!import_ts_morph9.Node.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph12.Node.isPropertyAssignment(prop)) continue;
     const name = prop.getName();
     const initializer = prop.getInitializer();
     if (!initializer) continue;
@@ -3072,21 +3737,21 @@ function extractFromObjectLiteral(objLiteral) {
   return { typeString, properties, isImportRef: false };
 }
 function inferExpressionType(node) {
-  if (import_ts_morph9.Node.isStringLiteral(node)) return "string";
-  if (import_ts_morph9.Node.isTemplateExpression(node) || import_ts_morph9.Node.isNoSubstitutionTemplateLiteral(node))
+  if (import_ts_morph12.Node.isStringLiteral(node)) return "string";
+  if (import_ts_morph12.Node.isTemplateExpression(node) || import_ts_morph12.Node.isNoSubstitutionTemplateLiteral(node))
     return "string";
-  if (import_ts_morph9.Node.isNumericLiteral(node)) return "number";
-  if (node.getKind() === import_ts_morph9.SyntaxKind.TrueKeyword || node.getKind() === import_ts_morph9.SyntaxKind.FalseKeyword) {
+  if (import_ts_morph12.Node.isNumericLiteral(node)) return "number";
+  if (node.getKind() === import_ts_morph12.SyntaxKind.TrueKeyword || node.getKind() === import_ts_morph12.SyntaxKind.FalseKeyword) {
     return "boolean";
   }
-  if (node.getKind() === import_ts_morph9.SyntaxKind.NullKeyword) return "null";
-  if (import_ts_morph9.Node.isIdentifier(node) && node.getText() === "undefined") return "undefined";
-  if (import_ts_morph9.Node.isObjectLiteralExpression(node)) {
+  if (node.getKind() === import_ts_morph12.SyntaxKind.NullKeyword) return "null";
+  if (import_ts_morph12.Node.isIdentifier(node) && node.getText() === "undefined") return "undefined";
+  if (import_ts_morph12.Node.isObjectLiteralExpression(node)) {
     const props = node.getProperties();
     if (props.length === 0) return "Record<string, unknown>";
     const entries = [];
     for (const prop of props) {
-      if (!import_ts_morph9.Node.isPropertyAssignment(prop)) continue;
+      if (!import_ts_morph12.Node.isPropertyAssignment(prop)) continue;
       const key = prop.getName();
       const init = prop.getInitializer();
       if (!init) continue;
@@ -3095,23 +3760,23 @@ function inferExpressionType(node) {
     if (entries.length === 0) return "Record<string, unknown>";
     return `{ ${entries.join("; ")} }`;
   }
-  if (import_ts_morph9.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph12.Node.isArrayLiteralExpression(node)) {
     const elements = node.getElements();
     if (elements.length === 0) return "Array<unknown>";
     const first = elements[0];
     if (first) return `Array<${inferExpressionType(first)}>`;
     return "Array<unknown>";
   }
-  if (import_ts_morph9.Node.isConditionalExpression(node)) {
+  if (import_ts_morph12.Node.isConditionalExpression(node)) {
     const whenTrue = inferExpressionType(node.getWhenTrue());
     const whenFalse = inferExpressionType(node.getWhenFalse());
     if (whenTrue === whenFalse) return whenTrue;
     return `${whenTrue} | ${whenFalse}`;
   }
-  if (import_ts_morph9.Node.isParenthesizedExpression(node)) {
+  if (import_ts_morph12.Node.isParenthesizedExpression(node)) {
     return inferExpressionType(node.getExpression());
   }
-  if (import_ts_morph9.Node.isAsExpression(node)) {
+  if (import_ts_morph12.Node.isAsExpression(node)) {
     const typeNode = node.getTypeNode();
     if (typeNode) return typeNode.getText();
   }
@@ -3124,7 +3789,7 @@ var import_node_path7 = require("path");
 
 // src/extension/registry.ts
 var import_node_path6 = require("path");
-var import_ts_morph10 = require("ts-morph");
+var import_ts_morph13 = require("ts-morph");
 function resolveApiSlots(extensions) {
   let layer;
   let layerOwner;
@@ -3175,7 +3840,7 @@ function createExtensionContext(config, getRoutes, trackedInputs) {
     },
     project() {
       if (!project) {
-        project = new import_ts_morph10.Project({
+        project = new import_ts_morph13.Project({
           skipAddingFilesFromTsConfig: true,
           skipLoadingLibFiles: true,
           skipFileDependencyResolution: true,
@@ -3293,10 +3958,11 @@ function insertIntoTree(tree, segments, leaf, fullName) {
     insertIntoTree(branch.children, rest, leaf, fullName);
   }
 }
-function buildParamsType(params) {
+function buildParamsType(params, paramTypes) {
   const pathParams = params.filter((p) => p.source === "path");
   if (pathParams.length === 0) return "never";
-  return `{ ${pathParams.map((p) => `${p.name}: string`).join("; ")} }`;
+  const typeOf = (name) => paramTypes && Object.hasOwn(paramTypes, name) && paramTypes[name] || "string";
+  return `{ ${pathParams.map((p) => `${p.name}: ${typeOf(p.name)}`).join("; ")} }`;
 }
 function hasPathParams(params) {
   return params.some((p) => p.source === "path");
@@ -3390,7 +4056,7 @@ function emitRouterTypeBlock(tree, indent, outDir, serialization) {
       }
       const response = buildResponseType(c, outDir, serialization);
       const error = buildErrorType(c);
-      const params = buildParamsType(c.params);
+      const params = buildParamsType(c.params, c.contractSource.paramTypes);
       const safeMethod = JSON.stringify(method);
       const safeUrl = JSON.stringify(c.path);
       const filterLiterals = filterFieldLiterals(c.contractSource.filterFields);
@@ -3478,28 +4144,28 @@ function renderFetcherRequest(req, binaryResponse) {
 }
 function emitReqHelper() {
   return [
-    "/** Awaitable request handle. `await api.x.y({...})` runs the fetch; extensions add query/mutation helpers. */",
-    "type __Req<R> = {",
-    "  then<T1 = R, T2 = never>(",
+    "/** An awaitable request handle: a lazy, memoized `Promise` that also carries `fetch()` and the members extensions add. */",
+    "export type RequestHandle<R, M = {}> = Promise<R> & { fetch(): Promise<R> } & M;",
+    "class __Request<R> extends Promise<R> {",
+    "  static override get [Symbol.species](): PromiseConstructor {",
+    "    return Promise;",
+    "  }",
+    "  private __run: () => Promise<R>;",
+    "  private __p: Promise<R> | undefined;",
+    "  constructor(run: () => Promise<R>) {",
+    "    super(() => {});",
+    "    this.__run = run;",
+    "  }",
+    "  override then<T1 = R, T2 = never>(",
     "    onfulfilled?: ((value: R) => T1 | PromiseLike<T1>) | null,",
     "    onrejected?: ((reason: unknown) => T2 | PromiseLike<T2>) | null,",
-    "  ): Promise<T1 | T2>;",
-    "  catch<T = never>(onrejected?: ((reason: unknown) => T | PromiseLike<T>) | null): Promise<R | T>;",
-    "  finally(onfinally?: (() => void) | null): Promise<R>;",
-    "  fetch(): Promise<R>;",
-    "};",
-    "function __req<R>(run: () => Promise<R>): __Req<R> {",
-    "  let __p: Promise<R> | undefined;",
-    "  const __promise = () => {",
-    "    __p ??= run();",
-    "    return __p;",
-    "  };",
-    "  return {",
-    "    then: (onfulfilled, onrejected) => __promise().then(onfulfilled, onrejected),",
-    "    catch: (onrejected) => __promise().catch(onrejected),",
-    "    finally: (onfinally) => __promise().finally(onfinally),",
-    "    fetch: run,",
-    "  };",
+    "  ): Promise<T1 | T2> {",
+    "    this.__p ??= this.__run();",
+    "    return this.__p.then(onfulfilled, onrejected);",
+    "  }",
+    "}",
+    "function __req<R, M extends object = {}>(run: () => Promise<R>, members?: M): RequestHandle<R, M> {",
+    "  return Object.assign(new __Request<R>(run), { fetch: run }, members) as RequestHandle<R, M>;",
     "}",
     ""
   ];
@@ -3517,18 +4183,26 @@ function emitFilterFieldGuard() {
   ];
 }
 function renderLeaf(pad, objKey, req, requestExpr, members, streamExpr) {
-  const lines = [`${pad}${objKey}: (input?: ${req.inputType}) => ({`];
-  lines.push(`${pad}  ...__req<${req.responseType}>(() => ${requestExpr}),`);
+  const memberLines = [];
   if (req.filterFieldsExpr) {
-    lines.push(`${pad}  filterFields: ${req.filterFieldsExpr},`);
+    memberLines.push(`${pad}    filterFields: ${req.filterFieldsExpr},`);
   }
   if (streamExpr) {
-    lines.push(`${pad}  stream: () => ${streamExpr},`);
+    memberLines.push(`${pad}    stream: () => ${streamExpr},`);
   }
   for (const [name, value] of Object.entries(members)) {
-    lines.push(`${pad}  ${name}: ${value},`);
-  }
-  lines.push(`${pad}}),`);
+    memberLines.push(`${pad}    ${name}: ${value},`);
+  }
+  const body = [requestExpr, ...memberLines].join("\n");
+  const param = /\binput\b/.test(body) ? `input?: ${req.inputType}` : "";
+  const lines = [`${pad}${objKey}: (${param}) =>`];
+  if (memberLines.length === 0) {
+    lines.push(`${pad}  __req<${req.responseType}>(() => ${requestExpr}),`);
+    return lines;
+  }
+  lines.push(`${pad}  __req(() => ${requestExpr}, {`);
+  lines.push(...memberLines);
+  lines.push(`${pad}  }),`);
   return lines;
 }
 function renderStreamExpr(req) {
@@ -3659,6 +4333,26 @@ var EMPTY_PATH_NAMESPACE = [
   "}",
   ""
 ];
+function isClientCallable(route) {
+  return route.method.toUpperCase() !== "ALL";
+}
+var ROUTES_IMPORT_PLACEHOLDER = "/* @@routes-import@@ */";
+var ROUTES_EXPORTS = [
+  // Called, never mentioned in prose: match the call so a comment saying "route" doesn't count.
+  { name: "route", typeOnly: false },
+  { name: "ROUTES", typeOnly: false },
+  { name: "RouteName", typeOnly: true },
+  { name: "ExtractParams", typeOnly: true },
+  { name: "RouteParams", typeOnly: true }
+];
+function finishRoutesImport(lines) {
+  const body = lines.filter((l) => l !== ROUTES_IMPORT_PLACEHOLDER).join("\n");
+  const used = ROUTES_EXPORTS.filter(
+    ({ name }) => new RegExp(name === "route" ? "\\broute\\(" : `\\b${name}\\b`).test(body)
+  ).map(({ name, typeOnly }) => typeOnly ? `type ${name}` : name);
+  const importLine = used.length ? `import { ${used.join(", ")} } from './routes.js';` : null;
+  return lines.flatMap((l) => l === ROUTES_IMPORT_PLACEHOLDER ? importLine ? [importLine] : [] : [l]).join("\n");
+}
 function buildApiFile(routes, outDir, opts = {}) {
   const fetcherImportPath = opts.fetcherImportPath;
   const serialization = opts.serialization ?? "json";
@@ -3666,7 +4360,7 @@ function buildApiFile(routes, outDir, opts = {}) {
   const { layer } = resolveApiSlots(extensions);
   const memberExts = extensions.filter((e) => e.apiMembers);
   const headerExts = extensions.filter((e) => e.apiHeader);
-  const contracted = routes.filter((r) => r.contract);
+  const contracted = routes.filter((r) => r.contract && isClientCallable(r));
   const ctx = opts.ctx ?? {
     cwd: outDir ?? "",
     outDir: outDir ?? "",
@@ -3718,9 +4412,7 @@ function buildApiFile(routes, outDir, opts = {}) {
     for (const imp of ext.apiHeader?.(ctx)?.imports ?? []) pushImport(imp);
   }
   lines.push(...extImports);
-  lines.push(
-    "import { route, ROUTES, type RouteName, type ExtractParams, type RouteParams } from './routes.js';"
-  );
+  lines.push(ROUTES_IMPORT_PLACEHOLDER);
   const runtimeImport = fetcherImportPath ?? "@dudousxd/nestjs-client";
   lines.push(`import type { Fetcher } from '${runtimeImport}';`);
   if (serialization === "json" && contracted.length > 0) {
@@ -3771,7 +4463,7 @@ function buildApiFile(routes, outDir, opts = {}) {
         lines.push(...statements, "");
       }
     }
-    return lines.join("\n");
+    return finishRoutesImport(lines);
   }
   const tree = /* @__PURE__ */ new Map();
   for (const r of contracted) {
@@ -3824,7 +4516,7 @@ function buildApiFile(routes, outDir, opts = {}) {
       lines.push(...statements, "");
     }
   }
-  return lines.join("\n");
+  return finishRoutesImport(lines);
 }
 
 // src/emit/emit-cache.ts
@@ -3837,6 +4529,7 @@ async function emitCache(pages, outDir) {
       const s = await (0, import_promises4.stat)(p.absolutePath);
       return {
         name: p.name,
+        scope: p.scope ?? "default",
         relativePath: p.relativePath,
         mtime: s.mtime.toISOString()
       };
@@ -4584,6 +5277,7 @@ function buildOpenApiSpec(routes, opts = {}) {
   const paths = {};
   for (const route of routes) {
     if (!route.contract) continue;
+    if (route.method.toUpperCase() === "ALL") continue;
     const oaPath = toOpenApiPath(route.path);
     const method = route.method.toLowerCase();
     let pathItem = paths[oaPath];
@@ -4627,10 +5321,11 @@ async function emitPages(pages, outDir, _options = {}) {
   }).join("\n");
   const propsHelper = "\nexport type InertiaProps<K extends InertiaPageName> = import('@dudousxd/nestjs-inertia').InertiaPages[K];\n";
   const sharedPropsBlock = buildSharedPropsBlock(_options.sharedProps ?? null);
+  const scopesBlock = buildScopesBlock(pages);
   const content = `// Generated by @dudousxd/nestjs-codegen. Do not edit.
 
 export type InertiaPageName = ${pageNameUnion};
-${propsHelper}
+${propsHelper}${scopesBlock}
 declare module '@dudousxd/nestjs-inertia' {
   interface InertiaPages {
 ${augBody}
@@ -4639,6 +5334,31 @@ ${sharedPropsBlock}}
 `;
   await (0, import_promises9.writeFile)((0, import_node_path13.join)(outDir, "pages.d.ts"), content, "utf8");
 }
+function buildScopesBlock(pages) {
+  const byScope = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const scope = page.scope ?? "default";
+    const names = byScope.get(scope) ?? [];
+    names.push(JSON.stringify(page.name));
+    byScope.set(scope, names);
+  }
+  if (![...byScope.keys()].some((scope) => scope !== "default")) return "";
+  if (!byScope.has("default")) byScope.set("default", []);
+  const scopes = ["default", ...[...byScope.keys()].filter((s) => s !== "default")];
+  const body = scopes.map((scope) => {
+    const key = needsQuotes(scope) ? JSON.stringify(scope) : scope;
+    const names = byScope.get(scope) ?? [];
+    return `  ${key}: ${names.length ? names.join(" | ") : "never"};`;
+  }).join("\n");
+  return `
+/** The page names of each Inertia app: \`default\` (forRoot) and every \`pages.scopes\` entry. */
+export interface InertiaScopePages {
+${body}
+}
+
+export type InertiaScopePageName<S extends keyof InertiaScopePages> = InertiaScopePages[S];
+`;
+}
 function buildSharedPropsBlock(sharedProps) {
   if (!sharedProps) return "";
   if (sharedProps.isImportRef) {
@@ -4820,12 +5540,7 @@ async function generate(config, inputRoutes = [], entryPoint = "cli") {
   }
   if (config.pages) {
     const pagesConfig = config.pages;
-    const pages = await discoverPages({
-      glob: pagesConfig.glob,
-      cwd: config.codegen.cwd,
-      propsExport: pagesConfig.propsExport,
-      componentNameStrategy: pagesConfig.componentNameStrategy
-    });
+    const pages = await discoverPageScopes(config);
     const sharedProps = discoverSharedPropsFromConfig(config);
     await emitPages(pages, config.codegen.outDir, {
       propsExport: pagesConfig.propsExport,
@@ -5000,12 +5715,17 @@ async function watch(config, onChange, options = {}) {
     await runInitialPass();
   }
   let pagesDebounceTimer;
-  const pagesGlob = config.pages?.glob ?? ".nestjs-codegen-no-pages";
-  const pagesWatcher = import_chokidar.default.watch((0, import_node_path17.join)(config.codegen.cwd, pagesGlob), {
-    ignoreInitial: true,
-    persistent: true,
-    awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
-  });
+  const pageGlobs = allPageGlobs(config);
+  const pagesWatcher = import_chokidar.default.watch(
+    (pageGlobs.length ? pageGlobs : [".nestjs-codegen-no-pages"]).map(
+      (glob) => (0, import_node_path17.join)(config.codegen.cwd, glob)
+    ),
+    {
+      ignoreInitial: true,
+      persistent: true,
+      awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
+    }
+  );
   function schedulePagesRegenerate() {
     if (pagesDebounceTimer !== void 0) {
       clearTimeout(pagesDebounceTimer);
@@ -5085,7 +5805,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.25.2";
+var VERSION = "0.27.0";
 
 // src/generate-manifest.ts
 var MANIFEST_FILE = ".codegen-manifest.json";
@@ -5145,8 +5865,7 @@ function diffConfigKeyHashes(previous, current) {
   return [...keys].filter((key) => previous[key] !== current[key]).sort();
 }
 async function discoverInputFiles(config) {
-  const globs = [config.contracts.glob, config.forms.watch];
-  if (config.pages) globs.push(config.pages.glob);
+  const globs = [config.contracts.glob, config.forms.watch, ...allPageGlobs(config)];
   const cwd = config.codegen.cwd;
   const matched = await (0, import_fast_glob3.default)(globs, { cwd, absolute: true, onlyFiles: true });
   return [...new Set(matched)].sort();