@lunora/codegen 1.0.0-alpha.4 → 1.0.0-alpha.40

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-DRDQdhfq.mjs → WORKFLOWS_FILENAME-B2By8S4s.mjs}

@@ -1,10 +1,12 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { LunoraError } from '@lunora/errors';
 import { workflowDefaultName, workflowClassName, workflowBindingName } from '@lunora/workflow';
 import { SyntaxKind, Node } from 'ts-morph';
-import { diagnosticAt } from './CodegenDiagnosticError-54jWDxA9.mjs';
+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) {
@@ -30,6 +32,44 @@ const stringProperty = (expression, exportName, property) => {
     `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)) {
@@ -39,7 +79,8 @@ const workflowFromCall = (call, exportName) => {
     bindingName: workflowBindingName(exportName),
     className: workflowClassName(exportName),
     exportName,
-    name: workflowDefaultName(exportName)
+    name: workflowDefaultName(exportName),
+    steps: stepsFromHandler(argument)
   };
   const nameProperty = argument.getProperty("name");
   if (nameProperty && Node.isPropertyAssignment(nameProperty)) {
@@ -70,6 +111,32 @@ const workflowsFromSource = (source) => {
   }
   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)) {
@@ -78,6 +145,7 @@ const discoverWorkflows = (project, lunoraDirectory) => {
   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;
 };
 

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

@@ -1,6 +1,6 @@
-import { GENERATED_HEADER } from './GENERATED_HEADER-DF1hQcix.mjs';
+import { G as GENERATED_HEADER } from './emit-CFz-9dcD.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-WMx8L2FG.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-CZ91aenA.mjs';
 
 const isAuthApiCall = (call) => {
   const callee = call.getExpression();

package/dist/packem_shared/{discoverCrons-BL6iGuJ3.mjs → discoverCrons-D-jrpm97.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-CZ91aenA.mjs';
 import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
 
 const CRON_METHODS = /* @__PURE__ */ new Set([...CRON_SCHEDULE_KINDS, "cron"]);
@@ -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
@@ -133,8 +137,9 @@ const resolveTarget = (call, index, jobName, workflowsByName) => {
       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.`),
+      throw diagnosticAt(
+        argument,
+        `Cron job "${jobName}" targets workflows.${argument.getName()}, but no such workflow is declared in lunora/workflows.ts.`,
         {
           code: "CRON_NON_STATIC_FN",
           name: "LunoraError",
@@ -149,10 +154,9 @@ const resolveTarget = (call, index, jobName, workflowsByName) => {
     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.`
-      ),
+    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.`,
       {
         code: "CRON_NON_STATIC_FN",
         name: "LunoraError",
@@ -172,7 +176,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 +186,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 +203,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
@@ -216,9 +220,7 @@ 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
       });
     }

package/dist/packem_shared/{discoverFunctions-DEgAcRuD.mjs → discoverFunctions-CZ91aenA.mjs}

@@ -1,11 +1,12 @@
 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-tuQtHrsr.mjs';
+import { a as parseObjectShape } from './parse-validator-BSJo1HGP.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/u;
+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;
@@ -221,7 +222,7 @@ const unwrapHandlerReturn = (handler) => {
   if (!rendered || rendered === "any" || rendered === "never") {
     return "unknown";
   }
-  if (ANY_TOKEN_RE.test(rendered)) {
+  if (ANY_TOKEN_RE.test(rendered.replaceAll(STRING_LITERAL_SPAN_RE, ""))) {
     return "unknown";
   }
   const handlerFilePath = handler.getSourceFile().getFilePath();
@@ -290,24 +291,73 @@ const classifyProcedureCall = (call) => {
   if (!Node.isIdentifier(callee)) {
     return void 0;
   }
-  const calleeName = resolveCalleeKind(callee);
-  if (!calleeName) {
+  const calleeName2 = resolveCalleeKind(callee);
+  if (!calleeName2) {
     return void 0;
   }
-  if (FUNCTION_KINDS.has(calleeName)) {
-    return { kind: calleeName, visibility: "public" };
+  if (FUNCTION_KINDS.has(calleeName2)) {
+    return { kind: calleeName2, visibility: "public" };
   }
-  const internalKind = INTERNAL_FACTORIES[calleeName];
+  const internalKind = INTERNAL_FACTORIES[calleeName2];
   if (internalKind) {
     return { kind: internalKind, visibility: "internal" };
   }
-  const lifecycle = LIFECYCLE_FACTORIES[calleeName];
+  const lifecycle = LIFECYCLE_FACTORIES[calleeName2];
   if (lifecycle) {
     return { kind: "mutation", lifecycle, visibility: "internal" };
   }
   return void 0;
 };
-const listLunoraSourceFiles = (directory, accumulator = []) => {
+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);
@@ -321,8 +371,11 @@ const listLunoraSourceFiles = (directory, accumulator = []) => {
       if (entry === "_generated" || entry === "node_modules") {
         continue;
       }
-      listLunoraSourceFiles(full, accumulator);
-    } else if (info.isFile() && extname(entry) === ".ts" && entry !== "schema.ts") {
+      listLunoraSourceFiles(full, accumulator, root);
+    } else if (info.isFile() && extname(entry) === ".ts") {
+      if (entry === "schema.ts" && directory === root) {
+        continue;
+      }
       accumulator.push(full);
     }
   }
@@ -344,7 +397,12 @@ const discoverFromCall = (call) => {
   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 };
+  return {
+    args: argsFromCall(call),
+    kind: classified.kind,
+    returnType: returnTypeFromCall(call),
+    visibility: classified.visibility
+  };
 };
 const RE_EXPORT_RESOLVE_LIMIT = 8;
 const resolveExpressionToCall = (node, depth = 0) => {
@@ -457,4 +515,4 @@ const discoverFunctions = (project, lunoraDirectory) => {
   return functions;
 };
 
-export { classifyProcedureCall, discoverFunctions, listLunoraSourceFiles, lunoraRelativePath };
+export { chainHasStep, chainUsesWrappedCall, classifyProcedureCall, discoverFunctions, inlineHandler, isDatabaseAccessor, listLunoraSourceFiles, lunoraRelativePath, procedureHandler };

package/dist/packem_shared/{discoverHttpRoutes-C978pBiG.mjs → discoverHttpRoutes-DNZLDCmm.mjs}

@@ -1,7 +1,7 @@
 import { relative, sep } from 'node:path';
 import { Node } from 'ts-morph';
-import { listLunoraSourceFiles } from './discoverFunctions-DEgAcRuD.mjs';
-import { p as parseValidator, a as parseObjectShape } from './parse-validator-tuQtHrsr.mjs';
+import { listLunoraSourceFiles } from './discoverFunctions-CZ91aenA.mjs';
+import { p as parseValidator, a as parseObjectShape } from './parse-validator-BSJo1HGP.mjs';
 
 const TS_EXTENSION_RE = /\.ts$/u;
 const HTTP_VERBS = /* @__PURE__ */ new Set(["delete", "get", "head", "options", "patch", "post", "put"]);

package/dist/packem_shared/{discoverInserts-CRQdXvHO.mjs → discoverInserts-DFRJhmCv.mjs}

@@ -1,6 +1,6 @@
 import { SyntaxKind, Node } from 'ts-morph';
 import { e as enclosingExportName } from './discover-ast-CT6BgBr4.mjs';
-import { listLunoraSourceFiles, lunoraRelativePath } from './discoverFunctions-DEgAcRuD.mjs';
+import { listLunoraSourceFiles, lunoraRelativePath } from './discoverFunctions-CZ91aenA.mjs';
 
 const isDatabaseInsertCall = (call) => {
   const callee = call.getExpression();
@@ -13,9 +13,31 @@ const isDatabaseInsertCall = (call) => {
   }
   return Node.isIdentifier(receiver) && receiver.getText() === "db";
 };
+const resolveStringConst = (identifier) => {
+  if (!Node.isIdentifier(identifier)) {
+    return void 0;
+  }
+  const symbol = identifier.getSymbol();
+  const declarations = symbol?.getAliasedSymbol()?.getDeclarations() ?? symbol?.getDeclarations() ?? [];
+  for (const declaration of declarations) {
+    if (Node.isVariableDeclaration(declaration)) {
+      const initializer = declaration.getInitializer();
+      if (initializer && Node.isStringLiteral(initializer)) {
+        return initializer.getLiteralText();
+      }
+    }
+  }
+  return void 0;
+};
 const tableOf = (call) => {
   const argument = call.getArguments()[0];
-  return argument && Node.isStringLiteral(argument) ? argument.getLiteralText() : "";
+  if (!argument) {
+    return "";
+  }
+  if (Node.isStringLiteral(argument)) {
+    return argument.getLiteralText();
+  }
+  return resolveStringConst(argument) ?? "";
 };
 const discoverInserts = (project, lunoraDirectory) => {
   const writes = [];

package/dist/packem_shared/{discoverMaskProcedures-B64zA740.mjs → discoverMaskProcedures-B5iFnZ-X.mjs}

@@ -1,5 +1,5 @@
 import { Node, SyntaxKind } from 'ts-morph';
-import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-DEgAcRuD.mjs';
+import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-CZ91aenA.mjs';
 
 const isMaskCall = (node) => {
   if (!Node.isCallExpression(node)) {
@@ -213,5 +213,61 @@ const discoverMaskMetadata = (project, lunoraDirectory) => {
   }
   return { columns: [...columnsByKey.values()] };
 };
+const extractMaskStrategyRows = (maskCall, exportName, relativePath) => {
+  const argument = maskCall.getArguments()[0];
+  if (!argument || !Node.isObjectLiteralExpression(argument)) {
+    return [];
+  }
+  const rows = [];
+  for (const tableProperty of argument.getProperties()) {
+    const table = memberName(tableProperty);
+    if (table === void 0 || !Node.isPropertyAssignment(tableProperty)) {
+      continue;
+    }
+    const initializer = tableProperty.getInitializer();
+    if (!initializer || !Node.isObjectLiteralExpression(initializer)) {
+      continue;
+    }
+    for (const columnProperty of initializer.getProperties()) {
+      const column = memberName(columnProperty);
+      if (column === void 0) {
+        continue;
+      }
+      const strategy = strategyOf(columnProperty);
+      if (strategy === "custom") {
+        continue;
+      }
+      rows.push({ column, exportName, file: relativePath, line: columnProperty.getStartLineNumber(), strategy, table });
+    }
+  }
+  return rows;
+};
+const maskStrategyRowsFromDeclaration = (declaration, relativePath) => {
+  if (!Node.isVariableDeclaration(declaration)) {
+    return [];
+  }
+  const initializer = declaration.getInitializer();
+  const classified = initializer && Node.isCallExpression(initializer) ? classifyProcedureCall(initializer) : void 0;
+  if (!classified?.receiver) {
+    return [];
+  }
+  return maskCallsInChain(classified.receiver).flatMap((maskCall) => extractMaskStrategyRows(maskCall, declaration.getName(), relativePath));
+};
+const discoverMaskStrategies = (project, lunoraDirectory) => {
+  const rows = [];
+  for (const filePath of listLunoraSourceFiles(lunoraDirectory)) {
+    const sourceFile = project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
+    const relativePath = lunoraRelativePath(lunoraDirectory, filePath);
+    for (const statement of sourceFile.getVariableStatements()) {
+      if (!statement.isExported()) {
+        continue;
+      }
+      for (const declaration of statement.getDeclarations()) {
+        rows.push(...maskStrategyRowsFromDeclaration(declaration, relativePath));
+      }
+    }
+  }
+  return rows;
+};
 
-export { discoverMaskProcedures as default, discoverMaskMetadata };
+export { discoverMaskProcedures as default, discoverMaskMetadata, discoverMaskStrategies };