@lunora/codegen 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/packem_shared/{createCodegenProject-DGJm0_Pk.mjs → SCHEMA_SNAPSHOT_FILENAME-BMez-jgr.mjs}

@@ -1,27 +1,33 @@
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
+import { performance } from 'node:perf_hooks';
 import { Node, SyntaxKind, Project } from 'ts-morph';
-import { lintSchema } from './lintSchema-DicbOHvH.mjs';
-import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall, discoverFunctions } from './discoverFunctions-DEgAcRuD.mjs';
-import discoverAuthApiCalls from './discoverAuthApiCalls-C35R6z0T.mjs';
-import { discoverContainers } from './CONTAINERS_FILENAME-0K-pjNb8.mjs';
-import discoverCrons from './discoverCrons-BL6iGuJ3.mjs';
-import discoverHttpRoutes from './discoverHttpRoutes-C978pBiG.mjs';
-import discoverInserts from './discoverInserts-CRQdXvHO.mjs';
-import discoverMaskProcedures, { discoverMaskMetadata } from './discoverMaskProcedures-B64zA740.mjs';
-import discoverMigrations from './discoverMigrations-Doj_-BAA.mjs';
-import discoverNondeterministicCalls from './discoverNondeterministicCalls-4KiPQxQU.mjs';
-import discoverQueries from './discoverQueries-BkIi0dBD.mjs';
-import discoverRlsProcedures, { discoverRlsMetadata } from './discoverRlsMetadata-DpRB1HMe.mjs';
-import discoverSchema from './discoverSchema-BBulgGbH.mjs';
-import discoverStorageRulesMetadata from './discoverStorageRulesMetadata-DAqJUxUv.mjs';
+import { lintSchema } from './formatAdvisories-DdjK7sgh.mjs';
+import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall, discoverFunctions } from './discoverFunctions-BWMczzBx.mjs';
+import discoverAuthApiCalls from './discoverAuthApiCalls-CoirYbg6.mjs';
+import { discoverContainers } from './CONTAINERS_FILENAME-DlP6YM_Q.mjs';
+import discoverCrons from './discoverCrons-Cev7RRAf.mjs';
+import { discoverFlagKeys } from './FLAGS_FILENAME-B1vE0LIo.mjs';
+import discoverHttpRoutes from './discoverHttpRoutes-CfP6cMzt.mjs';
+import discoverInserts from './discoverInserts-C7zxXkUf.mjs';
+import discoverMaskProcedures, { discoverMaskMetadata } from './discoverMaskProcedures-Cm81kwrb.mjs';
+import discoverMigrations from './discoverMigrations-Bi5nJ0mJ.mjs';
+import { MUTATORS_FILENAME, isDefineMutatorCallee, discoverMutators } from './MUTATORS_FILENAME-BhqdPtKp.mjs';
+import discoverNondeterministicCalls from './discoverNondeterministicCalls-C4M8AXmQ.mjs';
+import discoverQueries from './discoverQueries-B0wGT-xe.mjs';
+import { discoverQueues } from './QUEUES_FILENAME-B5_eWCRe.mjs';
+import discoverR2sqlCalls from './discoverR2sqlCalls-BVNMd428.mjs';
+import discoverRlsProcedures, { discoverRlsMetadata } from './discoverRlsMetadata-BS9GOGC5.mjs';
+import discoverSchema from './discoverSchema-KYq55qu3.mjs';
+import { discoverShapes } from './SHAPES_FILENAME-ChV7MqgE.mjs';
+import discoverStorageRulesMetadata from './discoverStorageRulesMetadata-Da8BKXcI.mjs';
 import { e as enclosingExportName$1 } from './discover-ast-CT6BgBr4.mjs';
-import { discoverWorkflows } from './discoverWorkflows-DRDQdhfq.mjs';
-import { buildStorageColumns, emitDataModel, emitApi, emitServer, emitFunctions, emitShard, emitContainers, emitWorkflows, emitCrons, emitVectors, emitDrizzleSchema, emitSeed, emitWranglerCronTriggers } from './emitApi-hRVC-kE7.mjs';
-import { emitApp } from './emitApp-CzZ6GbrD.mjs';
-import { buildOpenApiDocument, emitOpenApiModule } from './buildOpenApiDocument-yHVN66Xd.mjs';
-import { buildOpenRpcDocument, emitOpenRpcModule } from './buildOpenRpcDocument-BZGY1-jT.mjs';
-import { buildSchemaSnapshot, serializeSchemaSnapshot } from './buildSchemaSnapshot-DzLDbWk3.mjs';
+import { discoverWorkflows } from './WORKFLOWS_FILENAME-CCisG0Vy.mjs';
+import { buildStorageColumns, emitDataModel, emitApi, emitServer, emitFunctions, emitShard, emitCollections, emitContainers, emitWorkflows, emitQueues, emitCrons, emitVectors, emitDrizzleSchema, emitSeed, emitWranglerCronTriggers } from './GENERATED_HEADER-CI272wRm.mjs';
+import { emitApp } from './emitApp-cOSypPuO.mjs';
+import { buildOpenApiDocument, emitOpenApiModule } from './buildOpenApiDocument-Dx5QftUn.mjs';
+import { buildOpenRpcDocument, emitOpenRpcModule } from './OPENRPC_VERSION-t5pV2NIN.mjs';
+import { buildSchemaSnapshot, serializeSchemaSnapshot } from './SCHEMA_SNAPSHOT_VERSION-wWGP2_5E.mjs';
 
 const HTTP_VERBS = /* @__PURE__ */ new Set(["delete", "get", "head", "options", "patch", "post", "put"]);
 const TERMINAL_STEPS = /* @__PURE__ */ new Set(["handler", "stream"]);
@@ -237,18 +243,28 @@ const discoverArgumentValidators = (project, lunoraDirectory) => {
 };
 
 const PROBES = {
+  // The middleware (`accessContext()` / `accessRoles()`) imports the `/context`
+  // and `/roles` subpaths, NOT the bare `@lunora/cloudflare-access` specifier —
+  // so the per-procedure middleware never trips the global `ctx.access` wiring.
+  // A handler reading `ctx.access` is the signal that wires it onto every ctx.
+  access: { contextProperty: "access", moduleSpecifier: "@lunora/cloudflare-access" },
   ai: { contextProperty: "ai", moduleSpecifier: "@lunora/ai" },
-  analytics: { contextProperty: "analytics", moduleSpecifier: "@lunora/analytics" },
+  analytics: { contextProperty: "analytics", moduleSpecifier: "@lunora/bindings/analytics" },
   browser: { contextProperty: "browser", moduleSpecifier: "@lunora/browser" },
+  flags: { contextProperty: "flags", moduleSpecifier: "@lunora/flags" },
   hyperdrive: { contextProperty: "sql", moduleSpecifier: "@lunora/hyperdrive" },
-  images: { contextProperty: "images", moduleSpecifier: "@lunora/images" },
-  kv: { contextProperty: "kv", moduleSpecifier: "@lunora/kv" },
+  images: { contextProperty: "images", moduleSpecifier: "@lunora/bindings/images" },
+  kv: { contextProperty: "kv", moduleSpecifier: "@lunora/bindings/kv" },
   mail: { moduleSpecifier: "@lunora/mail" },
   payments: { contextProperty: "payments", moduleSpecifier: "@lunora/payment" },
-  pipelines: { contextProperty: "pipelines", moduleSpecifier: "@lunora/pipelines" },
+  // Pipelines is its own `@lunora/bindings/pipelines` subpath (distinct from
+  // `/analytics`), so a real import is a clean signal that won't be flipped by a
+  // plain analytics import; `ctx.pipelines` reads flip it too.
+  pipelines: { contextProperty: "pipelines", moduleSpecifier: "@lunora/bindings/pipelines" },
+  r2sql: { contextProperty: "r2sql", moduleSpecifier: "@lunora/bindings/r2sql" },
   scheduler: { contextProperty: "scheduler", moduleSpecifier: "@lunora/scheduler" },
   storage: { contextProperty: "storage", moduleSpecifier: "@lunora/storage" },
-  vectors: { contextProperty: "vectors", moduleSpecifier: "@lunora/vectors" },
+  vectors: { contextProperty: "vectors", moduleSpecifier: "@lunora/bindings/vectors" },
   workflows: { contextProperty: "workflows", moduleSpecifier: "@lunora/workflow" }
 };
 const readsContextProperty = (sourceFile, property) => {
@@ -268,15 +284,18 @@ const readsContextProperty = (sourceFile, property) => {
 };
 const discoverFeatureUsage = (project, lunoraDirectory) => {
   const usage = {
+    access: false,
     ai: false,
     analytics: false,
     browser: false,
+    flags: false,
     hyperdrive: false,
     images: false,
     kv: false,
     mail: false,
     payments: false,
     pipelines: false,
+    r2sql: false,
     scheduler: false,
     storage: false,
     vectors: false,
@@ -307,15 +326,72 @@ const discoverFeatureUsage = (project, lunoraDirectory) => {
 };
 const buildStudioFeatures = (usage, signals) => {
   return {
+    flags: usage.flags || signals.dependencies.has("@lunora/flags"),
     mail: usage.mail || signals.dependencies.has("@lunora/mail"),
     payments: usage.payments || signals.dependencies.has("@lunora/payment"),
+    queues: signals.queueCount > 0 || signals.dependencies.has("@lunora/queue"),
     scheduler: usage.scheduler || signals.cronCount > 0 || signals.dependencies.has("@lunora/scheduler"),
     storage: usage.storage || signals.storageRuleCount > 0 || signals.storageColumnCount > 0 || signals.dependencies.has("@lunora/storage"),
-    vectors: usage.vectors || signals.vectorIndexCount > 0 || signals.dependencies.has("@lunora/vectors"),
+    vectors: usage.vectors || signals.vectorIndexCount > 0 || signals.dependencies.has("@lunora/bindings/vectors"),
     workflows: usage.workflows || signals.workflowCount > 0 || signals.dependencies.has("@lunora/workflow")
   };
 };
 
+const isDatabaseReplaceCall = (call) => {
+  const callee = call.getExpression();
+  if (!Node.isPropertyAccessExpression(callee) || callee.getName() !== "replace") {
+    return false;
+  }
+  const receiver = callee.getExpression();
+  if (Node.isPropertyAccessExpression(receiver)) {
+    return receiver.getName() === "db";
+  }
+  return Node.isIdentifier(receiver) && receiver.getText() === "db";
+};
+const serverImplNode = (call) => {
+  const argument = call.getArguments()[0];
+  if (argument === void 0 || !Node.isObjectLiteralExpression(argument)) {
+    return void 0;
+  }
+  const property = argument.getProperty("server");
+  if (property === void 0) {
+    return void 0;
+  }
+  return Node.isPropertyAssignment(property) ? property.getInitializer() : property;
+};
+const exportedDefineMutatorCall = (declaration) => {
+  if (!declaration.isExported()) {
+    return void 0;
+  }
+  const initializer = declaration.getInitializer();
+  if (initializer?.getKind() !== SyntaxKind.CallExpression) {
+    return void 0;
+  }
+  const call = initializer;
+  return isDefineMutatorCallee(call.getExpression()) ? call : void 0;
+};
+const writesFromDeclaration = (declaration) => {
+  const call = exportedDefineMutatorCall(declaration);
+  const serverImpl = call === void 0 ? void 0 : serverImplNode(call);
+  if (serverImpl === void 0) {
+    return [];
+  }
+  const nameNode = declaration.getNameNode();
+  const exportName = Node.isIdentifier(nameNode) ? nameNode.getText() : "";
+  return serverImpl.getDescendantsOfKind(SyntaxKind.CallExpression).filter((replaceCall) => isDatabaseReplaceCall(replaceCall)).map((replaceCall) => {
+    return { exportName, file: "lunora/mutators.ts", line: replaceCall.getStartLineNumber() };
+  });
+};
+const mutatorWritesFromSource = (source) => source.getVariableDeclarations().flatMap((declaration) => writesFromDeclaration(declaration));
+const discoverMutatorWrites = (project, lunoraDirectory) => {
+  const mutatorsPath = join(lunoraDirectory, MUTATORS_FILENAME);
+  if (!existsSync(mutatorsPath)) {
+    return [];
+  }
+  const source = project.getSourceFile(mutatorsPath) ?? project.addSourceFileAtPath(mutatorsPath);
+  return mutatorWritesFromSource(source);
+};
+
 const discoverPackageDependencies = (projectRoot) => {
   const manifestPath = join(projectRoot, "package.json");
   if (!existsSync(manifestPath)) {
@@ -364,26 +440,45 @@ const protectPublicFlags = (call) => {
   }
   return { usesCaptcha: Boolean(argument.getProperty("captcha")), usesRateLimit: Boolean(argument.getProperty("rateLimit")) };
 };
+const resolveUseArgumentCall = (argument) => {
+  if (Node.isCallExpression(argument)) {
+    return argument;
+  }
+  if (!Node.isIdentifier(argument)) {
+    return void 0;
+  }
+  const declaration = argument.getSourceFile().getVariableDeclaration(argument.getText());
+  const initializer = declaration?.getInitializer();
+  return initializer && Node.isCallExpression(initializer) ? initializer : void 0;
+};
+const NO_PROTECTIONS = { usesCaptcha: false, usesMask: false, usesRateLimit: false, usesRls: false };
+const useStepProtections = (useArgument) => {
+  const argument = resolveUseArgumentCall(useArgument);
+  const name = argument ? calleeNameOf(argument) : void 0;
+  if (argument && name === "protectPublic") {
+    const bundle = protectPublicFlags(argument);
+    return { ...NO_PROTECTIONS, usesCaptcha: bundle.usesCaptcha, usesRateLimit: bundle.usesRateLimit };
+  }
+  if (name !== void 0 && name in MIDDLEWARE_FLAGS) {
+    return { ...NO_PROTECTIONS, [MIDDLEWARE_FLAGS[name]]: true };
+  }
+  return NO_PROTECTIONS;
+};
 const protectionsInChain = (receiver) => {
-  const protections = { usesCaptcha: false, usesMask: false, usesRateLimit: false, usesRls: false };
+  const protections = { ...NO_PROTECTIONS };
   let node = receiver;
   while (Node.isCallExpression(node)) {
     const chainCallee = node.getExpression();
     if (!Node.isPropertyAccessExpression(chainCallee)) {
       break;
     }
-    if (chainCallee.getName() === "use") {
-      const argument = node.getArguments()[0];
-      if (argument && Node.isCallExpression(argument)) {
-        const name = calleeNameOf(argument);
-        if (name === "protectPublic") {
-          const bundle = protectPublicFlags(argument);
-          protections.usesRateLimit ||= bundle.usesRateLimit;
-          protections.usesCaptcha ||= bundle.usesCaptcha;
-        } else if (name !== void 0 && name in MIDDLEWARE_FLAGS) {
-          protections[MIDDLEWARE_FLAGS[name]] = true;
-        }
-      }
+    const useArgument = chainCallee.getName() === "use" ? node.getArguments()[0] : void 0;
+    if (useArgument) {
+      const step = useStepProtections(useArgument);
+      protections.usesCaptcha ||= step.usesCaptcha;
+      protections.usesMask ||= step.usesMask;
+      protections.usesRateLimit ||= step.usesRateLimit;
+      protections.usesRls ||= step.usesRls;
     }
     node = chainCallee.getExpression();
   }
@@ -654,6 +749,10 @@ const readProjectVersion = (projectRoot) => {
     return void 0;
   }
 };
+const isTimingEnabled = () => {
+  const flag = process.env["LUNORA_CODEGEN_TIMING"];
+  return flag !== void 0 && flag !== "";
+};
 const findTsconfig = (startPath) => {
   let directory = existsSync(startPath) ? startPath : dirname(startPath);
   while (directory && directory !== dirname(directory)) {
@@ -695,17 +794,22 @@ const refreshCodegenProject = (project, lunoraDirectory) => {
   }
 };
 const runCodegen = (options) => {
+  const timingEnabled = isTimingEnabled();
+  const startedAt = timingEnabled ? performance.now() : 0;
   const lunoraDirectory = join(options.projectRoot, options.lunoraDirectory ?? "lunora");
   const schemaPath = join(lunoraDirectory, "schema.ts");
   if (!existsSync(schemaPath)) {
     throw new Error(`schema.ts not found at ${schemaPath}`);
   }
   const project = options.project ?? createCodegenProject(lunoraDirectory);
-  const schema = discoverSchema(project, schemaPath);
+  const schema = discoverSchema(project, schemaPath, options.projectRoot);
   const functions = discoverFunctions(project, lunoraDirectory);
   const httpRoutes = discoverHttpRoutes(project, lunoraDirectory);
   const migrations = discoverMigrations(project, lunoraDirectory);
+  const shapes = discoverShapes(project, lunoraDirectory);
+  const mutators = discoverMutators(project, lunoraDirectory);
   const workflows = discoverWorkflows(project, lunoraDirectory);
+  const queues = discoverQueues(project, lunoraDirectory);
   const crons = discoverCrons(project, lunoraDirectory, workflows);
   const containers = discoverContainers(project, lunoraDirectory);
   const advisories = options.lint === false ? [] : lintSchema(
@@ -723,7 +827,10 @@ const runCodegen = (options) => {
     discoverArgumentValidators(project, lunoraDirectory),
     discoverSecrets(project, lunoraDirectory),
     discoverSqlInterpolation(project, lunoraDirectory),
-    discoverAdminRoutes(project, lunoraDirectory)
+    discoverAdminRoutes(project, lunoraDirectory),
+    discoverR2sqlCalls(project, lunoraDirectory),
+    shapes,
+    discoverMutatorWrites(project, lunoraDirectory)
   );
   const rlsMetadata = discoverRlsMetadata(project, lunoraDirectory);
   const maskMetadata = discoverMaskMetadata(project, lunoraDirectory);
@@ -732,59 +839,79 @@ const runCodegen = (options) => {
   const hasAi = featureUsage.ai;
   const hasPayments = featureUsage.payments;
   const hasKv = featureUsage.kv;
+  const hasAccessFacade = featureUsage.access;
+  const hasFlags = existsSync(join(lunoraDirectory, "flags.ts"));
+  const flagKeys = hasFlags ? discoverFlagKeys(project, lunoraDirectory) : [];
   const hasHyperdrive = featureUsage.hyperdrive;
   const hasBrowser = featureUsage.browser;
   const hasImages = featureUsage.images;
   const hasAnalytics = featureUsage.analytics;
   const hasPipelines = featureUsage.pipelines;
+  const hasR2sql = featureUsage.r2sql;
   const dependencies = discoverPackageDependencies(options.projectRoot);
   const studioFeatures = buildStudioFeatures(featureUsage, {
     cronCount: crons.length,
     dependencies,
+    queueCount: queues.length,
     storageColumnCount: Object.keys(buildStorageColumns(schema)).length,
     storageRuleCount: storageRulesMetadata.rules.length,
     vectorIndexCount: schema.vectorIndexes.length,
     workflowCount: workflows.length
   });
   const useUmbrella = dependencies.has("lunorash");
+  const emitStartedAt = timingEnabled ? performance.now() : 0;
   const dataModelContent = emitDataModel(schema, useUmbrella);
   const apiContent = emitApi(functions, workflows, useUmbrella);
   const serverContent = emitServer({
     containers,
+    hasAccessFacade,
     hasAi,
     hasAnalytics,
     hasBrowser,
+    hasFlags,
     hasHyperdrive,
     hasImages,
     hasKv,
     hasPayments,
     hasPipelines,
+    hasR2sql,
+    queues,
     schema,
     storageRuleBuckets: storageRulesMetadata.rules.map((rule) => rule.bucket),
     useUmbrella,
     workflows
   });
-  const functionsContent = emitFunctions(functions, migrations);
+  const functionsContent = emitFunctions(functions, migrations, useUmbrella, mutators, shapes);
   const shardContent = emitShard({
     advisories,
     containers,
+    flagKeys,
+    hasAccessFacade,
     hasAi,
     hasAnalytics,
     hasBrowser,
+    hasFlags,
     hasHyperdrive,
     hasImages,
     hasKv,
     hasPayments,
+    hasPipelines,
+    hasR2sql,
     maskMetadata,
+    mutators,
+    queues,
     rlsMetadata,
     schema,
+    shapes,
     storageRules: storageRulesMetadata,
     studioFeatures,
     useUmbrella,
     workflows
   });
-  const containersContent = emitContainers(containers);
+  const collectionsContent = emitCollections(shapes, dependencies.has("@lunora/db"), useUmbrella);
+  const containersContent = emitContainers(containers, schema.jurisdiction);
   const workflowsContent = emitWorkflows(workflows);
+  const queuesContent = emitQueues(queues);
   const cronsContent = emitCrons(crons);
   const vectorsContent = emitVectors(schema.vectorIndexes);
   const drizzleFiles = emitDrizzleSchema(schema, useUmbrella);
@@ -793,6 +920,7 @@ const runCodegen = (options) => {
   const wantsOpenApi = apiSpec === "openapi" || apiSpec === "both";
   const wantsOpenRpc = apiSpec === "openrpc" || apiSpec === "both";
   const appContent = emitApp({
+    hasAccess: dependencies.has("@lunora/cloudflare-access"),
     hasAi,
     hasAnalytics,
     hasAuth: dependencies.has("@lunora/auth"),
@@ -809,10 +937,14 @@ const runCodegen = (options) => {
     hasImages,
     hasKv,
     hasPayments,
+    hasR2sql,
+    hasQueue: queues.some((queue) => queue.mode === "push"),
     hasScheduler: studioFeatures.scheduler,
     hasStorage: studioFeatures.storage,
     hasVectors: schema.vectorIndexes.length > 0,
     hasWorkflow: workflows.length > 0,
+    // Schema `.jurisdiction("…")` → pin the generated worker's DOs to the region.
+    jurisdiction: schema.jurisdiction,
     useUmbrella,
     wantsOpenApi,
     wantsOpenRpc
@@ -849,7 +981,9 @@ const runCodegen = (options) => {
     writeIfChanged(join(outputDirectory, "drizzle.shard.ts"), drizzleFiles.shard);
     writeIfPresent(join(outputDirectory, "containers.ts"), containersContent);
     writeIfPresent(join(outputDirectory, "workflows.ts"), workflowsContent);
+    writeIfPresent(join(outputDirectory, "queues.ts"), queuesContent);
     writeIfPresent(join(outputDirectory, "seed.ts"), seedContent);
+    writeIfPresent(join(outputDirectory, "collections.ts"), collectionsContent);
     if (wantsOpenApi) {
       writeIfChanged(join(outputDirectory, "openapi.json"), openApiContent);
       writeIfChanged(join(outputDirectory, "openapi.ts"), openApiModuleContent);
@@ -862,6 +996,13 @@ const runCodegen = (options) => {
       writeIfChanged(schemaSnapshotPath, serializeSchemaSnapshot(schemaSnapshot));
     }
   }
+  if (timingEnabled) {
+    const finishedAt = performance.now();
+    const total = Math.round(finishedAt - startedAt);
+    const discovery = Math.round(emitStartedAt - startedAt);
+    const emit = Math.round(finishedAt - emitStartedAt);
+    console.error(`@lunora/codegen: codegen took ${total.toString()}ms (discovery ${discovery.toString()}ms, emit ${emit.toString()}ms)`);
+  }
   return {
     advisories,
     containers,
@@ -869,6 +1010,7 @@ const runCodegen = (options) => {
     generated: {
       api: apiContent,
       app: appContent,
+      collections: collectionsContent,
       containers: containersContent,
       crons: cronsContent,
       dataModel: dataModelContent,
@@ -879,6 +1021,7 @@ const runCodegen = (options) => {
       openApiModule: openApiModuleContent,
       openRpc: openRpcContent,
       openRpcModule: openRpcModuleContent,
+      queues: queuesContent,
       seed: seedContent,
       server: serverContent,
       shard: shardContent,
@@ -886,6 +1029,7 @@ const runCodegen = (options) => {
       workflows: workflowsContent
     },
     outputDirectory,
+    queues,
     schemaSnapshot,
     schemaSnapshotPath,
     workflows

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

@@ -39,6 +39,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
@@ -69,7 +70,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 +192,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-ChV7MqgE.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-DeblMkzO.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/{discoverWorkflows-DRDQdhfq.mjs → WORKFLOWS_FILENAME-CCisG0Vy.mjs}

@@ -2,9 +2,10 @@ import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { workflowDefaultName, workflowClassName, workflowBindingName } from '@lunora/workflow';
 import { SyntaxKind, Node } from 'ts-morph';
-import { diagnosticAt } from './CodegenDiagnosticError-54jWDxA9.mjs';
+import { diagnosticAt } from './CodegenDiagnosticError-DeblMkzO.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 +31,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 +78,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)) {

package/dist/packem_shared/{buildOpenApiDocument-yHVN66Xd.mjs → buildOpenApiDocument-Dx5QftUn.mjs}

@@ -1,4 +1,4 @@
-import { GENERATED_HEADER } from './emitApi-hRVC-kE7.mjs';
+import { GENERATED_HEADER } from './GENERATED_HEADER-CI272wRm.mjs';
 import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
 import { LUNORA_ERROR_CODES, objectSchema, argsObjectSchema, validatorIrToJsonSchema } from './LUNORA_ERROR_CODES-CySpQPD3.mjs';
 

package/dist/packem_shared/{discoverAuthApiCalls-C35R6z0T.mjs → discoverAuthApiCalls-CoirYbg6.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-BWMczzBx.mjs';
 
 const isAuthApiCall = (call) => {
   const callee = call.getExpression();