fix(webapp): apply transaction dedupe guard to both $transaction overloads

Code review caught that the infraErrorAlreadyLogged guard was added to only
the named-$transaction callback; the anonymous overload still double-logged
statement-level infra errors. Extract one shared boundary callback so the
guard can't drift between the two overloads.

Also harden the dedupe marker: define it non-enumerable (so error-spreads
can't copy the tag onto a different error) and best-effort (so a frozen
error object can't make the assignment throw and mask the original error).

Author: d-cs

apps/webapp/app/db.server.ts

@@ -29,6 +29,22 @@ export type {
   PrismaReplicaClient,
 };
 
+// Boundary logger for transac(): skips an error the client extension already
+// logged (and tagged) at the statement level, so a single failure is logged
+// once. Shared by both $transaction overloads so the guard can't drift.
+function logTransactionPrismaError(error: Prisma.PrismaClientKnownRequestError) {
+  if (infraErrorAlreadyLogged(error)) {
+    return;
+  }
+  logger.error("prisma.$transaction error", {
+    code: error.code,
+    meta: error.meta,
+    stack: error.stack,
+    message: error.message,
+    name: error.name,
+  });
+}
+
 export async function $transaction<R>(
   prisma: PrismaClientOrTransaction,
   name: string,
@@ -84,39 +100,13 @@ async function $transactionInner<R>(
 
       const fn = fnOrOptions as (prisma: PrismaTransactionClient, span: Span) => Promise<R>;
 
-      return transac(
-        prisma,
-        (client) => fn(client, span),
-        (error) => {
-          // Skip if the client extension already logged this at the statement
-          // level — only commit-time errors that bypass it are logged here.
-          if (infraErrorAlreadyLogged(error)) {
-            return;
-          }
-          logger.error("prisma.$transaction error", {
-            code: error.code,
-            meta: error.meta,
-            stack: error.stack,
-            message: error.message,
-            name: error.name,
-          });
-        },
-        options
-      );
+      return transac(prisma, (client) => fn(client, span), logTransactionPrismaError, options);
     });
   } else {
     return transac(
       prisma,
       fnOrName,
-      (error) => {
-        logger.error("prisma.$transaction error", {
-          code: error.code,
-          meta: error.meta,
-          stack: error.stack,
-          message: error.message,
-          name: error.name,
-        });
-      },
+      logTransactionPrismaError,
       typeof fnOrOptions === "function" ? undefined : fnOrOptions
     );
   }

apps/webapp/app/utils/prismaErrors.ts

@@ -49,8 +49,21 @@ export function isInfrastructureError(error: unknown): boolean {
 const INFRA_ERROR_LOGGED: unique symbol = Symbol("prismaInfraErrorLogged");
 
 function markInfraErrorLogged(error: unknown): void {
-  if (typeof error === "object" && error !== null) {
-    (error as Record<symbol, unknown>)[INFRA_ERROR_LOGGED] = true;
+  if (typeof error !== "object" || error === null) {
+    return;
+  }
+  try {
+    // Non-enumerable so error-spreads/serializers can't copy the marker onto a
+    // different error; try/catch so a frozen error object can't make this throw
+    // and mask the original error as it propagates out of the catch.
+    Object.defineProperty(error, INFRA_ERROR_LOGGED, {
+      value: true,
+      enumerable: false,
+      configurable: true,
+      writable: true,
+    });
+  } catch {
+    // best-effort: a sealed/frozen error simply won't be deduped.
   }
 }