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

package/dist/packem_shared/buildOpenApiDocument-DCQSLuFc.mjs

@@ -1,262 +0,0 @@
-import { G as GENERATED_HEADER } from './emit-DIbr7U31.mjs';
-import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
-import { LUNORA_ERROR_CODES, objectSchema, argsObjectSchema, validatorIrToJsonSchema } from './LUNORA_ERROR_CODES-DvTLozCu.mjs';
-
-const REST_PATH_PREFIX = "/_lunora/rest";
-const splitFunctionPath = (functionPath) => {
-  const colon = functionPath.indexOf(":");
-  if (colon <= 0 || colon >= functionPath.length - 1 || functionPath.indexOf(":", colon + 1) !== -1) {
-    return void 0;
-  }
-  return { name: functionPath.slice(colon + 1), namespace: functionPath.slice(0, colon) };
-};
-const restPathForFunction = (functionPath) => {
-  const parts = splitFunctionPath(functionPath);
-  if (parts === void 0) {
-    return void 0;
-  }
-  return `${REST_PATH_PREFIX}/${parts.namespace}/${parts.name}`;
-};
-const restMethodForKind = (kind) => kind === "query" ? "GET" : "POST";
-
-const ERROR_COMPONENT_REF = "#/components/responses/LunoraError";
-const ROUTE_PARAM_RE = /:([A-Za-z_$][\w$]*)/gu;
-const pathParameterNames = (path) => [...path.matchAll(ROUTE_PARAM_RE)].map((match) => match[1]);
-const toOpenApiPath = (path) => path.replaceAll(ROUTE_PARAM_RE, "{$1}");
-const buildParameters = (route) => {
-  const declaredPathNames = new Set(pathParameterNames(route.path));
-  const parameters = [];
-  for (const [name, validator] of Object.entries(route.searchParams)) {
-    const inner = validator.kind === "optional" ? validator.inner ?? validator : validator;
-    parameters.push({
-      description: `Query parameter \`${name}\``,
-      in: "query",
-      name,
-      required: validator.kind !== "optional",
-      schema: validatorIrToJsonSchema(inner)
-    });
-  }
-  for (const [name, validator] of Object.entries(route.params)) {
-    const inner = validator.kind === "optional" ? validator.inner ?? validator : validator;
-    parameters.push({
-      description: `Path parameter \`${name}\``,
-      // A path param the template doesn't name is still surfaced (OpenAPI
-      // requires path params to be `required: true`), but flagged so the
-      // mismatch is visible rather than silently dropped.
-      in: declaredPathNames.has(name) ? "path" : "query",
-      name,
-      required: declaredPathNames.has(name) ? true : validator.kind !== "optional",
-      schema: validatorIrToJsonSchema(inner)
-    });
-  }
-  return parameters;
-};
-const successResponse = (output) => {
-  if (output) {
-    return {
-      content: { "application/json": { schema: validatorIrToJsonSchema(output) } },
-      description: "Successful response."
-    };
-  }
-  return {
-    content: { "application/json": { schema: { description: "Return shape is TS-inferred (no `.output()` declared); best-effort — any JSON." } } },
-    description: "Successful response. The return shape is TypeScript-inferred and not declared via `.output()`, so it is documented best-effort."
-  };
-};
-const httpRouteOperation = (route) => {
-  const tag = sanitizeNamespace(route.filePath);
-  const parameters = buildParameters(route);
-  const operation = {
-    description: `${route.stream ? "Streaming (SSE) " : ""}HTTP route handler \`${route.exportName}\` (${route.method} ${route.path}).`,
-    operationId: `${route.method.toLowerCase()}_${sanitizeNamespace(route.path)}`,
-    responses: {
-      "200": successResponse(route.output),
-      "204": { description: "No content (handler returned `undefined`)." },
-      default: { $ref: ERROR_COMPONENT_REF }
-    },
-    summary: `${route.method} ${route.path}`,
-    tags: [tag]
-  };
-  if (parameters.length > 0) {
-    operation.parameters = parameters;
-  }
-  if (Object.keys(route.body).length > 0) {
-    operation.requestBody = {
-      content: { "application/json": { schema: objectSchema(route.body) } },
-      required: true
-    };
-  }
-  if (route.stream) {
-    operation["x-lunora-stream"] = "text/event-stream";
-  }
-  return operation;
-};
-const rpcOperation = (definition) => {
-  const functionPath = `${sanitizeNamespace(definition.filePath)}:${definition.exportName}`;
-  const tag = sanitizeNamespace(definition.filePath);
-  const requestSchema = {
-    additionalProperties: false,
-    properties: {
-      args: argsObjectSchema(definition.args),
-      functionPath: { const: functionPath, type: "string" },
-      shardKey: { description: "Optional shard key; omitted routes to the default shard.", type: "string" }
-    },
-    required: ["functionPath"],
-    type: "object"
-  };
-  const operation = {
-    description: `Invoke the \`${definition.kind}\` \`${functionPath}\` over the Lunora RPC envelope (POST /_lunora/rpc).`,
-    operationId: functionPath,
-    requestBody: {
-      content: { "application/json": { schema: requestSchema } },
-      required: true
-    },
-    responses: {
-      "200": {
-        content: {
-          "application/json": {
-            schema: { description: "RPC result. The shape is TS-inferred from the function's return type; best-effort — any JSON." }
-          }
-        },
-        description: "Successful RPC result (TypeScript-inferred return shape, documented best-effort)."
-      },
-      default: { $ref: ERROR_COMPONENT_REF }
-    },
-    summary: `${definition.kind}: ${functionPath}`,
-    tags: [tag],
-    "x-lunora-function-kind": definition.kind
-  };
-  return { operation, pathKey: `/_lunora/rpc#${functionPath}` };
-};
-const restOperation = (definition) => {
-  const functionPath = `${sanitizeNamespace(definition.filePath)}:${definition.exportName}`;
-  const path = restPathForFunction(functionPath);
-  if (path === void 0) {
-    return void 0;
-  }
-  const tag = sanitizeNamespace(definition.filePath);
-  const method = restMethodForKind(definition.kind);
-  const isQuery = method === "GET";
-  const operation = {
-    description: `Public REST endpoint for the \`${definition.kind}\` \`${functionPath}\` (opt-in via \`.expose({ rest: true })\`). Routed through the procedure, so auth / RLS / validators are enforced.`,
-    operationId: `rest_${sanitizeNamespace(path)}`,
-    responses: {
-      "200": {
-        content: {
-          "application/json": {
-            schema: { description: "Procedure result. The shape is TS-inferred from the return type; best-effort — any JSON." }
-          }
-        },
-        description: "Successful result (TypeScript-inferred return shape, documented best-effort)."
-      },
-      default: { $ref: ERROR_COMPONENT_REF }
-    },
-    summary: `${method} ${path}`,
-    tags: [tag],
-    "x-lunora-function-kind": definition.kind
-  };
-  if (isQuery) {
-    const parameters = Object.entries(definition.args).map(([name, validator]) => {
-      const inner = validator.kind === "optional" ? validator.inner ?? validator : validator;
-      return {
-        description: `Argument \`${name}\` (JSON-encoded for non-string values).`,
-        in: "query",
-        name,
-        required: validator.kind !== "optional",
-        schema: validatorIrToJsonSchema(inner)
-      };
-    });
-    if (parameters.length > 0) {
-      operation.parameters = parameters;
-    }
-    return { method: "get", operation, path };
-  }
-  operation.requestBody = {
-    content: { "application/json": { schema: argsObjectSchema(definition.args) } },
-    required: Object.keys(definition.args).length > 0
-  };
-  return { method: "post", operation, path };
-};
-const buildOpenApiDocument = (input) => {
-  const version = input.version ?? "0.0.0";
-  const paths = {};
-  const tagNames = /* @__PURE__ */ new Set();
-  for (const route of input.httpRoutes) {
-    const openApiPath = toOpenApiPath(route.path);
-    const pathItem = paths[openApiPath] ?? {};
-    pathItem[route.method.toLowerCase()] = httpRouteOperation(route);
-    paths[openApiPath] = pathItem;
-    tagNames.add(sanitizeNamespace(route.filePath));
-  }
-  const rpcFunctions = input.functions.filter((definition) => definition.visibility !== "internal" && definition.kind !== "stream");
-  for (const definition of rpcFunctions) {
-    const { operation, pathKey } = rpcOperation(definition);
-    paths[pathKey] = { post: operation };
-    tagNames.add(sanitizeNamespace(definition.filePath));
-  }
-  for (const definition of rpcFunctions) {
-    if (definition.expose?.rest !== true) {
-      continue;
-    }
-    const rest = restOperation(definition);
-    if (rest === void 0) {
-      continue;
-    }
-    const pathItem = paths[rest.path] ?? {};
-    pathItem[rest.method] = rest.operation;
-    paths[rest.path] = pathItem;
-    tagNames.add(sanitizeNamespace(definition.filePath));
-  }
-  const tags = [...tagNames].toSorted((a, b) => a.localeCompare(b)).map((name) => {
-    return { description: `Operations declared in \`lunora/${name}\`.`, name };
-  });
-  const document = {
-    components: {
-      responses: {
-        LunoraError: {
-          content: {
-            "application/json": {
-              schema: {
-                additionalProperties: false,
-                description: "Standard Lunora error envelope.",
-                properties: {
-                  error: {
-                    additionalProperties: false,
-                    properties: {
-                      code: {
-                        description: "Machine-readable error code. Clients switch on this value.",
-                        enum: LUNORA_ERROR_CODES,
-                        type: "string"
-                      },
-                      message: { description: "Human-readable error message (never echoes internal details).", type: "string" }
-                    },
-                    required: ["code", "message"],
-                    type: "object"
-                  }
-                },
-                required: ["error"],
-                type: "object"
-              }
-            }
-          },
-          description: "A Lunora error response. The HTTP status reflects the error code (e.g. BAD_REQUEST→400, UNAUTHORIZED→401, FORBIDDEN→403, NOT_FOUND→404)."
-        }
-      }
-    },
-    info: {
-      description: "Auto-generated from @lunora/values-typed functions by @lunora/codegen. Do not edit — run `lunora codegen` to regenerate.",
-      title: "Lunora API",
-      version
-    },
-    openapi: "3.1.0",
-    paths,
-    tags
-  };
-  return document;
-};
-const emitOpenApi = (input) => `${JSON.stringify(buildOpenApiDocument(input), void 0, 2)}
-`;
-const emitOpenApiModule = (document_) => `${GENERATED_HEADER}export const openApiSpec: Record<string, unknown> = ${JSON.stringify(document_, void 0, 4)};
-`;
-
-export { buildOpenApiDocument, emitOpenApi, emitOpenApiModule };

package/dist/packem_shared/discover-ast-CT6BgBr4.mjs

@@ -1,13 +0,0 @@
-import { Node } from 'ts-morph';
-
-const TS_EXTENSION_RE = /\.ts$/u;
-const enclosingExportName = (call) => {
-  for (const ancestor of call.getAncestors()) {
-    if (Node.isVariableDeclaration(ancestor) && ancestor.getVariableStatement()?.hasExportKeyword() === true) {
-      return ancestor.getName();
-    }
-  }
-  return "";
-};
-
-export { TS_EXTENSION_RE as T, enclosingExportName as e };

package/dist/packem_shared/discoverAuthApiCalls-Dhwgf4J4.mjs

@@ -1,62 +0,0 @@
-import { relative, sep } from 'node:path';
-import { SyntaxKind, Node } from 'ts-morph';
-import { T as TS_EXTENSION_RE, e as enclosingExportName } from './discover-ast-CT6BgBr4.mjs';
-import { listLunoraSourceFiles } from './discoverFunctions-COG_Xkyz.mjs';
-
-const isAuthApiCall = (call) => {
-  const callee = call.getExpression();
-  if (!Node.isPropertyAccessExpression(callee)) {
-    return false;
-  }
-  const receiver = callee.getExpression();
-  if (Node.isPropertyAccessExpression(receiver)) {
-    return receiver.getName() === "authApi";
-  }
-  return Node.isIdentifier(receiver) && receiver.getText() === "authApi";
-};
-const hasHeadersProp = (call) => {
-  const argument = call.getArguments()[0];
-  if (argument === void 0) {
-    return false;
-  }
-  if (!Node.isObjectLiteralExpression(argument)) {
-    return true;
-  }
-  for (const property of argument.getProperties()) {
-    if ((Node.isPropertyAssignment(property) || Node.isShorthandPropertyAssignment(property)) && property.getName() === "headers") {
-      return true;
-    }
-    if (Node.isSpreadAssignment(property)) {
-      return true;
-    }
-  }
-  return false;
-};
-const discoverAuthApiCalls = (project, lunoraDirectory) => {
-  const calls = [];
-  for (const filePath of listLunoraSourceFiles(lunoraDirectory)) {
-    const sourceFile = project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
-    const relativePath = relative(lunoraDirectory, filePath).replace(TS_EXTENSION_RE, "").split(sep).join("/");
-    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-      if (!isAuthApiCall(call)) {
-        continue;
-      }
-      const exportName = enclosingExportName(call);
-      if (exportName === "") {
-        continue;
-      }
-      const callee = call.getExpression();
-      const method = Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
-      calls.push({
-        exportName,
-        file: relativePath,
-        hasHeaders: hasHeadersProp(call),
-        line: call.getStartLineNumber(),
-        method
-      });
-    }
-  }
-  return calls;
-};
-
-export { discoverAuthApiCalls as default };

package/dist/packem_shared/discoverCrons-UbQLLmMS.mjs

@@ -1,286 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-import { isValidCronExpression, compileCronSchedule, CRON_SCHEDULE_KINDS } from '@lunora/scheduler';
-import { SyntaxKind, Node } from 'ts-morph';
-import { diagnosticAt } from './CodegenDiagnosticError-DyQ5FwkM.mjs';
-import { listLunoraSourceFiles } from './discoverFunctions-COG_Xkyz.mjs';
-import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
-
-const CRON_METHODS = /* @__PURE__ */ new Set([...CRON_SCHEDULE_KINDS, "cron"]);
-const CRON_JOBS_SOURCES = /* @__PURE__ */ new Set(["@lunora/scheduler", "@lunora/server"]);
-const isCronJobsFactory = (identifier) => {
-  const symbol = identifier.getSymbol();
-  if (!symbol) {
-    return identifier.getText() === "cronJobs";
-  }
-  for (const declaration of symbol.getDeclarations()) {
-    if (!Node.isImportSpecifier(declaration)) {
-      continue;
-    }
-    if (!CRON_JOBS_SOURCES.has(declaration.getImportDeclaration().getModuleSpecifierValue())) {
-      return false;
-    }
-    return declaration.getNameNode().getText() === "cronJobs";
-  }
-  return false;
-};
-const collectCronBuilderNames = (source) => {
-  const names = /* @__PURE__ */ new Set();
-  for (const declaration of source.getVariableDeclarations()) {
-    const initializer = declaration.getInitializer();
-    if (initializer?.getKind() !== SyntaxKind.CallExpression) {
-      continue;
-    }
-    const callee = initializer.getExpression();
-    if (Node.isIdentifier(callee) && isCronJobsFactory(callee)) {
-      names.add(declaration.getName());
-    }
-  }
-  return names;
-};
-const rootIdentifierOf = (node) => {
-  let current = node;
-  while (Node.isCallExpression(current) || Node.isPropertyAccessExpression(current)) {
-    current = current.getExpression();
-  }
-  return Node.isIdentifier(current) ? current.getText() : void 0;
-};
-const stringArgument = (call, index) => {
-  const argument = call.getArguments()[index];
-  return argument && (Node.isStringLiteral(argument) || Node.isNoSubstitutionTemplateLiteral(argument)) ? argument.getLiteralValue() : void 0;
-};
-const literalValue = (node, jobName) => {
-  if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) {
-    return node.getLiteralValue();
-  }
-  if (Node.isNumericLiteral(node)) {
-    return node.getLiteralValue();
-  }
-  if (Node.isTrueLiteral(node)) {
-    return true;
-  }
-  if (Node.isFalseLiteral(node)) {
-    return false;
-  }
-  if (Node.isPrefixUnaryExpression(node) && node.getOperatorToken() === SyntaxKind.MinusToken) {
-    const operand = node.getOperand();
-    if (Node.isNumericLiteral(operand)) {
-      return -operand.getLiteralValue();
-    }
-  }
-  if (Node.isObjectLiteralExpression(node)) {
-    return objectLiteralValue(node, jobName);
-  }
-  if (Node.isArrayLiteralExpression(node)) {
-    return node.getElements().map((element) => literalValue(element, jobName));
-  }
-  throw diagnosticAt(node, `Cron job "${jobName}" passes a non-static value where a literal is required; codegen can only read literals.`, {
-    code: "CRON_NON_STATIC_VALUE",
-    name: "LunoraError",
-    status: 500
-  });
-};
-const objectLiteralValue = (object, jobName) => {
-  const result = {};
-  for (const property of object.getProperties()) {
-    if (!Node.isPropertyAssignment(property)) {
-      throw diagnosticAt(
-        property,
-        `Cron job "${jobName}" uses an unsupported object property (shorthand/spread/method) where a static literal is required.`,
-        {
-          code: "CRON_NON_STATIC_VALUE",
-          name: "LunoraError",
-          status: 500
-        }
-      );
-    }
-    const initializer = property.getInitializer();
-    if (initializer) {
-      result[property.getName()] = literalValue(initializer, jobName);
-    }
-  }
-  return result;
-};
-const functionPathFromArgument = (call, index, jobName) => {
-  const argument = call.getArguments()[index];
-  if (!argument || !Node.isPropertyAccessExpression(argument)) {
-    throw diagnosticAt(
-      call,
-      `Cron job "${jobName}" must reference a function statically (e.g. internal.email.digest); codegen cannot resolve a dynamic reference.`,
-      {
-        code: "CRON_NON_STATIC_FN",
-        name: "LunoraError",
-        status: 500
-      }
-    );
-  }
-  const functionName = argument.getName();
-  const receiver = argument.getExpression();
-  if (!Node.isPropertyAccessExpression(receiver)) {
-    throw diagnosticAt(argument, `Cron job "${jobName}" function reference must be of the form internal.file.fn (two property accesses).`, {
-      code: "CRON_NON_STATIC_FN",
-      name: "LunoraError",
-      status: 500
-    });
-  }
-  const namespace = receiver.getName();
-  return `${sanitizeNamespace(namespace)}:${functionName}`;
-};
-const workflowTarget = (workflow) => {
-  return { workflow: { binding: workflow.bindingName, exportName: workflow.exportName } };
-};
-const agentTarget = (agent) => {
-  return { workflow: { binding: agent.bindingName, exportName: agent.exportName } };
-};
-const resolveReferenceAccess = (argument, receiverName, byName, jobName, kind, build) => {
-  const receiver = argument.getExpression();
-  if (!Node.isIdentifier(receiver) || receiver.getText() !== receiverName) {
-    return void 0;
-  }
-  const definition = byName.get(argument.getName());
-  if (definition) {
-    return build(definition);
-  }
-  throw diagnosticAt(
-    argument,
-    `Cron job "${jobName}" targets ${receiverName}.${argument.getName()}, but no such ${kind} is declared in lunora/${kind}s.ts.`,
-    {
-      code: "CRON_NON_STATIC_FN",
-      name: "LunoraError",
-      status: 500
-    }
-  );
-};
-const resolveTarget = (call, index, jobName, workflowsByName, agentsByName) => {
-  const argument = call.getArguments()[index];
-  if (argument && Node.isPropertyAccessExpression(argument)) {
-    const workflowReference = resolveReferenceAccess(argument, "workflows", workflowsByName, jobName, "workflow", workflowTarget);
-    if (workflowReference) {
-      return workflowReference;
-    }
-    const agentReference = resolveReferenceAccess(argument, "agents", agentsByName, jobName, "agent", agentTarget);
-    if (agentReference) {
-      return agentReference;
-    }
-    return { functionPath: functionPathFromArgument(call, index, jobName) };
-  }
-  if (argument && Node.isIdentifier(argument)) {
-    const workflow = workflowsByName.get(argument.getText());
-    const agent = agentsByName.get(argument.getText());
-    if (workflow && agent) {
-      throw diagnosticAt(
-        argument,
-        `Cron job "${jobName}" references "${argument.getText()}", which is ambiguous: a workflow and an agent are both declared under that name.`,
-        {
-          code: "CRON_NON_STATIC_FN",
-          name: "LunoraError",
-          status: 500
-        }
-      );
-    }
-    if (workflow) {
-      return workflowTarget(workflow);
-    }
-    if (agent) {
-      return agentTarget(agent);
-    }
-    throw diagnosticAt(
-      argument,
-      `Cron job "${jobName}" references "${argument.getText()}", which is neither a function (internal.file.fn / api.file.fn) nor a declared workflow in lunora/workflows.ts nor a declared agent in lunora/agents.ts.`,
-      {
-        code: "CRON_NON_STATIC_FN",
-        name: "LunoraError",
-        status: 500
-      }
-    );
-  }
-  return { functionPath: functionPathFromArgument(call, index, jobName) };
-};
-const cronFromCall = (call, callee, builderNames, workflowsByName, agentsByName) => {
-  const method = callee.getName();
-  if (!CRON_METHODS.has(method)) {
-    return void 0;
-  }
-  if (!builderNames.has(rootIdentifierOf(callee.getExpression()) ?? "")) {
-    return void 0;
-  }
-  const name = stringArgument(call, 0);
-  if (name === void 0 || name.trim() === "") {
-    throw diagnosticAt(call, `A cron ".${method}(...)" registration must pass a non-empty string-literal name as its first argument.`, {
-      code: "CRON_NAME_NOT_STATIC",
-      name: "LunoraError",
-      status: 500
-    });
-  }
-  let cron;
-  if (method === "cron") {
-    const expression = stringArgument(call, 1);
-    if (expression === void 0) {
-      throw diagnosticAt(call, `Cron job "${name}" must pass a string-literal cron expression to ".cron(...)".`, {
-        code: "CRON_EXPR_NOT_STATIC",
-        name: "LunoraError",
-        status: 500
-      });
-    }
-    if (!isValidCronExpression(expression)) {
-      throw diagnosticAt(call, `Cron job "${name}" has an invalid cron expression "${expression}" — expected 5 or 6 space-separated fields.`, {
-        code: "CRON_EXPR_INVALID",
-        name: "LunoraError",
-        status: 500
-      });
-    }
-    cron = expression;
-  } else {
-    const scheduleArgument = call.getArguments()[1];
-    if (!scheduleArgument || !Node.isObjectLiteralExpression(scheduleArgument)) {
-      throw diagnosticAt(call, `Cron job "${name}" must pass an object-literal schedule to ".${method}(...)".`, {
-        code: "CRON_SCHEDULE_NOT_STATIC",
-        name: "LunoraError",
-        status: 500
-      });
-    }
-    cron = compileCronSchedule(method, objectLiteralValue(scheduleArgument, name));
-  }
-  const target = resolveTarget(call, 2, name, workflowsByName, agentsByName);
-  const argumentsNode = call.getArguments()[3];
-  const args = argumentsNode && Node.isObjectLiteralExpression(argumentsNode) ? objectLiteralValue(argumentsNode, name) : {};
-  return { args, cron, name, ...target };
-};
-const assertUniqueNames = (crons) => {
-  const seen = /* @__PURE__ */ new Set();
-  for (const cron of crons) {
-    if (seen.has(cron.name)) {
-      throw new LunoraError("DUPLICATE_CRON_NAME", `Duplicate cron job name "${cron.name}": cron names must be unique across the project.`, {
-        status: 500
-      });
-    }
-    seen.add(cron.name);
-  }
-};
-const discoverCrons = (project, lunoraDirectory, workflows = [], agents = []) => {
-  const filePaths = listLunoraSourceFiles(lunoraDirectory);
-  const crons = [];
-  const workflowsByName = new Map(workflows.map((workflow) => [workflow.exportName, workflow]));
-  const agentsByName = new Map(agents.map((agent) => [agent.exportName, agent]));
-  for (const filePath of filePaths) {
-    const source = project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
-    const builderNames = collectCronBuilderNames(source);
-    if (builderNames.size === 0) {
-      continue;
-    }
-    for (const call of source.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-      const callee = call.getExpression();
-      if (!Node.isPropertyAccessExpression(callee)) {
-        continue;
-      }
-      const cron = cronFromCall(call, callee, builderNames, workflowsByName, agentsByName);
-      if (cron) {
-        crons.push(cron);
-      }
-    }
-  }
-  crons.sort((a, b) => a.name.localeCompare(b.name));
-  assertUniqueNames(crons);
-  return crons;
-};
-
-export { discoverCrons as default };