@lunora/codegen 1.0.0-alpha.5 → 1.0.0-alpha.50

package/dist/packem_shared/{SCHEMA_SNAPSHOT_VERSION-DzLDbWk3.mjs → SCHEMA_SNAPSHOT_VERSION-D0ARY6rL.mjs}

@@ -1,3 +1,5 @@
+import { LunoraError } from '@lunora/errors';
+
 const SCHEMA_SNAPSHOT_VERSION = 1;
 const encodeShardMode = (mode) => {
   if (mode === "global" || mode === "root") {
@@ -39,6 +41,7 @@ const buildSchemaSnapshot = (schema, migrationIds) => {
     tables[table.name] = tableSnapshotOf(table);
   }
   return {
+    jurisdiction: schema.jurisdiction,
     migrationIds: [...migrationIds].toSorted((a, b) => a.localeCompare(b)),
     tables: sortKeys(tables),
     version: SCHEMA_SNAPSHOT_VERSION
@@ -46,8 +49,10 @@ const buildSchemaSnapshot = (schema, migrationIds) => {
 };
 const serializeSchemaSnapshot = (snapshot) => `${JSON.stringify(snapshot, void 0, 2)}
 `;
-class SchemaSnapshotParseError extends Error {
-  name = "SchemaSnapshotParseError";
+class SchemaSnapshotParseError extends LunoraError {
+  constructor(message) {
+    super("SCHEMA_SNAPSHOT_PARSE", message, { name: "SchemaSnapshotParseError" });
+  }
 }
 const isRecord = (value) => typeof value === "object" && value !== null;
 const isValidTableSnapshot = (value) => isRecord(value) && isRecord(value.fields) && isRecord(value.indexes) && isRecord(value.relations) && typeof value.shardMode === "string";
@@ -69,7 +74,9 @@ const parseSchemaSnapshot = (content) => {
       throw new SchemaSnapshotParseError(`baseline table "${name}" has an invalid structure`);
     }
   }
+  const jurisdiction = typeof parsed.jurisdiction === "string" ? parsed.jurisdiction : void 0;
   return {
+    jurisdiction,
     migrationIds: Array.isArray(parsed.migrationIds) ? parsed.migrationIds : [],
     tables: parsed.tables,
     version: SCHEMA_SNAPSHOT_VERSION
@@ -189,6 +196,15 @@ const diffSchemaSnapshots = (baseline, current) => {
       });
     }
   }
+  if (baseline !== void 0 && baseline.jurisdiction !== current.jurisdiction) {
+    const from = baseline.jurisdiction ?? "(none)";
+    const to = current.jurisdiction ?? "(none)";
+    changes.push({
+      severity: "breaking",
+      summary: `Durable Object jurisdiction changed from ${from} to ${to} — this re-homes every DO and strands all existing shard, scheduler, and session-DO data in the old region (no in-place migration; export then import to move it). Revert the change, or override the gate to proceed intentionally.`,
+      type: "changedJurisdiction"
+    });
+  }
   return { changes };
 };
 const evaluateSchemaDrift = (options) => {

package/dist/packem_shared/SHAPES_FILENAME-DOhPGi-6.mjs

@@ -0,0 +1,94 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { SyntaxKind, Node } from 'ts-morph';
+import { diagnosticAt } from './CodegenDiagnosticError-DyQ5FwkM.mjs';
+
+const SHAPES_FILENAME = "shapes.ts";
+const SHAPE_MODULE_SPECIFIERS = /* @__PURE__ */ new Set(["@lunora/server", "lunorash/server"]);
+const isDefineShape = (identifier) => {
+  const symbol = identifier.getSymbol();
+  if (!symbol) {
+    return identifier.getText() === "defineShape";
+  }
+  for (const declaration of symbol.getDeclarations()) {
+    if (!Node.isImportSpecifier(declaration)) {
+      continue;
+    }
+    if (!SHAPE_MODULE_SPECIFIERS.has(declaration.getImportDeclaration().getModuleSpecifierValue())) {
+      return false;
+    }
+    return declaration.getNameNode().getText() === "defineShape";
+  }
+  return false;
+};
+const isShapeNamespaceImport = (identifier) => {
+  const symbol = identifier.getSymbol();
+  if (!symbol) {
+    return false;
+  }
+  for (const declaration of symbol.getDeclarations()) {
+    if (!Node.isNamespaceImport(declaration)) {
+      continue;
+    }
+    const importDeclaration = declaration.getFirstAncestorByKind(SyntaxKind.ImportDeclaration);
+    return importDeclaration !== void 0 && SHAPE_MODULE_SPECIFIERS.has(importDeclaration.getModuleSpecifierValue());
+  }
+  return false;
+};
+const isDefineShapeCallee = (callee) => {
+  if (Node.isIdentifier(callee)) {
+    return isDefineShape(callee);
+  }
+  if (Node.isPropertyAccessExpression(callee)) {
+    const object = callee.getExpression();
+    return callee.getName() === "defineShape" && Node.isIdentifier(object) && isShapeNamespaceImport(object);
+  }
+  return false;
+};
+const tableLiteralFrom = (call) => {
+  const [config] = call.getArguments();
+  if (!config || !Node.isObjectLiteralExpression(config)) {
+    return void 0;
+  }
+  const tableProperty = config.getProperty("table");
+  if (!tableProperty || !Node.isPropertyAssignment(tableProperty)) {
+    return void 0;
+  }
+  const value = tableProperty.getInitializer();
+  return value && Node.isStringLiteral(value) ? value.getLiteralValue() : void 0;
+};
+const shapesFromSource = (source) => {
+  const shapes = [];
+  for (const declaration of source.getVariableDeclarations()) {
+    if (!declaration.isExported()) {
+      continue;
+    }
+    const initializer = declaration.getInitializer();
+    if (initializer?.getKind() !== SyntaxKind.CallExpression) {
+      continue;
+    }
+    const callExpression = initializer;
+    const callee = callExpression.getExpression();
+    if (!isDefineShapeCallee(callee)) {
+      continue;
+    }
+    const nameNode = declaration.getNameNode();
+    if (!Node.isIdentifier(nameNode)) {
+      throw diagnosticAt(nameNode, "defineShape exports must be plain named exports (no destructuring)");
+    }
+    shapes.push({ exportName: nameNode.getText(), filePath: "shapes", table: tableLiteralFrom(callExpression) });
+  }
+  return shapes;
+};
+const discoverShapes = (project, lunoraDirectory) => {
+  const shapesPath = join(lunoraDirectory, SHAPES_FILENAME);
+  if (!existsSync(shapesPath)) {
+    return [];
+  }
+  const source = project.getSourceFile(shapesPath) ?? project.addSourceFileAtPath(shapesPath);
+  const shapes = shapesFromSource(source);
+  shapes.sort((a, b) => a.exportName.localeCompare(b.exportName));
+  return shapes;
+};
+
+export { SHAPES_FILENAME, discoverShapes };

package/dist/packem_shared/WORKFLOWS_FILENAME-Dtuzvluc.mjs

@@ -0,0 +1,158 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { LunoraError } from '@lunora/errors';
+import { workflowDefaultName, workflowClassName, workflowBindingName } from '@lunora/workflow';
+import { Node, SyntaxKind } from 'ts-morph';
+import { diagnosticAt } from './CodegenDiagnosticError-DyQ5FwkM.mjs';
+
+const WORKFLOWS_FILENAME = "workflows.ts";
+const STEP_METHODS = /* @__PURE__ */ new Set(["do", "sleep", "sleepUntil", "waitForEvent"]);
+const isDefineWorkflow = (identifier) => {
+  const symbol = identifier.getSymbol();
+  if (!symbol) {
+    return identifier.getText() === "defineWorkflow";
+  }
+  for (const declaration of symbol.getDeclarations()) {
+    if (!Node.isImportSpecifier(declaration)) {
+      continue;
+    }
+    if (declaration.getImportDeclaration().getModuleSpecifierValue() !== "@lunora/workflow") {
+      return false;
+    }
+    return declaration.getNameNode().getText() === "defineWorkflow";
+  }
+  return false;
+};
+const stringProperty = (expression, exportName, property) => {
+  if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.getLiteralValue();
+  }
+  throw diagnosticAt(
+    expression,
+    `workflow "${exportName}": \`${property}\` must be a static string literal — it is deploy configuration codegen writes into wrangler.jsonc`
+  );
+};
+const isStepCall = (call) => {
+  const callee = call.getExpression();
+  if (!Node.isPropertyAccessExpression(callee) || !STEP_METHODS.has(callee.getName())) {
+    return false;
+  }
+  const receiver = callee.getExpression();
+  if (Node.isPropertyAccessExpression(receiver) && receiver.getName() === "step") {
+    return true;
+  }
+  return Node.isIdentifier(receiver) && receiver.getText() === "step";
+};
+const stepsFromHandler = (argument) => {
+  const handlerProperty = argument.getProperty("handler");
+  if (!handlerProperty) {
+    return [];
+  }
+  const body = Node.isPropertyAssignment(handlerProperty) ? handlerProperty.getInitializer() : handlerProperty;
+  if (!body) {
+    return [];
+  }
+  const steps = [];
+  for (const call of body.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+    if (!isStepCall(call)) {
+      continue;
+    }
+    const nameArgument = call.getArguments()[0];
+    if (!nameArgument || !(Node.isStringLiteral(nameArgument) || Node.isNoSubstitutionTemplateLiteral(nameArgument))) {
+      continue;
+    }
+    steps.push({
+      line: call.getStartLineNumber(),
+      // `isStepCall` already proved the callee is a `.<method>` property access.
+      method: call.getExpression().getName(),
+      name: nameArgument.getLiteralValue()
+    });
+  }
+  return steps;
+};
+const workflowFromCall = (call, exportName) => {
+  const argument = call.getArguments()[0];
+  if (!argument || !Node.isObjectLiteralExpression(argument)) {
+    throw diagnosticAt(call, `workflow "${exportName}": defineWorkflow must be passed an inline object literal`);
+  }
+  const ir = {
+    bindingName: workflowBindingName(exportName),
+    className: workflowClassName(exportName),
+    exportName,
+    name: workflowDefaultName(exportName),
+    steps: stepsFromHandler(argument)
+  };
+  const nameProperty = argument.getProperty("name");
+  if (nameProperty && Node.isPropertyAssignment(nameProperty)) {
+    ir.name = stringProperty(nameProperty.getInitializerOrThrow(), exportName, "name");
+  }
+  return ir;
+};
+const unwrapToCallExpression = (node) => {
+  let current = node;
+  while (current && (Node.isAsExpression(current) || Node.isSatisfiesExpression(current) || Node.isParenthesizedExpression(current))) {
+    current = current.getExpression();
+  }
+  return current && Node.isCallExpression(current) ? current : void 0;
+};
+const workflowsFromSource = (source) => {
+  const workflows = [];
+  for (const declaration of source.getVariableDeclarations()) {
+    if (!declaration.isExported()) {
+      continue;
+    }
+    const call = unwrapToCallExpression(declaration.getInitializer());
+    if (!call) {
+      continue;
+    }
+    const callee = call.getExpression();
+    if (!Node.isIdentifier(callee) || !isDefineWorkflow(callee)) {
+      continue;
+    }
+    const nameNode = declaration.getNameNode();
+    if (!Node.isIdentifier(nameNode)) {
+      throw diagnosticAt(nameNode, "defineWorkflow exports must be plain named exports (no destructuring)");
+    }
+    workflows.push(workflowFromCall(call, nameNode.getText()));
+  }
+  return workflows;
+};
+const assertUniqueNames = (workflows) => {
+  const seenNames = /* @__PURE__ */ new Map();
+  const seenBindings = /* @__PURE__ */ new Map();
+  for (const workflow of workflows) {
+    const priorName = seenNames.get(workflow.name);
+    if (priorName !== void 0) {
+      throw new LunoraError(
+        // eslint-disable-next-line no-secrets/no-secrets -- an error code, not a secret
+        "DUPLICATE_WORKFLOW_NAME",
+        `Duplicate workflow name "${workflow.name}": produced by both "${priorName}" and "${workflow.exportName}". Deployed workflow names must be unique across the project.`,
+        { status: 500 }
+      );
+    }
+    seenNames.set(workflow.name, workflow.exportName);
+    const priorBinding = seenBindings.get(workflow.bindingName);
+    if (priorBinding !== void 0) {
+      throw new LunoraError(
+        // eslint-disable-next-line no-secrets/no-secrets -- an error code, not a secret
+        "DUPLICATE_WORKFLOW_BINDING",
+        `Duplicate workflow binding "${workflow.bindingName}": produced by both "${priorBinding}" and "${workflow.exportName}". Workflow export names must yield unique binding names.`,
+        { status: 500 }
+      );
+    }
+    seenBindings.set(workflow.bindingName, workflow.exportName);
+  }
+};
+const discoverWorkflows = (project, lunoraDirectory) => {
+  const workflowsPath = join(lunoraDirectory, WORKFLOWS_FILENAME);
+  if (!existsSync(workflowsPath)) {
+    return [];
+  }
+  const source = project.getSourceFile(workflowsPath) ?? project.addSourceFileAtPath(workflowsPath);
+  const workflows = workflowsFromSource(source);
+  workflows.sort((a, b) => a.exportName.localeCompare(b.exportName));
+  assertUniqueNames(workflows);
+  return workflows;
+};
+
+export { WORKFLOWS_FILENAME, discoverWorkflows };

package/dist/packem_shared/{buildOpenApiDocument-Cns1EkCQ.mjs → buildOpenApiDocument-B7mEdzA2.mjs}

@@ -1,6 +1,6 @@
-import { GENERATED_HEADER } from './GENERATED_HEADER-DF1hQcix.mjs';
+import { G as GENERATED_HEADER } from './emit-ClTbCLy4.mjs';
 import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
-import { LUNORA_ERROR_CODES, objectSchema, argsObjectSchema, validatorIrToJsonSchema } from './LUNORA_ERROR_CODES-CySpQPD3.mjs';
+import { LUNORA_ERROR_CODES, objectSchema, argsObjectSchema, validatorIrToJsonSchema } from './LUNORA_ERROR_CODES-DvTLozCu.mjs';
 
 const ERROR_COMPONENT_REF = "#/components/responses/LunoraError";
 const ROUTE_PARAM_RE = /:([A-Za-z_$][\w$]*)/gu;

package/dist/packem_shared/{discoverAuthApiCalls-C35R6z0T.mjs → discoverAuthApiCalls-Dx3K42rk.mjs}

@@ -1,7 +1,7 @@
 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-DEgAcRuD.mjs';
+import { listLunoraSourceFiles } from './discoverFunctions-BJ-qR7Rg.mjs';
 
 const isAuthApiCall = (call) => {
   const callee = call.getExpression();

package/dist/packem_shared/{discoverCrons-BL6iGuJ3.mjs → discoverCrons-DvqkEWdx.mjs}

@@ -1,6 +1,8 @@
+import { LunoraError } from '@lunora/errors';
 import { isValidCronExpression, compileCronSchedule, CRON_SCHEDULE_KINDS } from '@lunora/scheduler';
 import { SyntaxKind, Node } from 'ts-morph';
-import { listLunoraSourceFiles } from './discoverFunctions-DEgAcRuD.mjs';
+import { diagnosticAt } from './CodegenDiagnosticError-DyQ5FwkM.mjs';
+import { listLunoraSourceFiles } from './discoverFunctions-BJ-qR7Rg.mjs';
 import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
 
 const CRON_METHODS = /* @__PURE__ */ new Set([...CRON_SCHEDULE_KINDS, "cron"]);
@@ -44,7 +46,7 @@ const rootIdentifierOf = (node) => {
 };
 const stringArgument = (call, index) => {
   const argument = call.getArguments()[index];
-  return argument && Node.isStringLiteral(argument) ? argument.getLiteralValue() : void 0;
+  return argument && (Node.isStringLiteral(argument) || Node.isNoSubstitutionTemplateLiteral(argument)) ? argument.getLiteralValue() : void 0;
 };
 const literalValue = (node, jobName) => {
   if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) {
@@ -71,7 +73,7 @@ const literalValue = (node, jobName) => {
   if (Node.isArrayLiteralExpression(node)) {
     return node.getElements().map((element) => literalValue(element, jobName));
   }
-  throw Object.assign(new Error(`Cron job "${jobName}" passes a non-static value where a literal is required; codegen can only read literals.`), {
+  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
@@ -81,8 +83,9 @@ const objectLiteralValue = (object, jobName) => {
   const result = {};
   for (const property of object.getProperties()) {
     if (!Node.isPropertyAssignment(property)) {
-      throw Object.assign(
-        new Error(`Cron job "${jobName}" uses an unsupported object property (shorthand/spread/method) where a static literal is required.`),
+      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",
@@ -100,8 +103,9 @@ const objectLiteralValue = (object, jobName) => {
 const functionPathFromArgument = (call, index, jobName) => {
   const argument = call.getArguments()[index];
   if (!argument || !Node.isPropertyAccessExpression(argument)) {
-    throw Object.assign(
-      new Error(`Cron job "${jobName}" must reference a function statically (e.g. internal.email.digest); codegen cannot resolve a dynamic reference.`),
+    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",
@@ -112,7 +116,7 @@ const functionPathFromArgument = (call, index, jobName) => {
   const functionName = argument.getName();
   const receiver = argument.getExpression();
   if (!Node.isPropertyAccessExpression(receiver)) {
-    throw Object.assign(new Error(`Cron job "${jobName}" function reference must be of the form internal.file.fn (two property accesses).`), {
+    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
@@ -124,17 +128,48 @@ const functionPathFromArgument = (call, index, jobName) => {
 const workflowTarget = (workflow) => {
   return { workflow: { binding: workflow.bindingName, exportName: workflow.exportName } };
 };
-const resolveTarget = (call, index, jobName, workflowsByName) => {
+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 receiver = argument.getExpression();
-    if (Node.isIdentifier(receiver) && receiver.getText() === "workflows") {
-      const workflow = workflowsByName.get(argument.getName());
-      if (workflow) {
-        return workflowTarget(workflow);
-      }
-      throw Object.assign(
-        new Error(`Cron job "${jobName}" targets workflows.${argument.getName()}, but no such workflow is declared in lunora/workflows.ts.`),
+    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",
@@ -142,17 +177,15 @@ const resolveTarget = (call, index, jobName, workflowsByName) => {
         }
       );
     }
-    return { functionPath: functionPathFromArgument(call, index, jobName) };
-  }
-  if (argument && Node.isIdentifier(argument)) {
-    const workflow = workflowsByName.get(argument.getText());
     if (workflow) {
       return workflowTarget(workflow);
     }
-    throw Object.assign(
-      new Error(
-        `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.`
-      ),
+    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",
@@ -162,7 +195,7 @@ const resolveTarget = (call, index, jobName, workflowsByName) => {
   }
   return { functionPath: functionPathFromArgument(call, index, jobName) };
 };
-const cronFromCall = (call, callee, builderNames, workflowsByName) => {
+const cronFromCall = (call, callee, builderNames, workflowsByName, agentsByName) => {
   const method = callee.getName();
   if (!CRON_METHODS.has(method)) {
     return void 0;
@@ -172,7 +205,7 @@ const cronFromCall = (call, callee, builderNames, workflowsByName) => {
   }
   const name = stringArgument(call, 0);
   if (name === void 0 || name.trim() === "") {
-    throw Object.assign(new Error(`A cron ".${method}(...)" registration must pass a non-empty string-literal name as its first argument.`), {
+    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
@@ -182,14 +215,14 @@ const cronFromCall = (call, callee, builderNames, workflowsByName) => {
   if (method === "cron") {
     const expression = stringArgument(call, 1);
     if (expression === void 0) {
-      throw Object.assign(new Error(`Cron job "${name}" must pass a string-literal cron expression to ".cron(...)".`), {
+      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 Object.assign(new Error(`Cron job "${name}" has an invalid cron expression "${expression}" — expected 5 or 6 space-separated fields.`), {
+      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
@@ -199,7 +232,7 @@ const cronFromCall = (call, callee, builderNames, workflowsByName) => {
   } else {
     const scheduleArgument = call.getArguments()[1];
     if (!scheduleArgument || !Node.isObjectLiteralExpression(scheduleArgument)) {
-      throw Object.assign(new Error(`Cron job "${name}" must pass an object-literal schedule to ".${method}(...)".`), {
+      throw diagnosticAt(call, `Cron job "${name}" must pass an object-literal schedule to ".${method}(...)".`, {
         code: "CRON_SCHEDULE_NOT_STATIC",
         name: "LunoraError",
         status: 500
@@ -207,7 +240,7 @@ const cronFromCall = (call, callee, builderNames, workflowsByName) => {
     }
     cron = compileCronSchedule(method, objectLiteralValue(scheduleArgument, name));
   }
-  const target = resolveTarget(call, 2, name, workflowsByName);
+  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 };
@@ -216,19 +249,18 @@ const assertUniqueNames = (crons) => {
   const seen = /* @__PURE__ */ new Set();
   for (const cron of crons) {
     if (seen.has(cron.name)) {
-      throw Object.assign(new Error(`Duplicate cron job name "${cron.name}": cron names must be unique across the project.`), {
-        code: "DUPLICATE_CRON_NAME",
-        name: "LunoraError",
+      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 = []) => {
+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);
@@ -240,7 +272,7 @@ const discoverCrons = (project, lunoraDirectory, workflows = []) => {
       if (!Node.isPropertyAccessExpression(callee)) {
         continue;
       }
-      const cron = cronFromCall(call, callee, builderNames, workflowsByName);
+      const cron = cronFromCall(call, callee, builderNames, workflowsByName, agentsByName);
       if (cron) {
         crons.push(cron);
       }