fix(webapp): resolve effective default region in workers API + compute templates

Two callers still read the project-level default directly, which the UI no
longer updates. Use resolveEffectiveDefaultWorkerGroupId (env -> project ->
global) in:
- api.v1.workers isDefault flag
- computeTemplateCreation.resolveMode (MICROVM template decision)

Author: myftija

apps/webapp/app/routes/api.v1.workers.ts

@@ -4,10 +4,14 @@ import {
   WorkersCreateResponseBody,
   WorkersListResponseBody,
 } from "@trigger.dev/core/v3";
+import { $replica } from "~/db.server";
 import {
   createActionApiRoute,
   createLoaderApiRoute,
 } from "~/services/routeBuilders/apiBuilder.server";
+import { FEATURE_FLAG } from "~/v3/featureFlags";
+import { makeFlag } from "~/v3/featureFlags.server";
+import { resolveEffectiveDefaultWorkerGroupId } from "~/v3/regionAccess.server";
 import { WorkerGroupService } from "~/v3/services/worker/workerGroupService.server";
 
 export const loader = createLoaderApiRoute(
@@ -27,12 +31,23 @@ export const loader = createLoaderApiRoute(
       projectId: authentication.environment.projectId,
     });
 
+    const globalDefaultWorkerGroupId = await makeFlag($replica)({
+      key: FEATURE_FLAG.defaultWorkerInstanceGroupId,
+    });
+
+    // env default -> project default -> global default
+    const effectiveDefaultWorkerGroupId = resolveEffectiveDefaultWorkerGroupId({
+      environmentDefaultWorkerGroupId: authentication.environment.defaultWorkerGroupId,
+      projectDefaultWorkerGroupId: authentication.environment.project.defaultWorkerGroupId,
+      globalDefaultWorkerGroupId,
+    });
+
     return json(
       workers.map((w) => ({
         type: w.type,
         name: w.name,
         description: w.description,
-        isDefault: w.id === authentication.environment.project.defaultWorkerGroupId,
+        isDefault: w.id === effectiveDefaultWorkerGroupId,
         updatedAt: w.updatedAt,
       }))
     );

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

@@ -8,7 +8,9 @@ import type { PrismaClientOrTransaction } from "~/db.server";
 import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { ServiceValidationError } from "./baseService.server";
 import { FailDeploymentService } from "./failDeployment.server";
-import { resolveComputeAccess } from "../regionAccess.server";
+import { resolveComputeAccess, resolveEffectiveDefaultWorkerGroupId } from "../regionAccess.server";
+import { FEATURE_FLAG } from "../featureFlags";
+import { makeFlag } from "../featureFlags.server";
 
 type TemplateCreationMode = "required" | "shadow" | "skip";
 
@@ -56,7 +58,7 @@ export class ComputeTemplateCreationService {
     prisma: PrismaClientOrTransaction;
     writer?: WritableStreamDefaultWriter;
   }): Promise<void> {
-    const mode = await this.resolveMode(options.projectId, options.prisma);
+    const mode = await this.resolveMode(options.authenticatedEnv, options.prisma);
 
     if (mode === "skip") {
       return;
@@ -134,19 +136,17 @@ export class ComputeTemplateCreationService {
   }
 
   async resolveMode(
-    projectId: string,
+    authenticatedEnv: AuthenticatedEnvironment,
     prisma: PrismaClientOrTransaction
   ): Promise<TemplateCreationMode> {
     if (!this.client) {
       return "skip";
     }
 
     const project = await prisma.project.findFirst({
-      where: { id: projectId },
+      where: { id: authenticatedEnv.projectId },
       select: {
-        defaultWorkerGroup: {
-          select: { workloadType: true },
-        },
+        defaultWorkerGroupId: true,
         organization: {
           select: { featureFlags: true },
         },
@@ -157,7 +157,24 @@ export class ComputeTemplateCreationService {
       return "skip";
     }
 
-    if (project.defaultWorkerGroup?.workloadType === "MICROVM") {
+    // Resolve the region this env actually deploys to: env default -> project default -> global default.
+    const globalDefaultWorkerGroupId = await makeFlag(prisma)({
+      key: FEATURE_FLAG.defaultWorkerInstanceGroupId,
+    });
+    const effectiveDefaultWorkerGroupId = resolveEffectiveDefaultWorkerGroupId({
+      environmentDefaultWorkerGroupId: authenticatedEnv.defaultWorkerGroupId,
+      projectDefaultWorkerGroupId: project.defaultWorkerGroupId,
+      globalDefaultWorkerGroupId,
+    });
+
+    const defaultWorkerGroup = effectiveDefaultWorkerGroupId
+      ? await prisma.workerInstanceGroup.findFirst({
+          where: { id: effectiveDefaultWorkerGroupId },
+          select: { workloadType: true },
+        })
+      : null;
+
+    if (defaultWorkerGroup?.workloadType === "MICROVM") {
       return "required";
     }