@lunora/codegen 1.0.0-alpha.55 → 1.0.0-alpha.57

package/dist/packem_shared/discoverFunctions-COG_Xkyz.mjs

@@ -1,544 +0,0 @@
-import { readdirSync, lstatSync } from 'node:fs';
-import { join, extname, relative, sep } from 'node:path';
-import { Node, SyntaxKind } from 'ts-morph';
-import { a as parseObjectShape } from './parse-validator-BDGV8iue.mjs';
-import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
-
-const FUNCTION_KINDS = /* @__PURE__ */ new Set(["action", "mutation", "query", "stream"]);
-const ANY_TOKEN_RE = /\bany\b(?!\s*(?:\?\s*)?:)/u;
-const STRING_LITERAL_SPAN_RE = /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`/gu;
-const IDENTIFIER_RE = /^[A-Za-z_$][\w$]*$/u;
-const renderExpandedPropertyKey = (propertyName) => IDENTIFIER_RE.test(propertyName) ? propertyName : JSON.stringify(propertyName);
-const TS_EXTENSION_RE = /\.ts$/u;
-const lunoraRelativePath = (lunoraDirectory, filePath) => relative(lunoraDirectory, filePath).split(sep).join("/").replace(TS_EXTENSION_RE, "");
-const INTERNAL_FACTORIES = {
-  internalAction: "action",
-  internalMutation: "mutation",
-  internalQuery: "query"
-};
-const LIFECYCLE_FACTORIES = {
-  onConnect: "connect",
-  onDisconnect: "disconnect"
-};
-const GENERATED_SERVER_RE = /(?:^|\/)_generated\/server(?:\.js)?$/u;
-const isLunoraSurfaceModule = (moduleSpecifier) => moduleSpecifier === "@lunora/server" || GENERATED_SERVER_RE.test(moduleSpecifier);
-const resolveCalleeKind = (identifier) => {
-  const symbol = identifier.getSymbol();
-  if (!symbol) {
-    return identifier.getText();
-  }
-  const declarations = symbol.getDeclarations();
-  for (const declaration of declarations) {
-    if (!Node.isImportSpecifier(declaration)) {
-      continue;
-    }
-    const importDeclaration = declaration.getImportDeclaration();
-    const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
-    if (!isLunoraSurfaceModule(moduleSpecifier)) {
-      return void 0;
-    }
-    return declaration.getNameNode().getText();
-  }
-  return void 0;
-};
-const resolveBuilderRootKind = (receiver, followedLocal = false) => {
-  let current = receiver;
-  while (Node.isCallExpression(current)) {
-    const inner = current.getExpression();
-    if (!Node.isPropertyAccessExpression(inner)) {
-      return void 0;
-    }
-    current = inner.getExpression();
-  }
-  if (!Node.isIdentifier(current)) {
-    return void 0;
-  }
-  const rootName = resolveCalleeKind(current);
-  if (rootName === void 0) {
-    if (followedLocal) {
-      return void 0;
-    }
-    const declaration = current.getSymbol()?.getValueDeclaration();
-    if (declaration && Node.isVariableDeclaration(declaration)) {
-      const initializer = declaration.getInitializer();
-      return initializer ? resolveBuilderRootKind(initializer, true) : void 0;
-    }
-    return void 0;
-  }
-  if (FUNCTION_KINDS.has(rootName)) {
-    return "public";
-  }
-  return INTERNAL_FACTORIES[rootName] ? "internal" : void 0;
-};
-const exposeFromBuilderChain = (receiver) => {
-  let current = receiver;
-  while (Node.isCallExpression(current)) {
-    const inner = current.getExpression();
-    if (!Node.isPropertyAccessExpression(inner)) {
-      return void 0;
-    }
-    if (inner.getName() === "expose") {
-      const argument = current.getArguments()[0];
-      if (argument !== void 0 && Node.isObjectLiteralExpression(argument)) {
-        const restProperty = argument.getProperty("rest");
-        if (restProperty !== void 0 && Node.isPropertyAssignment(restProperty)) {
-          const initializer = restProperty.getInitializer();
-          const rest = initializer?.getText() === "true";
-          return { rest };
-        }
-      }
-      return {};
-    }
-    current = inner.getExpression();
-  }
-  return void 0;
-};
-const argsFromCall = (call) => {
-  const first = call.getArguments()[0];
-  if (!first || !Node.isObjectLiteralExpression(first)) {
-    return {};
-  }
-  const argsProperty = first.getProperty("args");
-  if (!argsProperty || !Node.isPropertyAssignment(argsProperty)) {
-    return {};
-  }
-  const initializer = argsProperty.getInitializer();
-  if (!initializer || !Node.isObjectLiteralExpression(initializer)) {
-    return {};
-  }
-  return parseObjectShape(initializer);
-};
-const symbolDeclaredUnreachable = (type, handlerFilePath) => {
-  for (const candidate of [type.getSymbol(), type.getAliasSymbol()]) {
-    if (!candidate) {
-      continue;
-    }
-    for (const declaration of candidate.getDeclarations()) {
-      const declarationFile = declaration.getSourceFile();
-      if (declarationFile.isInNodeModules() || declarationFile.isDeclarationFile()) {
-        continue;
-      }
-      if (declarationFile.getFilePath() !== handlerFilePath) {
-        continue;
-      }
-      if ((Node.isInterfaceDeclaration(declaration) || Node.isTypeAliasDeclaration(declaration)) && !declaration.isExported()) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
-const childTypes = (type) => {
-  const children = [...type.getTypeArguments()];
-  if (type.isUnion()) {
-    children.push(...type.getUnionTypes());
-  }
-  if (type.isIntersection()) {
-    children.push(...type.getIntersectionTypes());
-  }
-  return children;
-};
-const isExpandableObject = (type) => {
-  if (!type.isObject() || type.isArray() || type.isTuple()) {
-    return false;
-  }
-  if (type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0) {
-    return false;
-  }
-  return type.getStringIndexType() === void 0 && type.getNumberIndexType() === void 0;
-};
-const referencesUnreachableLocalType = (type, node, handlerFilePath, seen = /* @__PURE__ */ new Set()) => {
-  if (seen.has(type)) {
-    return false;
-  }
-  seen.add(type);
-  if (symbolDeclaredUnreachable(type, handlerFilePath)) {
-    return true;
-  }
-  if (childTypes(type).some((child) => referencesUnreachableLocalType(child, node, handlerFilePath, seen))) {
-    return true;
-  }
-  if (!isExpandableObject(type)) {
-    return false;
-  }
-  return type.getProperties().some((property) => referencesUnreachableLocalType(property.getTypeAtLocation(node), node, handlerFilePath, seen));
-};
-const isOptionalProperty = (property, propertyType) => {
-  const declaration = property.getValueDeclaration() ?? property.getDeclarations()[0];
-  if (declaration && (Node.isPropertySignature(declaration) || Node.isPropertyDeclaration(declaration)) && declaration.hasQuestionToken()) {
-    return true;
-  }
-  return propertyType.isUnion() && propertyType.getUnionTypes().some((member) => member.isUndefined());
-};
-const MAX_EXPANSION_DEPTH = 8;
-const expandArrayType = (type, node, handlerFilePath, depth, nextSeen, expand) => {
-  const element = type.getArrayElementType();
-  const rendered = element ? expand(element, node, handlerFilePath, depth, nextSeen) : void 0;
-  if (rendered === void 0) {
-    return void 0;
-  }
-  return element?.isUnion() ? `(${rendered})[]` : `${rendered}[]`;
-};
-const expandUnionType = (type, node, handlerFilePath, depth, nextSeen, expand) => {
-  const parts = [];
-  for (const member of type.getUnionTypes()) {
-    const rendered = expand(member, node, handlerFilePath, depth, nextSeen);
-    if (rendered === void 0) {
-      return void 0;
-    }
-    parts.push(rendered);
-  }
-  return parts.join(" | ");
-};
-const expandObjectType = (type, node, handlerFilePath, depth, nextSeen, expand) => {
-  if (!isExpandableObject(type)) {
-    return void 0;
-  }
-  const parts = [];
-  for (const property of type.getProperties()) {
-    const propertyType = property.getTypeAtLocation(node);
-    const optional = isOptionalProperty(property, propertyType);
-    const valueMembers = optional && propertyType.isUnion() ? propertyType.getUnionTypes().filter((member) => !member.isUndefined()) : [propertyType];
-    const rendered = [];
-    for (const member of valueMembers) {
-      const text = expand(member, node, handlerFilePath, depth + 1, nextSeen);
-      if (text === void 0) {
-        return void 0;
-      }
-      rendered.push(text);
-    }
-    parts.push(`${renderExpandedPropertyKey(property.getName())}${optional ? "?" : ""}: ${rendered.join(" | ")}`);
-  }
-  return parts.length > 0 ? `{ ${parts.join("; ")} }` : "{}";
-};
-const expandUnreachableType = (type, node, handlerFilePath, depth, seen) => {
-  if (depth > MAX_EXPANSION_DEPTH || seen.has(type)) {
-    return void 0;
-  }
-  if (!referencesUnreachableLocalType(type, node, handlerFilePath)) {
-    return type.getText(node);
-  }
-  const nextSeen = new Set(seen).add(type);
-  if (type.isArray()) {
-    return expandArrayType(type, node, handlerFilePath, depth, nextSeen, expandUnreachableType);
-  }
-  if (type.isUnion()) {
-    return expandUnionType(type, node, handlerFilePath, depth, nextSeen, expandUnreachableType);
-  }
-  return expandObjectType(type, node, handlerFilePath, depth, nextSeen, expandUnreachableType);
-};
-const unwrapHandlerReturn = (handler) => {
-  const signature = handler.getType().getCallSignatures()[0];
-  if (!signature) {
-    return "unknown";
-  }
-  let returnType = signature.getReturnType();
-  const symbol = returnType.getSymbol() ?? returnType.getAliasSymbol();
-  const wrapperName = symbol?.getName();
-  if (wrapperName === "Promise" || wrapperName === "AsyncIterable" || wrapperName === "AsyncIterableIterator" || wrapperName === "AsyncGenerator") {
-    const innerTypeArgument = returnType.getTypeArguments()[0];
-    if (innerTypeArgument) {
-      returnType = innerTypeArgument;
-    }
-  }
-  const rendered = returnType.getText(handler);
-  if (!rendered || rendered === "any" || rendered === "never") {
-    return "unknown";
-  }
-  if (ANY_TOKEN_RE.test(rendered.replaceAll(STRING_LITERAL_SPAN_RE, ""))) {
-    return "unknown";
-  }
-  const handlerFilePath = handler.getSourceFile().getFilePath();
-  if (referencesUnreachableLocalType(returnType, handler, handlerFilePath)) {
-    return expandUnreachableType(returnType, handler, handlerFilePath, 0, /* @__PURE__ */ new Set()) ?? "unknown";
-  }
-  return rendered;
-};
-const returnTypeFromCall = (call) => {
-  const first = call.getArguments()[0];
-  if (!first || !Node.isObjectLiteralExpression(first)) {
-    return "unknown";
-  }
-  const handlerProperty = first.getProperty("handler");
-  if (!handlerProperty || !Node.isPropertyAssignment(handlerProperty)) {
-    return "unknown";
-  }
-  const initializer = handlerProperty.getInitializer();
-  if (!initializer || !(Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer))) {
-    return "unknown";
-  }
-  return unwrapHandlerReturn(initializer);
-};
-const returnTypeFromBuilderCall = (call) => {
-  const handler = call.getArguments()[0];
-  if (!handler || !(Node.isArrowFunction(handler) || Node.isFunctionExpression(handler))) {
-    return "unknown";
-  }
-  return unwrapHandlerReturn(handler);
-};
-const argsFromBuilderChain = (receiver) => {
-  let merged = {};
-  let node = receiver;
-  while (Node.isCallExpression(node)) {
-    const chainCallee = node.getExpression();
-    if (!Node.isPropertyAccessExpression(chainCallee)) {
-      break;
-    }
-    if (chainCallee.getName() === "input") {
-      const argument = node.getArguments()[0];
-      if (argument && Node.isObjectLiteralExpression(argument)) {
-        merged = { ...parseObjectShape(argument), ...merged };
-      }
-    }
-    node = chainCallee.getExpression();
-  }
-  return merged;
-};
-const classifyProcedureCall = (call) => {
-  const callee = call.getExpression();
-  if (Node.isPropertyAccessExpression(callee)) {
-    const method = callee.getName();
-    if (!FUNCTION_KINDS.has(method)) {
-      return void 0;
-    }
-    const receiver = callee.getExpression();
-    if (receiver.getType().getProperty("__lunoraProcedure")) {
-      return { kind: method, receiver, visibility: receiver.getType().getProperty("__lunoraVisibility") ? "internal" : "public" };
-    }
-    const rootKind = resolveBuilderRootKind(receiver);
-    if (rootKind) {
-      return { kind: method, receiver, visibility: rootKind };
-    }
-    return void 0;
-  }
-  if (!Node.isIdentifier(callee)) {
-    return void 0;
-  }
-  const calleeName2 = resolveCalleeKind(callee);
-  if (!calleeName2) {
-    return void 0;
-  }
-  if (FUNCTION_KINDS.has(calleeName2)) {
-    return { kind: calleeName2, visibility: "public" };
-  }
-  const internalKind = INTERNAL_FACTORIES[calleeName2];
-  if (internalKind) {
-    return { kind: internalKind, visibility: "internal" };
-  }
-  const lifecycle = LIFECYCLE_FACTORIES[calleeName2];
-  if (lifecycle) {
-    return { kind: "mutation", lifecycle, visibility: "internal" };
-  }
-  return void 0;
-};
-const inlineHandler = (argument) => argument !== void 0 && (Node.isArrowFunction(argument) || Node.isFunctionExpression(argument)) ? argument : void 0;
-const isDatabaseAccessor = (receiver) => Node.isPropertyAccessExpression(receiver) && receiver.getName() === "db" || Node.isIdentifier(receiver) && receiver.getText() === "db";
-const procedureHandler = (initializer) => {
-  const argument = initializer.getArguments()[0];
-  const direct = inlineHandler(argument);
-  if (direct !== void 0) {
-    return direct;
-  }
-  if (argument === void 0 || !Node.isObjectLiteralExpression(argument)) {
-    return void 0;
-  }
-  const property = argument.getProperty("handler");
-  return property !== void 0 && Node.isPropertyAssignment(property) ? inlineHandler(property.getInitializer()) : void 0;
-};
-const calleeName = (callee) => {
-  if (Node.isIdentifier(callee)) {
-    return callee.getText();
-  }
-  return Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
-};
-const chainHasStep = (receiver, method) => {
-  let node = receiver;
-  while (Node.isCallExpression(node)) {
-    const callee = node.getExpression();
-    if (!Node.isPropertyAccessExpression(callee)) {
-      break;
-    }
-    if (callee.getName() === method) {
-      return true;
-    }
-    node = callee.getExpression();
-  }
-  return false;
-};
-const chainUsesWrappedCall = (receiver, method, wrappedCallee) => {
-  let node = receiver;
-  while (Node.isCallExpression(node)) {
-    const callee = node.getExpression();
-    if (!Node.isPropertyAccessExpression(callee)) {
-      break;
-    }
-    const argument = node.getArguments()[0];
-    if (callee.getName() === method && argument !== void 0 && Node.isCallExpression(argument) && calleeName(argument.getExpression()) === wrappedCallee) {
-      return true;
-    }
-    node = callee.getExpression();
-  }
-  return false;
-};
-const listLunoraSourceFiles = (directory, accumulator = [], root = directory) => {
-  let entries;
-  try {
-    entries = readdirSync(directory);
-  } catch {
-    return accumulator;
-  }
-  for (const entry of entries) {
-    const full = join(directory, entry);
-    const info = lstatSync(full);
-    if (info.isDirectory()) {
-      if (entry === "_generated" || entry === "node_modules") {
-        continue;
-      }
-      listLunoraSourceFiles(full, accumulator, root);
-    } else if (info.isFile() && extname(entry) === ".ts") {
-      if (entry === "schema.ts" && directory === root) {
-        continue;
-      }
-      accumulator.push(full);
-    }
-  }
-  return accumulator;
-};
-const discoverFromCall = (call) => {
-  const classified = classifyProcedureCall(call);
-  if (!classified) {
-    return void 0;
-  }
-  if (classified.receiver) {
-    const expose = exposeFromBuilderChain(classified.receiver);
-    return {
-      args: argsFromBuilderChain(classified.receiver),
-      ...expose ? { expose } : {},
-      kind: classified.kind,
-      returnType: returnTypeFromBuilderCall(call),
-      visibility: classified.visibility
-    };
-  }
-  if (classified.lifecycle) {
-    return { args: {}, kind: classified.kind, lifecycle: classified.lifecycle, returnType: "void", visibility: classified.visibility };
-  }
-  return {
-    args: argsFromCall(call),
-    kind: classified.kind,
-    returnType: returnTypeFromCall(call),
-    visibility: classified.visibility
-  };
-};
-const RE_EXPORT_RESOLVE_LIMIT = 8;
-const resolveExpressionToCall = (node, depth = 0) => {
-  if (depth > RE_EXPORT_RESOLVE_LIMIT) {
-    return void 0;
-  }
-  if (Node.isCallExpression(node)) {
-    return node;
-  }
-  if (Node.isParenthesizedExpression(node) || Node.isAsExpression(node) || Node.isSatisfiesExpression(node) || Node.isNonNullExpression(node)) {
-    return resolveExpressionToCall(node.getExpression(), depth + 1);
-  }
-  if (!Node.isIdentifier(node) && !Node.isPropertyAccessExpression(node)) {
-    return void 0;
-  }
-  const declaration = node.getSymbol()?.getValueDeclaration();
-  return declaration ? resolveDeclarationToCall(declaration, depth + 1) : void 0;
-};
-const resolveDeclarationToCall = (declaration, depth) => {
-  if (Node.isVariableDeclaration(declaration) || Node.isPropertyAssignment(declaration)) {
-    const initializer = declaration.getInitializer();
-    return initializer ? resolveExpressionToCall(initializer, depth) : void 0;
-  }
-  if (Node.isShorthandPropertyAssignment(declaration)) {
-    return resolveExpressionToCall(declaration.getNameNode(), depth);
-  }
-  if (Node.isBindingElement(declaration)) {
-    const propertyName = declaration.getPropertyNameNode()?.getText() ?? declaration.getName();
-    const variableDeclaration = declaration.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
-    const rightHandSide = variableDeclaration?.getInitializer();
-    const propertyDeclaration = rightHandSide?.getType().getProperty(propertyName)?.getValueDeclaration();
-    return propertyDeclaration ? resolveDeclarationToCall(propertyDeclaration, depth + 1) : void 0;
-  }
-  return void 0;
-};
-const exportCallsOfDeclaration = (declaration) => {
-  const nameNode = declaration.getNameNode();
-  if (Node.isObjectBindingPattern(nameNode)) {
-    const pairs = [];
-    for (const element of nameNode.getElements()) {
-      const call2 = resolveExpressionToCall(element.getNameNode());
-      if (call2) {
-        pairs.push([element.getName(), call2]);
-      }
-    }
-    return pairs;
-  }
-  const initializer = declaration.getInitializer();
-  const call = initializer && (Node.isCallExpression(initializer) ? initializer : resolveExpressionToCall(initializer));
-  return call ? [[declaration.getName(), call]] : [];
-};
-const functionIrFromCall = (call, exportName, relativePath) => {
-  const discovered = discoverFromCall(call);
-  if (!discovered) {
-    return void 0;
-  }
-  return {
-    args: discovered.args,
-    exportName,
-    filePath: relativePath,
-    kind: discovered.kind,
-    returnType: discovered.returnType,
-    visibility: discovered.visibility,
-    ...discovered.expose ? { expose: discovered.expose } : {},
-    ...discovered.lifecycle ? { lifecycle: discovered.lifecycle } : {}
-  };
-};
-const discoverFileFunctions = (source, relativePath) => {
-  const found = [];
-  for (const statement of source.getVariableStatements()) {
-    if (!statement.isExported()) {
-      continue;
-    }
-    for (const declaration of statement.getDeclarations()) {
-      for (const [exportName, call] of exportCallsOfDeclaration(declaration)) {
-        const entry = functionIrFromCall(call, exportName, relativePath);
-        if (entry) {
-          found.push(entry);
-        }
-      }
-    }
-  }
-  return found;
-};
-const assertNoNamespaceCollision = (functions) => {
-  const namespaceOrigins = /* @__PURE__ */ new Map();
-  for (const entry of functions) {
-    const namespace = sanitizeNamespace(entry.filePath);
-    const prior = namespaceOrigins.get(namespace);
-    if (prior && prior !== entry.filePath) {
-      throw Object.assign(
-        new Error(
-          `Namespace collision: "${prior}" and "${entry.filePath}" both resolve to "${namespace}". Rename one of the files so the JS-identifier-sanitized names differ. (note: case-insensitive filesystems may also cause this — \`foo\` and \`FOO\` map to the same identifier)`
-        ),
-        { code: "NAMESPACE_COLLISION", name: "LunoraError", paths: [prior, entry.filePath], status: 500 }
-      );
-    }
-    namespaceOrigins.set(namespace, entry.filePath);
-  }
-};
-const discoverFunctions = (project, lunoraDirectory) => {
-  const filePaths = listLunoraSourceFiles(lunoraDirectory);
-  const functions = [];
-  for (const filePath of filePaths) {
-    const source = project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
-    const relativePath = lunoraRelativePath(lunoraDirectory, filePath);
-    functions.push(...discoverFileFunctions(source, relativePath));
-  }
-  functions.sort((a, b) => `${a.filePath}:${a.exportName}`.localeCompare(`${b.filePath}:${b.exportName}`));
-  assertNoNamespaceCollision(functions);
-  return functions;
-};
-
-export { chainHasStep, chainUsesWrappedCall, classifyProcedureCall, discoverFunctions, inlineHandler, isDatabaseAccessor, listLunoraSourceFiles, lunoraRelativePath, procedureHandler, unwrapHandlerReturn };

package/dist/packem_shared/discoverHttpRoutes-CVXWZkzo.mjs

@@ -1,139 +0,0 @@
-import { relative, sep } from 'node:path';
-import { Node } from 'ts-morph';
-import { listLunoraSourceFiles, unwrapHandlerReturn } from './discoverFunctions-COG_Xkyz.mjs';
-import { p as parseValidator, a as parseObjectShape } from './parse-validator-BDGV8iue.mjs';
-
-const TS_EXTENSION_RE = /\.ts$/u;
-const HTTP_VERBS = /* @__PURE__ */ new Set(["delete", "get", "head", "options", "patch", "post", "put"]);
-const MAP_STEPS = /* @__PURE__ */ new Set(["body", "params", "searchParams"]);
-const TERMINAL_STEPS = /* @__PURE__ */ new Set(["handler", "stream"]);
-const readPathLiteral = (call) => {
-  const first = call.getArguments()[0];
-  if (first && Node.isStringLiteral(first)) {
-    return first.getLiteralValue();
-  }
-  return void 0;
-};
-const readMapArgument = (call) => {
-  const first = call.getArguments()[0];
-  return first && Node.isObjectLiteralExpression(first) ? parseObjectShape(first) : {};
-};
-const readRootVerb = (node) => {
-  if (!Node.isCallExpression(node)) {
-    return void 0;
-  }
-  const callee = node.getExpression();
-  if (!Node.isPropertyAccessExpression(callee)) {
-    return void 0;
-  }
-  const verb = callee.getName();
-  if (!HTTP_VERBS.has(verb)) {
-    return void 0;
-  }
-  const receiver = callee.getExpression();
-  if (!Node.isIdentifier(receiver) || receiver.getText() !== "httpRoute") {
-    return void 0;
-  }
-  const path = readPathLiteral(node);
-  return path === void 0 ? void 0 : { method: verb.toUpperCase(), path };
-};
-const walkRouteChain = (terminalCall, terminalStep) => {
-  const state = { body: {}, params: {}, searchParams: {}, stream: terminalStep === "stream" };
-  const terminalCallee = terminalCall.getExpression();
-  if (!Node.isPropertyAccessExpression(terminalCallee)) {
-    return void 0;
-  }
-  let node = terminalCallee.getExpression();
-  while (Node.isCallExpression(node)) {
-    const callee = node.getExpression();
-    if (!Node.isPropertyAccessExpression(callee)) {
-      break;
-    }
-    const step = callee.getName();
-    if (HTTP_VERBS.has(step)) {
-      break;
-    }
-    if (MAP_STEPS.has(step)) {
-      const map = readMapArgument(node);
-      state[step] = { ...map, ...state[step] };
-    } else if (step === "output" && state.output === void 0) {
-      const argument = node.getArguments()[0];
-      if (argument && Node.isExpression(argument)) {
-        state.output = parseValidator(argument);
-      }
-    }
-    node = callee.getExpression();
-  }
-  const root = readRootVerb(node);
-  if (!root) {
-    return void 0;
-  }
-  state.method = root.method;
-  state.path = root.path;
-  return state;
-};
-const chunkTypeFromStreamTerminal = (call) => {
-  const handler = call.getArguments()[0];
-  if (!handler || !(Node.isArrowFunction(handler) || Node.isFunctionExpression(handler))) {
-    return "unknown";
-  }
-  return unwrapHandlerReturn(handler);
-};
-const routeFromTerminal = (call, callee, exportName, filePath) => {
-  const step = callee.getName();
-  if (!TERMINAL_STEPS.has(step)) {
-    return void 0;
-  }
-  const state = walkRouteChain(call, step);
-  if (state?.method === void 0 || state.path === void 0) {
-    return void 0;
-  }
-  return {
-    body: state.body,
-    exportName,
-    filePath,
-    method: state.method,
-    params: state.params,
-    path: state.path,
-    searchParams: state.searchParams,
-    stream: state.stream,
-    ...state.stream ? { chunkType: chunkTypeFromStreamTerminal(call) } : {},
-    ...state.output ? { output: state.output } : {}
-  };
-};
-const discoverFileRoutes = (source, relativePath) => {
-  const found = [];
-  for (const statement of source.getVariableStatements()) {
-    if (!statement.isExported()) {
-      continue;
-    }
-    for (const declaration of statement.getDeclarations()) {
-      const initializer = declaration.getInitializer();
-      if (!initializer || !Node.isCallExpression(initializer)) {
-        continue;
-      }
-      const callee = initializer.getExpression();
-      if (!Node.isPropertyAccessExpression(callee)) {
-        continue;
-      }
-      const route = routeFromTerminal(initializer, callee, declaration.getName(), relativePath);
-      if (route) {
-        found.push(route);
-      }
-    }
-  }
-  return found;
-};
-const discoverHttpRoutes = (project, lunoraDirectory) => {
-  const filePaths = listLunoraSourceFiles(lunoraDirectory);
-  const routes = [];
-  for (const filePath of filePaths) {
-    const source = project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
-    const relativePath = relative(lunoraDirectory, filePath).split(sep).join("/").replace(TS_EXTENSION_RE, "");
-    routes.push(...discoverFileRoutes(source, relativePath));
-  }
-  routes.sort((a, b) => `${a.method} ${a.path}`.localeCompare(`${b.method} ${b.path}`) || a.filePath.localeCompare(b.filePath));
-  return routes;
-};
-
-export { discoverHttpRoutes as default };