@supacloud/compiler 0.57.1 → 0.59.0

package/dist/contract-manifest.d.ts

@@ -7,6 +7,7 @@ export interface ContractManifest {
         module: string;
         permission?: string;
         rpc?: string;
+        branchesFallback?: "reject" | "command";
         branches?: Array<{
             when: string;
             adapter: string;

package/dist/delivery-bundle-protocol.d.ts

@@ -19,6 +19,7 @@ declare const requestSchema: Type.TObject<{
                 definitionVersion: Type.TString;
                 replicas: Type.TInteger;
                 maxReplicas: Type.TInteger;
+                shardCount: Type.TOptional<Type.TInteger>;
                 concurrencyPerReplica: Type.TInteger;
                 resources: Type.TObject<{
                     cpuLimit: Type.TNumber;

package/dist/delivery-bundle-worker.js

@@ -10103,23 +10103,49 @@ var init_build2 = __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);
   }
 }
@@ -10143,6 +10169,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_({