fix(webapp): raw gate replacement keeps the inline gate, V4 deploys validate first

The low-level gates option now carries the task's anonymous inline
limit gate over the same way the concurrency option does (a replay
resending stored gates collapses back through dedupe). The V4 deploy
path rejects invalid concurrency declarations before any worker rows
or engine keys are written, so a failed deploy can no longer leave the
running version's limits mutated.

Author: matt-aitken

apps/webapp/app/runEngine/concerns/queues.server.ts

@@ -248,12 +248,31 @@ export class DefaultQueueManager implements QueueManager {
         ]
       : undefined;
 
+    /**
+     * The raw gates option replaces stored gates the same way concurrency does, so
+     * it also carries the inline gate over; a replay resending the stored gates
+     * collapses back to the original set through the dedupe below.
+     */
+    const rawGates = request.body.options?.gates;
     const requestedGates =
-      concurrencyGates ?? request.body.options?.gates ?? taskGates ?? undefined;
+      concurrencyGates ??
+      (rawGates ? [...inlineTaskGates, ...rawGates] : undefined) ??
+      taskGates ??
+      undefined;
+
+    const seenGates = new Set<string>();
     const gates = requestedGates
       ?.flatMap((gate) => {
         const sanitized = sanitizeQueueName(gate.queue);
-        return sanitized ? [{ queue: sanitized, concurrencyKey: gate.concurrencyKey }] : [];
+        if (!sanitized) {
+          return [];
+        }
+        const dedupeKey = `${sanitized}${gate.concurrencyKey ?? ""}`;
+        if (seenGates.has(dedupeKey)) {
+          return [];
+        }
+        seenGates.add(dedupeKey);
+        return [{ queue: sanitized, concurrencyKey: gate.concurrencyKey }];
       })
       .slice(0, 3);
 

apps/webapp/app/v3/services/createBackgroundWorker.server.ts

@@ -614,7 +614,7 @@ async function createWorkerQueues(
  * Rejects invalid concurrency declarations before any worker rows are written, so a
  * failed deploy leaves nothing behind for a same-content retry to return.
  */
-function validateWorkerConcurrencyDeclarations(metadata: BackgroundWorkerMetadata): void {
+export function validateWorkerConcurrencyDeclarations(metadata: BackgroundWorkerMetadata): void {
   for (const queue of metadata.queues ?? []) {
     assertNotReservedQueueName(queue.name, `Queue "${queue.name}"`);
   }

apps/webapp/app/v3/services/createDeploymentBackgroundWorkerV4.server.ts

@@ -15,6 +15,7 @@ import {
   createWorkerResources,
   syncDeclarativeSchedules,
   syncDeclarativeWebhooks,
+  validateWorkerConcurrencyDeclarations,
 } from "./createBackgroundWorker.server";
 import { findOrCreateBackgroundWorker } from "./createDeploymentBackgroundWorkerV4/findOrCreateBackgroundWorker.server";
 import { TimeoutDeploymentService } from "./timeoutDeployment.server";
@@ -67,6 +68,23 @@ export class CreateDeploymentBackgroundWorkerServiceV4 extends BaseService {
         return;
       }
 
+      /**
+       * Reject invalid concurrency declarations before any worker rows exist. Queue
+       * rows and their engine limit keys are per-environment, so a mid-creation
+       * failure would leave the running version's limits already mutated.
+       */
+      try {
+        validateWorkerConcurrencyDeclarations(body.metadata);
+      } catch (concurrencyError) {
+        if (concurrencyError instanceof ServiceValidationError) {
+          logger.warn("Invalid worker concurrency declarations", {
+            error: concurrencyError.message,
+          });
+          await this.#failBackgroundWorkerDeployment(deployment, concurrencyError, environment);
+        }
+        throw concurrencyError;
+      }
+
       // Handle multi-platform builds
       const deploymentPlatforms = deployment.imagePlatform?.split(",") ?? [];
       if (deploymentPlatforms.length > 1) {