@supacloud/compiler 0.57.1 → 0.59.0

package/dist/index.js

@@ -381,6 +381,7 @@ var init_di_resolution = __esm(() => {
     "conflicting-injection-flags",
     "cross-module-scoped-dependency",
     "mixed-multi-provider-scopes",
+    "effect-contract-required",
     "dynamic-aspect-reference",
     "invalid-aspect-reference",
     "aspect-operation-mismatch"
@@ -1088,7 +1089,13 @@ function validateGraph(graph, options = false) {
       if (command.rpc && command.branches) {
         error("command-rpc-branches-conflict", `Command ${command.name} cannot declare both rpc and branches.`, module.file, module.line);
       }
+      if (command.branchesFallback !== undefined && command.branchesFallback !== "reject" && command.branchesFallback !== "command") {
+        error("command-branches-fallback-invalid", `Command ${command.name} has an invalid branches fallback.`, module.file, module.line);
+      }
       const branchAdapters = command.branches ?? [];
+      if (command.branchesFallback === "command" && branchAdapters.length === 0) {
+        error("command-branches-fallback-without-branches", `Command ${command.name} declares a fallback without branches.`, module.file, module.line);
+      }
       for (const branch of branchAdapters) {
         if (typeof options !== "object" || !Object.hasOwn(options.commandCapabilities?.rpc ?? {}, branch.rpc)) {
           error("command-rpc-unavailable", `Command ${command.name} requires configured RPC adapter '${branch.rpc}'.`, module.file, module.line);
@@ -1118,7 +1125,7 @@ function validateGraph(graph, options = false) {
             error("command-transaction-unsupported", `Command ${command.name} branch '${branch.when}' declares transaction, but transaction support is unavailable.`, module.file, module.line);
           }
         }
-        if (hostCaps.requirePersistentAdapters && (command.rpc !== undefined && (!rpcCaps?.boundary || rpcCaps.audit !== true || rpcCaps.idempotency !== true) || branchCaps.length > 0 && branchCaps.some(({ branch, capabilities }) => !capabilities?.boundary || capabilities.audit !== true || capabilities.idempotency !== true || capabilities.boundary === "database" && (capabilities.transaction !== true || branch.transaction !== "required")) || hostCaps.permission !== true || !command.permission || branchCaps.length === 0 && (!command.audit || command.idempotency !== "required") || branchCaps.length > 0 && branchCaps.some(({ branch }) => !branch.audit || branch.idempotency !== "required") || branchCaps.length > 0 && branchCaps.some(({ capabilities }) => capabilities?.boundary === "external" && capabilities.reconcile !== true) || command.rpc !== undefined && rpcCaps?.boundary === "database" && (rpcCaps.transaction !== true || command.transaction !== "required") || command.rpc === undefined && branchCaps.length === 0 && (hostCaps.audit !== true || hostCaps.idempotency !== true || hostCaps.transaction !== true || command.transaction !== "required") || command.rpc !== undefined && rpcCaps?.boundary === "external" && rpcCaps.reconcile !== true)) {
+        if (hostCaps.requirePersistentAdapters && (command.rpc !== undefined && (!rpcCaps?.boundary || rpcCaps.audit !== true || rpcCaps.idempotency !== true) || branchCaps.length > 0 && branchCaps.some(({ branch, capabilities }) => !capabilities?.boundary || capabilities.audit !== true || capabilities.idempotency !== true || capabilities.boundary === "database" && (capabilities.transaction !== true || branch.transaction !== "required")) || hostCaps.permission !== true || !command.permission || branchCaps.length === 0 && (!command.audit || command.idempotency !== "required") || branchCaps.length > 0 && branchCaps.some(({ branch }) => !branch.audit || branch.idempotency !== "required") || branchCaps.length > 0 && branchCaps.some(({ capabilities }) => capabilities?.boundary === "external" && capabilities.reconcile !== true) || command.branchesFallback === "command" && (!command.audit || command.idempotency !== "required" || command.transaction !== "required" || hostCaps.audit !== true || hostCaps.idempotency !== true || hostCaps.transaction !== true) || command.rpc !== undefined && rpcCaps?.boundary === "database" && (rpcCaps.transaction !== true || command.transaction !== "required") || command.rpc === undefined && branchCaps.length === 0 && (hostCaps.audit !== true || hostCaps.idempotency !== true || hostCaps.transaction !== true || command.transaction !== "required") || command.rpc !== undefined && rpcCaps?.boundary === "external" && rpcCaps.reconcile !== true)) {
           error("command-persistence-required", `Command ${command.name} requires an explicit persistent adapter, permission, audit and idempotency policy.`, module.file, module.line, "Register a named database/external adapter, enable permission checks and declare permission, audit and required idempotency on the command.");
         }
         if (rpcCaps?.boundary === "external" && (command.transaction === "required" || rpcCaps.transaction === true)) {
@@ -1671,6 +1678,7 @@ function buildContractManifest(graph, artifacts) {
         module: module.name,
         ...command.permission === undefined ? {} : { permission: command.permission },
         ...command.rpc === undefined ? {} : { rpc: command.rpc },
+        ...command.branchesFallback === undefined ? {} : { branchesFallback: command.branchesFallback },
         ...command.branches === undefined ? {} : {
           branches: command.branches.map((branch) => ({
             when: branch.when,
@@ -2402,6 +2410,7 @@ function renderApplication(graph, options) {
     permission: command.permission ?? null,
     rpc: command.rpc ?? null,
     branches: command.branches ?? [],
+    branchesFallback: command.branchesFallback ?? "reject",
     transaction: command.transaction ?? null,
     audit: command.audit ?? null,
     idempotency: command.idempotency ?? null
@@ -2452,6 +2461,7 @@ function renderApplication(graph, options) {
           executor: route.command === undefined ? "route" : "command",
           ...command === undefined ? {} : { commandBoundary: route.command === undefined ? "handler" : "route" },
           ...route.effect === undefined ? {} : { effect: route.effect },
+          ...route.effectMode === undefined ? {} : { effectMode: route.effectMode },
           invoker: isPipeline ? "pipeline" : "direct",
           stages: operationPlans.find((plan) => plan.module === module.name && plan.kind === "route" && plan.name === `${route.method} ${joinRoutePaths(controller.path, route.path)}`).stages,
           ...commandRef === undefined ? {} : { command: command?.name ?? commandRef },
@@ -2479,6 +2489,7 @@ function renderApplication(graph, options) {
         transaction: command.transaction,
         idempotency: command.idempotency,
         branches: command.branches ?? [],
+        branchesFallback: command.branchesFallback ?? "reject",
         ...command.tenantScope === undefined ? {} : { tenantScope: command.tenantScope },
         requiredCapabilities: {
           permission: true,
@@ -2831,6 +2842,8 @@ class ModuleGenerator {
         if (route.effect !== undefined) {
           fields.push(`effect: ${JSON.stringify(route.effect)}`);
         }
+        if (route.effectMode !== undefined)
+          fields.push(`effectMode: ${JSON.stringify(route.effectMode)}`);
         if (idempotency !== undefined) {
           fields.push(`idempotency: ${JSON.stringify(idempotency)}`);
         }
@@ -2969,6 +2982,7 @@ ${indent(item, 2)}`).join(",")}
         `idempotency: ${JSON.stringify(command.idempotency)}`,
         ...command.tenantScope ? [`tenantScope: ${JSON.stringify(command.tenantScope)}`] : [],
         ...command.rpc ? [`rpc: ${JSON.stringify(command.rpc)}`] : [],
+        ...command.branchesFallback ? [`branchesFallback: ${JSON.stringify(command.branchesFallback)}`] : [],
         ...command.branches && command.branches.length > 0 ? [`branches: ${JSON.stringify(command.branches)}`] : [],
         ...command.standalone ? ["standalone: true"] : [],
         ...command.aspects && command.aspects.length > 0 ? [`aspects: ${this.renderAspects(command.aspects)}`, `aspectPipeline: ${this.renderAspectPipeline(command.aspects)}`] : []
@@ -4680,6 +4694,8 @@ var HEADER = "// GENERATED BY @supacloud/compiler — do not edit", INTERFACES =
     maxAttempts?: number;
     timeoutMs?: number;
   };
+  /** Simple route profile; no Effect interpreter or error mapping is required. */
+  effectMode?: "simple";
   /** Compile-time ownership and transport classification for the route boundary. */
   contract?: {
     body?: "framework" | "domain";
@@ -4726,6 +4742,7 @@ var HEADER = "// GENERATED BY @supacloud/compiler — do not edit", INTERFACES =
 export interface CompiledCommand {
   rpc?: string;
   branches?: readonly CompiledCommandBranch[];
+  branchesFallback?: "reject" | "command";
   className: string;
   name: string;
   permission: string;
@@ -4858,7 +4875,7 @@ async function compiledAspectStep(context: CompiledAspectContext, handler: () =>
     }
     called = true;
     pending = Promise.resolve().then(handler).then(result => {
-      if (strict) freezeCompiledAspectData(result);
+      if (strict && !(result instanceof Response)) freezeCompiledAspectData(result);
       value = result;
       return result;
     });
@@ -15624,23 +15641,49 @@ var init_value2 = __esm(() => {
 });
 
 // node_modules/@supacloud/delivery/src/worker-execution.ts
+function workerShardCount(group) {
+  return group.shardCount ?? 1;
+}
+function shardSuffix(shard) {
+  if (!Number.isSafeInteger(shard) || shard < 0 || shard >= 64) {
+    throw new Error("WORKER_SHARD_INVALID");
+  }
+  return `s${shard.toString(36).padStart(2, "0")}`;
+}
+function workerShardQueue(group, shard) {
+  const count = workerShardCount(group);
+  if (!Number.isSafeInteger(shard) || shard < 0 || shard >= count) {
+    throw new Error("WORKER_SHARD_INVALID");
+  }
+  if (count === 1)
+    return group.queue;
+  const queue = `${group.queue}_${shardSuffix(shard)}`;
+  if (!/^scw_[a-z0-9_]{1,40}$/.test(queue))
+    throw new Error("WORKER_QUEUE_INVALID");
+  return queue;
+}
 function parseWorkerExecutionGroup(value) {
   if (!Check2(WorkerExecutionGroupSchema, value) || value.replicas > value.maxReplicas || !value.queue.endsWith(`_v${value.definitionVersion}`) || value.lifecycle.visibilityTimeoutSeconds < value.lifecycle.executionTimeoutSeconds + value.lifecycle.shutdownGraceSeconds + 30) {
     throw new Error("WORKER_EXECUTION_INVALID");
   }
-  return structuredClone(value);
+  const group = structuredClone(value);
+  for (let shard = 0;shard < workerShardCount(group); shard += 1)
+    workerShardQueue(group, shard);
+  return group;
 }
 function validateWorkerExecution(groups) {
   const names = new Set, targets = new Set, queues = new Set, routes = new Set;
   for (const candidate of groups) {
     const group = parseWorkerExecutionGroup(candidate);
     const route = `${group.taskKey}:${group.definitionVersion}`;
-    if (names.has(group.name) || targets.has(group.target) || queues.has(group.queue) || routes.has(route)) {
+    const physicalQueues = Array.from({ length: workerShardCount(group) }, (_, shard) => workerShardQueue(group, shard));
+    if (names.has(group.name) || targets.has(group.target) || queues.has(group.queue) || physicalQueues.some((queue) => queues.has(queue)) || routes.has(route)) {
       throw new Error("WORKER_EXECUTION_CONFLICT");
     }
     names.add(group.name);
     targets.add(group.target);
     queues.add(group.queue);
+    physicalQueues.forEach((queue) => queues.add(queue));
     routes.add(route);
   }
 }
@@ -15664,6 +15707,7 @@ var init_worker_execution = __esm(() => {
     definitionVersion: String2({ pattern: "^[1-9][0-9]{0,8}$" }),
     replicas: positive(16),
     maxReplicas: positive(16),
+    shardCount: Optional(positive(64)),
     concurrencyPerReplica: positive(32),
     resources: ComputeResourcesSchema,
     database: _Object_({
@@ -16073,7 +16117,7 @@ function parseDeliveryBuildManifest(value) {
   if (!Check2(DeliveryBuildManifestSchema, value))
     throw new Error("Invalid delivery build manifest.");
   validateWorkerExecution(value.plan.targets.flatMap((target) => target.execution ? [target.execution] : []));
-  if (value.plan.targets.reduce((count, target) => count + (target.execution?.replicas ?? 1), 0) > 32) {
+  if (value.plan.targets.reduce((count, target) => count + (target.execution ? (target.execution.replicas ?? 1) * workerShardCount(target.execution) : 1), 0) > 256) {
     throw new Error("Invalid delivery replica count.");
   }
   for (const target of value.plan.targets) {
@@ -19832,6 +19876,7 @@ async function analyzeProject(rootDir, include, cache, changedPaths, effectOptio
             const permission = stringLiteralProp(meta, "permission");
             const rpc = checkedRpc(meta, ctx);
             const branches = checkedBranches(meta, ctx);
+            const branchesFallback = checkedBranchesFallback(meta, ctx);
             const audit = stringLiteralProp(meta, "audit");
             const standaloneName = stringLiteralProp(meta, "name") ?? classInfo.decl.name?.text ?? name;
             const standaloneUses = await parseInfraResourceUseRefs(infraResourceProp(meta, "uses", ctx), ctx, `command ${standaloneName}`, sourcePath(ctx.rootDir, classInfo.file), lineOf(classInfo.decl));
@@ -19842,6 +19887,7 @@ async function analyzeProject(rootDir, include, cache, changedPaths, effectOptio
               ...permission === undefined ? {} : { permission },
               ...rpc === undefined ? {} : { rpc },
               ...branches === undefined ? {} : { branches },
+              ...branchesFallback === undefined ? {} : { branchesFallback },
               transaction: checkedCommandMode(meta, "transaction", ctx, classInfo.decl.name?.text ?? name) ?? "none",
               ...audit === undefined ? {} : { audit },
               idempotency: checkedCommandMode(meta, "idempotency", ctx, classInfo.decl.name?.text ?? name) ?? "none",
@@ -20216,6 +20262,7 @@ async function parseModule(candidate, nameByNode, ctx) {
         const permission = stringLiteralProp(meta, "permission");
         const rpc = checkedRpc(meta, ctx);
         const branches = checkedBranches(meta, ctx);
+        const branchesFallback = checkedBranchesFallback(meta, ctx);
         const audit = stringLiteralProp(meta, "audit");
         const commandName = stringLiteralProp(meta, "name") ?? cls.name?.text ?? "<anonymous>";
         const uses = await parseInfraResourceUseRefs(infraResourceProp(meta, "uses", ctx), ctx, `command ${commandName}`, sourcePath(ctx.rootDir, cls.getSourceFile().fileName), lineOf(cls));
@@ -20227,6 +20274,7 @@ async function parseModule(candidate, nameByNode, ctx) {
           ...permission === undefined ? {} : { permission },
           ...rpc === undefined ? {} : { rpc },
           ...branches === undefined ? {} : { branches },
+          ...branchesFallback === undefined ? {} : { branchesFallback },
           transaction: checkedCommandMode(meta, "transaction", ctx, cls.name?.text ?? "<anonymous>") ?? "none",
           ...audit === undefined ? {} : { audit },
           idempotency: checkedCommandMode(meta, "idempotency", ctx, cls.name?.text ?? "<anonymous>") ?? "none",
@@ -21447,111 +21495,102 @@ async function parseController(input, ctx) {
         }
         const effectExpr = getProp(optionsObject, "effect");
         if (effectExpr) {
-          const effectObject = await resolveStaticObjectLiteral(effectExpr, ctx);
-          if (!effectObject) {
-            ctx.diagnostics.push({
-              severity: "error",
-              code: "invalid-effect-contract",
-              errorCode: "SC3030",
-              docsUrl: "https://supacloud.dev/errors/SC3030",
-              file,
-              line: lineOf(effectExpr),
-              message: `Route ${route.handler} effect must be a statically resolvable object literal.`,
-              suggestion: 'Use effect: { required: true, errors: [...], dependencies: [...], retry: "none" }.'
-            });
+          if (effectExpr.kind === ts8.SyntaxKind.FalseKeyword) {
+            route.effectMode = "simple";
           } else {
-            const effect = { required: true };
-            const requiredExpr = getProp(effectObject, "required");
-            if (requiredExpr !== undefined && booleanProp(effectObject, "required") !== true) {
+            const effectObject = await resolveStaticObjectLiteral(effectExpr, ctx);
+            if (!effectObject) {
               ctx.diagnostics.push({
                 severity: "error",
                 code: "invalid-effect-contract",
                 errorCode: "SC3030",
                 docsUrl: "https://supacloud.dev/errors/SC3030",
                 file,
-                line: lineOf(requiredExpr),
-                message: `Route ${route.handler} effect.required must be the literal true.`
+                line: lineOf(effectExpr),
+                message: `Route ${route.handler} effect must be a statically resolvable object literal.`,
+                suggestion: 'Use effect: { required: true, errors: [...], dependencies: [...], retry: "none" }.'
               });
-            }
-            const retry = stringLiteralProp(effectObject, "retry");
-            if (retry !== undefined) {
-              if (retry !== "none" && retry !== "explicit") {
+            } else {
+              const effect = { required: true };
+              const requiredExpr = getProp(effectObject, "required");
+              if (requiredExpr !== undefined && booleanProp(effectObject, "required") !== true) {
                 ctx.diagnostics.push({
                   severity: "error",
-                  code: "invalid-effect-retry",
-                  errorCode: "SC3031",
-                  docsUrl: "https://supacloud.dev/errors/SC3031",
+                  code: "invalid-effect-contract",
+                  errorCode: "SC3030",
+                  docsUrl: "https://supacloud.dev/errors/SC3030",
                   file,
-                  line: lineOf(getProp(effectObject, "retry")),
-                  message: `Route ${route.handler} effect.retry must be "none" or "explicit".`
+                  line: lineOf(requiredExpr),
+                  message: `Route ${route.handler} effect.required must be the literal true.`
                 });
-              } else {
-                effect.retry = retry;
               }
-            } else if (ctx.effectOptions.requireRetryPolicy === false) {
-              effect.retry = "none";
-            }
-            const maxAttemptsExpr = getProp(effectObject, "maxAttempts");
-            if (maxAttemptsExpr !== undefined) {
-              const maxAttempts = numberLiteralProp(effectObject, "maxAttempts");
-              if (maxAttempts === undefined || maxAttempts < 1 || !Number.isInteger(maxAttempts)) {
+              const retry = stringLiteralProp(effectObject, "retry");
+              if (retry !== undefined) {
+                if (retry !== "none" && retry !== "explicit") {
+                  ctx.diagnostics.push({
+                    severity: "error",
+                    code: "invalid-effect-retry",
+                    errorCode: "SC3031",
+                    docsUrl: "https://supacloud.dev/errors/SC3031",
+                    file,
+                    line: lineOf(getProp(effectObject, "retry")),
+                    message: `Route ${route.handler} effect.retry must be "none" or "explicit".`
+                  });
+                } else {
+                  effect.retry = retry;
+                }
+              } else if (ctx.effectOptions.requireRetryPolicy === false) {
+                effect.retry = "none";
+              }
+              const maxAttemptsExpr = getProp(effectObject, "maxAttempts");
+              if (maxAttemptsExpr !== undefined) {
+                const maxAttempts = numberLiteralProp(effectObject, "maxAttempts");
+                if (maxAttempts === undefined || maxAttempts < 1 || !Number.isInteger(maxAttempts)) {
+                  ctx.diagnostics.push({
+                    severity: "error",
+                    code: "invalid-effect-retry",
+                    errorCode: "SC3031",
+                    docsUrl: "https://supacloud.dev/errors/SC3031",
+                    file,
+                    line: lineOf(maxAttemptsExpr),
+                    message: `Route ${route.handler} effect.maxAttempts must be a positive integer.`
+                  });
+                } else {
+                  effect.maxAttempts = maxAttempts;
+                }
+              }
+              if (effect.retry === "explicit" && effect.maxAttempts === undefined) {
                 ctx.diagnostics.push({
                   severity: "error",
                   code: "invalid-effect-retry",
                   errorCode: "SC3031",
                   docsUrl: "https://supacloud.dev/errors/SC3031",
                   file,
-                  line: lineOf(maxAttemptsExpr),
-                  message: `Route ${route.handler} effect.maxAttempts must be a positive integer.`
+                  line: lineOf(effectExpr),
+                  message: `Route ${route.handler} effect.maxAttempts is required when retry is "explicit".`
                 });
-              } else {
-                effect.maxAttempts = maxAttempts;
               }
-            }
-            if (effect.retry === "explicit" && effect.maxAttempts === undefined) {
-              ctx.diagnostics.push({
-                severity: "error",
-                code: "invalid-effect-retry",
-                errorCode: "SC3031",
-                docsUrl: "https://supacloud.dev/errors/SC3031",
-                file,
-                line: lineOf(effectExpr),
-                message: `Route ${route.handler} effect.maxAttempts is required when retry is "explicit".`
-              });
-            }
-            const timeoutExpr = getProp(effectObject, "timeoutMs");
-            if (timeoutExpr !== undefined) {
-              const timeoutMs = numberLiteralProp(effectObject, "timeoutMs");
-              if (timeoutMs === undefined || timeoutMs <= 0 || !Number.isInteger(timeoutMs)) {
-                ctx.diagnostics.push({
-                  severity: "error",
-                  code: "invalid-effect-timeout",
-                  errorCode: "SC3032",
-                  docsUrl: "https://supacloud.dev/errors/SC3032",
-                  file,
-                  line: lineOf(timeoutExpr),
-                  message: `Route ${route.handler} effect.timeoutMs must be a positive integer.`
-                });
-              } else {
-                effect.timeoutMs = timeoutMs;
+              const timeoutExpr = getProp(effectObject, "timeoutMs");
+              if (timeoutExpr !== undefined) {
+                const timeoutMs = numberLiteralProp(effectObject, "timeoutMs");
+                if (timeoutMs === undefined || timeoutMs <= 0 || !Number.isInteger(timeoutMs)) {
+                  ctx.diagnostics.push({
+                    severity: "error",
+                    code: "invalid-effect-timeout",
+                    errorCode: "SC3032",
+                    docsUrl: "https://supacloud.dev/errors/SC3032",
+                    file,
+                    line: lineOf(timeoutExpr),
+                    message: `Route ${route.handler} effect.timeoutMs must be a positive integer.`
+                  });
+                } else {
+                  effect.timeoutMs = timeoutMs;
+                }
               }
-            }
-            const dependenciesExpr = getProp(effectObject, "dependencies");
-            if (dependenciesExpr !== undefined) {
-              const dependenciesArray = await resolveStaticArrayLiteral(dependenciesExpr, ctx);
-              if (!dependenciesArray || dependenciesArray.elements.some((element) => !ts8.isStringLiteral(element) || element.text.trim().length === 0)) {
-                ctx.diagnostics.push({
-                  severity: "error",
-                  code: "invalid-effect-dependencies",
-                  errorCode: "SC3033",
-                  docsUrl: "https://supacloud.dev/errors/SC3033",
-                  file,
-                  line: lineOf(dependenciesExpr),
-                  message: `Route ${route.handler} effect.dependencies must be a string array or a const initialized with one.`
-                });
-              } else {
-                effect.dependencies = dependenciesArray.elements.map((element) => element.text);
-                if (new Set(effect.dependencies).size !== effect.dependencies.length) {
+              const dependenciesExpr = getProp(effectObject, "dependencies");
+              if (dependenciesExpr !== undefined) {
+                const dependenciesArray = await resolveStaticArrayLiteral(dependenciesExpr, ctx);
+                if (!dependenciesArray || dependenciesArray.elements.some((element) => !ts8.isStringLiteral(element) || element.text.trim().length === 0)) {
                   ctx.diagnostics.push({
                     severity: "error",
                     code: "invalid-effect-dependencies",
@@ -21559,148 +21598,161 @@ async function parseController(input, ctx) {
                     docsUrl: "https://supacloud.dev/errors/SC3033",
                     file,
                     line: lineOf(dependenciesExpr),
-                    message: `Route ${route.handler} effect.dependencies must not contain duplicate service names.`,
-                    suggestion: "List each logical Effect dependency exactly once."
+                    message: `Route ${route.handler} effect.dependencies must be a string array or a const initialized with one.`
                   });
-                }
-              }
-            }
-            const errorsExpr = getProp(effectObject, "errors");
-            if (errorsExpr !== undefined) {
-              const errorsArray = await resolveStaticArrayLiteral(errorsExpr, ctx);
-              if (!errorsArray) {
-                ctx.diagnostics.push({
-                  severity: "error",
-                  code: "invalid-effect-errors",
-                  errorCode: "SC3034",
-                  docsUrl: "https://supacloud.dev/errors/SC3034",
-                  file,
-                  line: lineOf(errorsExpr),
-                  message: `Route ${route.handler} effect.errors must be an object array or a const initialized with one.`
-                });
-              } else {
-                const errors = [];
-                for (const errorExpr of errorsArray.elements) {
-                  if (!ts8.isObjectLiteralExpression(errorExpr)) {
+                } else {
+                  effect.dependencies = dependenciesArray.elements.map((element) => element.text);
+                  if (new Set(effect.dependencies).size !== effect.dependencies.length) {
                     ctx.diagnostics.push({
                       severity: "error",
-                      code: "invalid-effect-errors",
-                      errorCode: "SC3034",
-                      docsUrl: "https://supacloud.dev/errors/SC3034",
+                      code: "invalid-effect-dependencies",
+                      errorCode: "SC3033",
+                      docsUrl: "https://supacloud.dev/errors/SC3033",
                       file,
-                      line: lineOf(errorExpr),
-                      message: `Route ${route.handler} effect.errors entries must be object literals.`
+                      line: lineOf(dependenciesExpr),
+                      message: `Route ${route.handler} effect.dependencies must not contain duplicate service names.`,
+                      suggestion: "List each logical Effect dependency exactly once."
                     });
-                    continue;
                   }
-                  const tag = stringLiteralProp(errorExpr, "tag");
-                  const code = stringLiteralProp(errorExpr, "code");
-                  const status = numberLiteralProp(errorExpr, "status");
-                  const message = stringLiteralProp(errorExpr, "message");
-                  const codeFromError = booleanLiteralProp(errorExpr, "codeFromError");
-                  const messageFromError = booleanLiteralProp(errorExpr, "messageFromError");
-                  const statusFromError = booleanLiteralProp(errorExpr, "statusFromError");
-                  const retryable = booleanLiteralProp(errorExpr, "retryable");
-                  const outcomeUnknown = booleanLiteralProp(errorExpr, "outcomeUnknown");
-                  if (invalidBooleanProp(errorExpr, "codeFromError") || invalidBooleanProp(errorExpr, "messageFromError") || invalidBooleanProp(errorExpr, "statusFromError") || invalidBooleanProp(errorExpr, "retryable") || invalidBooleanProp(errorExpr, "outcomeUnknown")) {
-                    ctx.diagnostics.push({
-                      severity: "error",
-                      code: "invalid-effect-errors",
-                      errorCode: "SC3034",
-                      docsUrl: "https://supacloud.dev/errors/SC3034",
-                      file,
-                      line: lineOf(errorExpr),
-                      message: `Route ${route.handler} effect.errors instance flags must be boolean literals.`
+                }
+              }
+              const errorsExpr = getProp(effectObject, "errors");
+              if (errorsExpr !== undefined) {
+                const errorsArray = await resolveStaticArrayLiteral(errorsExpr, ctx);
+                if (!errorsArray) {
+                  ctx.diagnostics.push({
+                    severity: "error",
+                    code: "invalid-effect-errors",
+                    errorCode: "SC3034",
+                    docsUrl: "https://supacloud.dev/errors/SC3034",
+                    file,
+                    line: lineOf(errorsExpr),
+                    message: `Route ${route.handler} effect.errors must be an object array or a const initialized with one.`
+                  });
+                } else {
+                  const errors = [];
+                  for (const errorExpr of errorsArray.elements) {
+                    if (!ts8.isObjectLiteralExpression(errorExpr)) {
+                      ctx.diagnostics.push({
+                        severity: "error",
+                        code: "invalid-effect-errors",
+                        errorCode: "SC3034",
+                        docsUrl: "https://supacloud.dev/errors/SC3034",
+                        file,
+                        line: lineOf(errorExpr),
+                        message: `Route ${route.handler} effect.errors entries must be object literals.`
+                      });
+                      continue;
+                    }
+                    const tag = stringLiteralProp(errorExpr, "tag");
+                    const code = stringLiteralProp(errorExpr, "code");
+                    const status = numberLiteralProp(errorExpr, "status");
+                    const message = stringLiteralProp(errorExpr, "message");
+                    const codeFromError = booleanLiteralProp(errorExpr, "codeFromError");
+                    const messageFromError = booleanLiteralProp(errorExpr, "messageFromError");
+                    const statusFromError = booleanLiteralProp(errorExpr, "statusFromError");
+                    const retryable = booleanLiteralProp(errorExpr, "retryable");
+                    const outcomeUnknown = booleanLiteralProp(errorExpr, "outcomeUnknown");
+                    if (invalidBooleanProp(errorExpr, "codeFromError") || invalidBooleanProp(errorExpr, "messageFromError") || invalidBooleanProp(errorExpr, "statusFromError") || invalidBooleanProp(errorExpr, "retryable") || invalidBooleanProp(errorExpr, "outcomeUnknown")) {
+                      ctx.diagnostics.push({
+                        severity: "error",
+                        code: "invalid-effect-errors",
+                        errorCode: "SC3034",
+                        docsUrl: "https://supacloud.dev/errors/SC3034",
+                        file,
+                        line: lineOf(errorExpr),
+                        message: `Route ${route.handler} effect.errors instance flags must be boolean literals.`
+                      });
+                      continue;
+                    }
+                    if (!tag || !code || status === undefined || !Number.isInteger(status) || status < 400 || status > 599) {
+                      ctx.diagnostics.push({
+                        severity: "error",
+                        code: "invalid-effect-errors",
+                        errorCode: "SC3034",
+                        docsUrl: "https://supacloud.dev/errors/SC3034",
+                        file,
+                        line: lineOf(errorExpr),
+                        message: `Route ${route.handler} effect.errors entries require tag, code and an HTTP status from 400 to 599.`
+                      });
+                      continue;
+                    }
+                    errors.push({
+                      tag,
+                      code,
+                      status,
+                      ...message === undefined ? {} : { message },
+                      ...codeFromError === undefined ? {} : { codeFromError },
+                      ...messageFromError === undefined ? {} : { messageFromError },
+                      ...statusFromError === undefined ? {} : { statusFromError },
+                      ...retryable === undefined ? {} : { retryable },
+                      ...outcomeUnknown === undefined ? {} : { outcomeUnknown }
                     });
-                    continue;
                   }
-                  if (!tag || !code || status === undefined || !Number.isInteger(status) || status < 400 || status > 599) {
+                  effect.errors = errors;
+                  if (new Set(errors.map((entry) => entry.tag)).size !== errors.length) {
                     ctx.diagnostics.push({
                       severity: "error",
                       code: "invalid-effect-errors",
                       errorCode: "SC3034",
                       docsUrl: "https://supacloud.dev/errors/SC3034",
                       file,
-                      line: lineOf(errorExpr),
-                      message: `Route ${route.handler} effect.errors entries require tag, code and an HTTP status from 400 to 599.`
+                      line: lineOf(errorsExpr),
+                      message: `Route ${route.handler} effect.errors must not contain duplicate tags.`,
+                      suggestion: "Map each tagged failure exactly once."
                     });
-                    continue;
                   }
-                  errors.push({
-                    tag,
-                    code,
-                    status,
-                    ...message === undefined ? {} : { message },
-                    ...codeFromError === undefined ? {} : { codeFromError },
-                    ...messageFromError === undefined ? {} : { messageFromError },
-                    ...statusFromError === undefined ? {} : { statusFromError },
-                    ...retryable === undefined ? {} : { retryable },
-                    ...outcomeUnknown === undefined ? {} : { outcomeUnknown }
-                  });
-                }
-                effect.errors = errors;
-                if (new Set(errors.map((entry) => entry.tag)).size !== errors.length) {
-                  ctx.diagnostics.push({
-                    severity: "error",
-                    code: "invalid-effect-errors",
-                    errorCode: "SC3034",
-                    docsUrl: "https://supacloud.dev/errors/SC3034",
-                    file,
-                    line: lineOf(errorsExpr),
-                    message: `Route ${route.handler} effect.errors must not contain duplicate tags.`,
-                    suggestion: "Map each tagged failure exactly once."
-                  });
                 }
               }
-            }
-            route.effect = effect;
-            const effectArguments = await effectTypeArgumentsOf(returnType, ctx);
-            const promiseReturn = Boolean(resultType && /\bPromise(?:<|\s)/.test(resultType));
-            if (promiseReturn) {
-              pushEffectDiagnostic(ctx, "effect-promise-return", file, lineOf(method), `Route ${route.handler} returns Promise instead of an Effect program.`, "Return Effect.Effect<Success, Failure, Requirements>; the Elysia boundary owns Promise interpretation.");
-            } else if (!effectArguments) {
-              ctx.diagnostics.push({
-                severity: "error",
-                code: "effect-return-type",
-                errorCode: "SC3035",
-                docsUrl: "https://supacloud.dev/errors/SC3035",
-                file,
-                line: lineOf(method),
-                message: `Route ${route.handler} declares an Effect contract but returns ${resultType ?? "an unresolved type"}.`,
-                suggestion: "Return Effect.Effect<Success, Failure, Requirements> from the handler."
-              });
-            }
-            if (effectArguments) {
-              const [, failureType, environmentType] = effectArguments;
-              const failure = await effectFailureTags(failureType, method, ctx);
-              if (ctx.effectOptions.requireTaggedErrorTypes && failure.invalid) {
-                pushEffectDiagnostic(ctx, "effect-error-type", file, lineOf(method), `Route ${route.handler} must use never or a tagged failure union in Effect's error channel, not ${await effectTypeName(failureType, method, ctx)}.`, "Replace unknown/any with never or a union of objects carrying a literal _tag.");
-              } else if (ctx.effectOptions.requireTaggedErrorTypes && effect.errors !== undefined && !failure.invalid) {
-                const declaredTags = sortedUnique(effect.errors.map((entry) => entry.tag));
-                const typedTags = sortedUnique(failure.tags);
-                if (declaredTags.join("\x00") !== typedTags.join("\x00")) {
-                  pushEffectDiagnostic(ctx, "effect-error-mapping-type", file, lineOf(method), `Route ${route.handler} maps [${declaredTags.join(", ")}], but its Effect failure type declares [${typedTags.join(", ")}].`, "Make effect.errors and the Effect error type the same tagged union; do not hide unmapped failures.");
-                }
+              route.effect = effect;
+              const effectArguments = await effectTypeArgumentsOf(returnType, ctx);
+              const promiseReturn = Boolean(resultType && /\bPromise(?:<|\s)/.test(resultType));
+              if (promiseReturn) {
+                pushEffectDiagnostic(ctx, "effect-promise-return", file, lineOf(method), `Route ${route.handler} returns Promise instead of an Effect program.`, "Return Effect.Effect<Success, Failure, Requirements>; the Elysia boundary owns Promise interpretation.");
+              } else if (!effectArguments) {
+                ctx.diagnostics.push({
+                  severity: "error",
+                  code: "effect-return-type",
+                  errorCode: "SC3035",
+                  docsUrl: "https://supacloud.dev/errors/SC3035",
+                  file,
+                  line: lineOf(method),
+                  message: `Route ${route.handler} declares an Effect contract but returns ${resultType ?? "an unresolved type"}.`,
+                  suggestion: "Return Effect.Effect<Success, Failure, Requirements> from the handler."
+                });
               }
-              const environment = await effectEnvironmentNames(environmentType, method, ctx);
-              if (ctx.effectOptions.requireExactDependencyTypes && effect.dependencies !== undefined) {
-                if (environment.invalid) {
-                  pushEffectDiagnostic(ctx, "effect-dependency-mismatch", file, lineOf(method), `Route ${route.handler} uses an Effect environment that cannot be represented by its explicit dependency list.`, "Use named service types or never in the third Effect type parameter.");
-                } else {
-                  const declaredDependencies = sortedUnique(effect.dependencies);
-                  const typedDependencies = sortedUnique(environment.names);
-                  if (declaredDependencies.join("\x00") !== typedDependencies.join("\x00")) {
-                    pushEffectDiagnostic(ctx, "effect-dependency-mismatch", file, lineOf(method), `Route ${route.handler} declares dependencies [${declaredDependencies.join(", ")}], but its Effect environment is [${typedDependencies.join(", ")}].`, "Make effect.dependencies exactly match the third Effect type parameter.");
+              if (effectArguments) {
+                const [, failureType, environmentType] = effectArguments;
+                const failure = await effectFailureTags(failureType, method, ctx);
+                if (ctx.effectOptions.requireTaggedErrorTypes && failure.invalid) {
+                  pushEffectDiagnostic(ctx, "effect-error-type", file, lineOf(method), `Route ${route.handler} must use never or a tagged failure union in Effect's error channel, not ${await effectTypeName(failureType, method, ctx)}.`, "Replace unknown/any with never or a union of objects carrying a literal _tag.");
+                } else if (ctx.effectOptions.requireTaggedErrorTypes && effect.errors !== undefined && !failure.invalid) {
+                  const declaredTags = sortedUnique(effect.errors.map((entry) => entry.tag));
+                  const typedTags = sortedUnique(failure.tags);
+                  if (declaredTags.join("\x00") !== typedTags.join("\x00")) {
+                    pushEffectDiagnostic(ctx, "effect-error-mapping-type", file, lineOf(method), `Route ${route.handler} maps [${declaredTags.join(", ")}], but its Effect failure type declares [${typedTags.join(", ")}].`, "Make effect.errors and the Effect error type the same tagged union; do not hide unmapped failures.");
                   }
                 }
+                const environment = await effectEnvironmentNames(environmentType, method, ctx);
+                if (ctx.effectOptions.requireExactDependencyTypes && effect.dependencies !== undefined) {
+                  if (environment.invalid) {
+                    pushEffectDiagnostic(ctx, "effect-dependency-mismatch", file, lineOf(method), `Route ${route.handler} uses an Effect environment that cannot be represented by its explicit dependency list.`, "Use named service types or never in the third Effect type parameter.");
+                  } else {
+                    const declaredDependencies = sortedUnique(effect.dependencies);
+                    const typedDependencies = sortedUnique(environment.names);
+                    if (declaredDependencies.join("\x00") !== typedDependencies.join("\x00")) {
+                      pushEffectDiagnostic(ctx, "effect-dependency-mismatch", file, lineOf(method), `Route ${route.handler} declares dependencies [${declaredDependencies.join(", ")}], but its Effect environment is [${typedDependencies.join(", ")}].`, "Make effect.dependencies exactly match the third Effect type parameter.");
+                    }
+                  }
+                }
+                if (ctx.effectOptions.requireTimeoutForDependencies && (effect.dependencies?.length ?? 0) > 0 && effect.timeoutMs === undefined) {
+                  pushEffectDiagnostic(ctx, "effect-timeout-required", file, lineOf(method), `Route ${route.handler} declares external Effect dependencies without a timeout.`, "Add a positive effect.timeoutMs so external I/O cannot occupy a request indefinitely.");
+                }
               }
-              if (ctx.effectOptions.requireTimeoutForDependencies && (effect.dependencies?.length ?? 0) > 0 && effect.timeoutMs === undefined) {
-                pushEffectDiagnostic(ctx, "effect-timeout-required", file, lineOf(method), `Route ${route.handler} declares external Effect dependencies without a timeout.`, "Add a positive effect.timeoutMs so external I/O cannot occupy a request indefinitely.");
-              }
-            }
-            if (ctx.effectOptions.forbidDirectThrows && method.body) {
-              for (const throwStatement of descendantsOfKind(method.body, ts8.isThrowStatement)) {
-                pushEffectDiagnostic(ctx, "effect-direct-throw", file, lineOf(throwStatement), `Route ${route.handler} throws directly instead of representing failure in Effect.`, "Use Effect.fail with a tagged error value and map it in effect.errors.");
+              if (ctx.effectOptions.forbidDirectThrows && method.body) {
+                for (const throwStatement of descendantsOfKind(method.body, ts8.isThrowStatement)) {
+                  pushEffectDiagnostic(ctx, "effect-direct-throw", file, lineOf(throwStatement), `Route ${route.handler} throws directly instead of representing failure in Effect.`, "Use Effect.fail with a tagged error value and map it in effect.errors.");
+                }
               }
             }
           }
@@ -22061,6 +22113,23 @@ function checkedBranches(meta, ctx) {
   }
   return branches;
 }
+function checkedBranchesFallback(meta, ctx) {
+  const expression = getProp(meta, "branchesFallback");
+  if (!expression)
+    return;
+  const value = stringLiteralProp(meta, "branchesFallback");
+  if (value === "reject" || value === "command")
+    return value;
+  ctx.diagnostics.push({
+    severity: "error",
+    code: "invalid-command-branches-fallback",
+    file: sourcePath(ctx.rootDir, expression.getSourceFile().fileName),
+    line: lineOf(expression),
+    message: "Command branchesFallback must be 'reject' or 'command'.",
+    suggestion: "Use branchesFallback: 'command' only when the command handler owns the unmatched-input boundary."
+  });
+  return;
+}
 async function classDeps(cls, ctx) {
   const injectable = await parseInjectableOptions(cls, ctx);
   const ctor = cls.members.find(ts8.isConstructorDeclaration);
@@ -23336,6 +23405,14 @@ function validateEffectPolicies(graph, options = {}) {
     for (const controller of module.controllers) {
       for (const route of controller.routes) {
         const label = routeLabel(route, controller.path);
+        if (route.effectMode === "simple") {
+          const featureTransition = featureTransitionForRoute(module, controller, route);
+          const commandRef = route.command ?? featureTransition?.command;
+          if (commandRef !== undefined || !["GET", "HEAD", "OPTIONS"].includes(route.method)) {
+            diagnostics.push(diagnostic("effect-contract-required", commandRef === undefined ? `Route ${label} cannot use effect: false for a write operation.` : `Route ${label} cannot use effect: false when it enters command ${commandRef}.`, controller.file, "Keep Effect enabled for writes and durable commands; effect: false is only for simple read routes."));
+          }
+          continue;
+        }
         if (options.requireRouteEffects && route.effect === undefined) {
           diagnostics.push(diagnostic("effect-contract-required", `Route ${label} must declare an Effect contract.`, controller.file, 'Add effect: { dependencies: [...], errors: [...], retry: "none" } to the route options.'));
           continue;
@@ -23842,8 +23919,8 @@ function createDeliveryPlan(graph, input, validation) {
       target.execution = group;
     }
   }
-  if ([...targets.values()].reduce((count, target) => count + (target.execution?.replicas ?? 1), 0) > 32) {
-    fail("delivery-execution-replica-limit", "A release supports at most 32 runtime targets including replicas.", "Reduce the replica count or split independent applications.");
+  if ([...targets.values()].reduce((count, target) => count + (target.execution ? (target.execution.replicas ?? 1) * (target.execution.shardCount ?? 1) : 1), 0) > 256) {
+    fail("delivery-execution-replica-limit", "A release supports at most 256 runtime targets including replicas and queue shards.", "Reduce the replica or shard count, or split independent applications.");
   }
   const canonicalDiagnostics = [...new Map(diagnostics.map((item) => [JSON.stringify(item), item])).values()].sort((a, b) => compare2(JSON.stringify(a), JSON.stringify(b)));
   if (canonicalDiagnostics.some((item) => item.severity === "error")) {
@@ -23933,6 +24010,7 @@ function validateExecutionManifest(plan, capabilities = {}) {
         ...command.adapter === null ? {} : { rpc: command.adapter },
         ...command.audit === null ? {} : { audit: command.audit },
         ...command.branches.length === 0 ? {} : { branches: command.branches },
+        ...command.branchesFallback === undefined ? {} : { branchesFallback: command.branchesFallback },
         transaction: command.transaction,
         idempotency: command.idempotency
       }))
@@ -25684,10 +25762,10 @@ import { readFileSync as readFileSync4 } from "node:fs";
 import { resolve as resolve17 } from "node:path";
 
 // src/migration-app-version.ts
-var MIGRATION_APP_VERSION = "0.38.0";
+var MIGRATION_APP_VERSION = "0.39.1";
 
 // src/migration-elysia-version.ts
-var MIGRATION_ELYSIA_VERSION = "0.40.0";
+var MIGRATION_ELYSIA_VERSION = "0.42.0";
 
 // src/migration-policy.ts
 var cachedCompilerVersion;