prisma-generator-effect 1.0.0 → 1.1.0-beta.0

package/dist/index.js

@@ -4,9 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const generator_helper_1 = require("@prisma/generator-helper");
+const node_child_process_1 = require("node:child_process");
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
+const generator_helper_1 = require("@prisma/generator-helper");
 const header = `// This file was generated by prisma-generator-effect, do not edit manually.\n`;
 // Utility function to convert PascalCase to camelCase
 function toCamelCase(str) {
@@ -28,10 +29,7 @@ function toCamelCase(str) {
         const configPath = options.generator.config.clientImportPath;
         const clientImportPath = Array.isArray(configPath)
             ? configPath[0]
-            : configPath ?? "@prisma/client";
-        // Get datasource provider (e.g., "sqlite", "postgresql", "mysql", etc.)
-        const datasources = options.datasources;
-        const provider = datasources[0]?.provider; // Usually there's one datasource, but could be multiple
+            : (configPath ?? "@prisma/client");
         // Custom error configuration: "path/to/module#ErrorClassName"
         // Path is relative to schema.prisma, e.g., "./errors#PrismaError"
         // The module must export:
@@ -47,10 +45,26 @@ function toCamelCase(str) {
         const importExtConfigRaw = options.generator.config.importFileExtension;
         const importFileExtension = Array.isArray(importExtConfigRaw)
             ? importExtConfigRaw[0]
-            : importExtConfigRaw ?? "";
+            : (importExtConfigRaw ?? "");
+        // Telemetry configuration: enable Effect.fn tracing for all operations
+        // Set to "true" to wrap operations with Effect.fn (adds operation names to traces)
+        // Set to "false" to use Effect.fnUntraced (no telemetry overhead)
+        const telemetryConfigRaw = options.generator.config.enableTelemetry;
+        const enableTelemetry = Array.isArray(telemetryConfigRaw)
+            ? telemetryConfigRaw[0] === "true"
+            : telemetryConfigRaw === "true";
         if (!outputDir) {
             throw new Error("No output directory specified");
         }
+        // Get datasource provider (e.g., "sqlite", "postgresql", "mysql", etc.)
+        // Used to avoid generating createManyAndReturn/updateManyAndReturn when the DB doesn't support them
+        const datasources = options.datasources;
+        const provider = datasources?.[0]?.provider;
+        const supportsManyAndReturn = provider === "postgresql" ||
+            provider === "postgres" ||
+            provider === "prisma+postgres" ||
+            provider === "cockroachdb" ||
+            provider === "sqlite";
         // Helper to add file extension to a path if configured
         const addExtension = (filePath) => {
             if (!importFileExtension)
@@ -89,254 +103,425 @@ function toCamelCase(str) {
         await promises_1.default.rm(outputDir, { recursive: true, force: true });
         await promises_1.default.mkdir(outputDir, { recursive: true });
         // Generate unified index file with PrismaService
-        await generateUnifiedService([...models], outputDir, clientImportPath, errorImportPath, provider);
+        await generateUnifiedService([...models], outputDir, clientImportPath, errorImportPath, enableTelemetry, supportsManyAndReturn);
     },
 });
-function generateRawSqlOperations(customError) {
+function generateRawSqlOperations(customError, enableTelemetry) {
     // With custom error, use mapError which maps to user's error type
     // Without custom error, use mapError which maps to PrismaError union
     const errorType = customError ? customError.className : "PrismaError";
+    const wrapTelemetry = (name, generatorFn) => enableTelemetry
+        ? `Effect.fn("${name}")(${generatorFn})`
+        : `Effect.fnUntraced(${generatorFn})`;
     return `
-    $executeRaw: (args: PrismaNamespace.Sql | [PrismaNamespace.Sql, ...any[]]): Effect.Effect<number, ${errorType}, PrismaClient> =>
-      Effect.flatMap(PrismaClient, ({ tx: client }) =>
-        Effect.tryPromise({
-          try: () => (Array.isArray(args) ? client.$executeRaw(args[0], ...args.slice(1)) : client.$executeRaw(args)),
-          catch: (error) => mapError(error, "$executeRaw", "Prisma")
-        })
-      ),
-
-    $executeRawUnsafe: (query: string, ...values: any[]): Effect.Effect<number, ${errorType}, PrismaClient> =>
-      Effect.flatMap(PrismaClient, ({ tx: client }) =>
-        Effect.tryPromise({
-          try: () => client.$executeRawUnsafe(query, ...values),
-          catch: (error) => mapError(error, "$executeRawUnsafe", "Prisma")
-        })
-      ),
-
-    $queryRaw: <T = unknown>(args: PrismaNamespace.Sql | [PrismaNamespace.Sql, ...any[]]): Effect.Effect<T, ${errorType}, PrismaClient> =>
-      Effect.flatMap(PrismaClient, ({ tx: client }) =>
-        Effect.tryPromise({
-          try: () => (Array.isArray(args) ? client.$queryRaw(args[0], ...args.slice(1)) : client.$queryRaw(args)) as Promise<T>,
-          catch: (error) => mapError(error, "$queryRaw", "Prisma")
-        })
-      ),
-
-    $queryRawUnsafe: <T = unknown>(query: string, ...values: any[]): Effect.Effect<T, ${errorType}, PrismaClient> =>
-      Effect.flatMap(PrismaClient, ({ tx: client }) =>
-        Effect.tryPromise({
-          try: () => client.$queryRawUnsafe(query, ...values) as Promise<T>,
-          catch: (error) => mapError(error, "$queryRawUnsafe", "Prisma")
-        })
-      ),`;
+    $executeRaw: ${wrapTelemetry("Prisma.$executeRaw", `function* (args) {
+      const actualClient = yield* clientOrTx(client);
+      return yield* Effect.tryPromise<any, ${errorType}>({
+        try: () => (Array.isArray(args) ? actualClient.$executeRaw(args[0], ...args.slice(1)) : actualClient.$executeRaw(args)) as any,
+        catch: (error) => mapError(error, "$executeRaw", "Prisma")
+      });
+    }`)},
+
+    $executeRawUnsafe: ${wrapTelemetry("Prisma.$executeRawUnsafe", `function* (query, ...values) {
+      const actualClient = yield* clientOrTx(client);
+      return yield* Effect.tryPromise<any, ${errorType}>({
+        try: () => actualClient.$executeRawUnsafe(query, ...values) as any,
+        catch: (error) => mapError(error, "$executeRawUnsafe", "Prisma")
+      });
+    }`)},
+
+    $queryRaw: ${wrapTelemetry("Prisma.$queryRaw", `function* (args) {
+      const actualClient = yield* clientOrTx(client);
+      return yield* Effect.tryPromise<any, ${errorType}>({
+        try: () => (Array.isArray(args) ? actualClient.$queryRaw(args[0], ...args.slice(1)) : actualClient.$queryRaw(args)) as any,
+        catch: (error) => mapError(error, "$queryRaw", "Prisma")
+      });
+    }`)},
+
+    $queryRawUnsafe: ${wrapTelemetry("Prisma.$queryRawUnsafe", `function* (query, ...values) {
+      const actualClient = yield* clientOrTx(client);
+      return yield* Effect.tryPromise<any, ${errorType}>({
+        try: () => actualClient.$queryRawUnsafe(query, ...values) as any,
+        catch: (error) => mapError(error, "$queryRawUnsafe", "Prisma")
+      });
+    }`)},`;
 }
-function generateModelOperations(models, customError, provider) {
-    // Check if provider supports createManyAndReturn and updateManyAndReturn
-    const supportsManyAndReturn = provider === "postgresql" ||
-        provider === "postgres" ||
-        provider === "prisma+postgres" ||
-        provider === "cockroachdb" ||
-        provider === "sqlite";
+/**
+ * Generate type aliases for a model to reduce redundant type computation.
+ * TypeScript performance is significantly improved when complex types are
+ * computed once and reused via aliases rather than inline.
+ */
+function generateModelTypeAliases(models, supportsManyAndReturn) {
+    const operations = [
+        "findUnique",
+        "findUniqueOrThrow",
+        "findFirst",
+        "findFirstOrThrow",
+        "findMany",
+        "create",
+        "createMany",
+        ...(supportsManyAndReturn ? ["createManyAndReturn"] : []),
+        "delete",
+        "update",
+        "deleteMany",
+        "updateMany",
+        ...(supportsManyAndReturn ? ["updateManyAndReturn"] : []),
+        "upsert",
+        "count",
+        "aggregate",
+        "groupBy",
+    ];
     return models
         .map((model) => {
         const modelName = model.name;
         const modelNameCamel = toCamelCase(modelName);
-        // Type alias for the model delegate (e.g., BasePrismaClient['user'])
+        const argsAliases = operations
+            .map((op) => `type ${modelName}${capitalize(op)}Args = PrismaNamespace.Args<BasePrismaClient['${modelNameCamel}'], '${op}'>`)
+            .join("\n");
+        return argsAliases;
+    })
+        .join("\n\n");
+}
+/**
+ * Generate the IPrismaService interface that defines the contract for all Prisma operations.
+ * This interface is used to type-check the service implementation and provides explicit types.
+ */
+function generatePrismaInterface(models, customError, supportsManyAndReturn) {
+    const errorType = customError ? customError.className : "PrismaError";
+    // Generate model operation interfaces
+    const modelInterfaces = models
+        .map((model) => {
+        const modelName = model.name;
+        const modelNameCamel = toCamelCase(modelName);
         const delegate = `BasePrismaClient['${modelNameCamel}']`;
+        // Helper to get Args type alias
+        const argsType = (op) => `${modelName}${capitalize(op)}Args`;
+        // Helper for error types based on operation
+        const errorTypeFor = (op) => {
+            if (customError)
+                return customError.className;
+            // Map operations to their specific error types
+            if (["findUniqueOrThrow", "findFirstOrThrow"].includes(op)) {
+                return "PrismaFindOrThrowError";
+            }
+            else if ([
+                "findUnique",
+                "findFirst",
+                "findMany",
+                "count",
+                "aggregate",
+                "groupBy",
+            ].includes(op)) {
+                return "PrismaFindError";
+            }
+            else if (["create", "createMany", "createManyAndReturn"].includes(op)) {
+                return "PrismaCreateError";
+            }
+            else if (["update", "updateMany", "updateManyAndReturn", "upsert"].includes(op)) {
+                return "PrismaUpdateError";
+            }
+            else if (["delete", "deleteMany"].includes(op)) {
+                return "PrismaDeleteError";
+            }
+            return "PrismaError";
+        };
+        return `  ${modelNameCamel}: {
+    findUnique: <A extends ${argsType("findUnique")}>(
+      args: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'findUnique'> | null, ${errorTypeFor("findUnique")}>
+
+    findUniqueOrThrow: <A extends ${argsType("findUniqueOrThrow")}>(
+      args: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'findUniqueOrThrow'>, ${errorTypeFor("findUniqueOrThrow")}>
+
+    findFirst: <A extends ${argsType("findFirst")}>(
+      args: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'findFirst'> | null, ${errorTypeFor("findFirst")}>
+
+    findFirstOrThrow: <A extends ${argsType("findFirstOrThrow")}>(
+      args: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'findFirstOrThrow'>, ${errorTypeFor("findFirstOrThrow")}>
+
+    findMany: <A extends ${argsType("findMany")}>(
+      args?: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'findMany'>, ${errorTypeFor("findMany")}>
+
+    create: <A extends ${argsType("create")}>(
+      args: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'create'>, ${errorTypeFor("create")}>
+
+    createMany: <A extends ${argsType("createMany")}>(
+      args: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'createMany'>, ${errorTypeFor("createMany")}>${supportsManyAndReturn
+            ? `
+
+    createManyAndReturn: <A extends ${argsType("createManyAndReturn")}>(
+      args: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'createManyAndReturn'>, ${errorTypeFor("createManyAndReturn")}>`
+            : ""}
+
+    delete: <A extends ${argsType("delete")}>(
+      args: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'delete'>, ${errorTypeFor("delete")}>
+
+    update: <A extends ${argsType("update")}>(
+      args: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'update'>, ${errorTypeFor("update")}>
+
+    deleteMany: <A extends ${argsType("deleteMany")}>(
+      args?: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'deleteMany'>, ${errorTypeFor("deleteMany")}>
+
+    updateMany: <A extends ${argsType("updateMany")}>(
+      args: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'updateMany'>, ${errorTypeFor("updateMany")}>${supportsManyAndReturn
+            ? `
+
+    updateManyAndReturn: <A extends ${argsType("updateManyAndReturn")}>(
+      args: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'updateManyAndReturn'>, ${errorTypeFor("updateManyAndReturn")}>`
+            : ""}
+
+    upsert: <A extends ${argsType("upsert")}>(
+      args: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'upsert'>, ${errorTypeFor("upsert")}>
+
+    count: <A extends ${argsType("count")}>(
+      args?: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'count'>, ${errorTypeFor("count")}>
+
+    aggregate: <A extends ${argsType("aggregate")}>(
+      args: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'aggregate'>, ${errorTypeFor("aggregate")}>
+
+    groupBy: <A extends ${argsType("groupBy")}>(
+      args: A
+    ) => EffectType<PrismaNamespace.Result<${delegate}, A, 'groupBy'>, ${errorTypeFor("groupBy")}>
+  }`;
+    })
+        .join("\n\n");
+    return `/**
+ * Interface defining all Prisma operations with explicit types.
+ * This provides a type contract that the service implementation must satisfy.
+ */
+export interface IPrismaService {
+  client: BasePrismaClient
+  // Transaction operations
+  $transaction: <R, E, A>(
+    effect: EffectType<A, E, R>
+  ) => EffectType<A, E | ${errorType}, Exclude<R, PrismaTransactionClientService>>
+
+  $transactionWith: <R, E, A>(
+    effect: EffectType<A, E, R>,
+    options: TransactionOptions
+  ) => EffectType<A, E | ${errorType}, R>
+
+  $isolatedTransaction: <R, E, A>(
+    effect: EffectType<A, E, R>
+  ) => EffectType<A, E | ${errorType}, R>
+
+  $isolatedTransactionWith: <R, E, A>(
+    effect: EffectType<A, E, R>,
+    options: TransactionOptions
+  ) => EffectType<A, E | ${errorType}, R>
+
+  // Raw SQL operations
+  $executeRaw: (
+    args: PrismaNamespace.Sql | [PrismaNamespace.Sql, ...any[]]
+  ) => EffectType<number, ${errorType}>
+
+  $executeRawUnsafe: (
+    query: string,
+    ...values: any[]
+  ) => EffectType<number, ${errorType}>
+
+  $queryRaw: <T = unknown>(
+    args: PrismaNamespace.Sql | [PrismaNamespace.Sql, ...any[]]
+  ) => EffectType<T, ${errorType}>
+
+  $queryRawUnsafe: <T = unknown>(
+    query: string,
+    ...values: any[]
+  ) => EffectType<T, ${errorType}>
+
+  // Model operations
+${modelInterfaces}
+}
+`;
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function generateModelOperations(models, customError, enableTelemetry, supportsManyAndReturn) {
+    return models
+        .map((model) => {
+        const modelName = model.name;
+        const modelNameCamel = toCamelCase(modelName);
+        // Use pre-computed type alias for delegate
+        const _delegate = `BasePrismaClient['${modelNameCamel}']`;
+        // Helper to get pre-computed Args type alias
+        const _argsType = (op) => `${modelName}${capitalize(op)}Args`;
         // Cast Promise results to ensure consistent typing across Prisma versions
-        // This handles Prisma 7's GlobalOmitConfig and works fine with Prisma 6 too
-        const promiseCast = (op, nullable = false) => {
-            const resultType = `PrismaNamespace.Result<${delegate}, A, '${op}'>`;
-            const fullType = nullable ? `${resultType} | null` : resultType;
-            return ` as Promise<${fullType}>`;
+        // This handles Prisma 7's GlobalOmitConfig
+        // @deprecated just cast as any now
+        const promiseCast = () => {
+            return " as any";
         };
         // Aggregate/groupBy use complex internal types that need stronger casts
-        const strongPromiseCast = (op) => {
-            const resultType = `PrismaNamespace.Result<${delegate}, A, '${op}'>`;
-            return ` as unknown as Promise<${resultType}>`;
-        };
-        const resultType = (op, nullable = false) => {
-            const baseType = `PrismaNamespace.Result<${delegate}, A, '${op}'>`;
-            return nullable ? `${baseType} | null` : baseType;
+        // @deprecated just cast as any now
+        const strongPromiseCast = () => {
+            return " as any";
         };
         // With custom error: all operations use single error type and mapError
         // Without custom error: use per-operation error types and mappers
         const errorType = (opErrorType) => customError ? customError.className : opErrorType;
         const mapperFn = (defaultMapper) => customError ? "mapError" : defaultMapper;
+        // Telemetry: wrap operations with Effect.fn or Effect.fnUntraced
+        const wrapTelemetry = (name, generatorFn) => enableTelemetry
+            ? `Effect.fn("${name}")(${generatorFn})`
+            : `Effect.fnUntraced(${generatorFn})`;
+        // Implementation without explicit types - the IPrismaService interface provides all type checking
         return `    ${modelNameCamel}: {
-      findUnique: <A extends PrismaNamespace.Args<${delegate}, 'findUnique'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'findUnique'>>
-      ): Effect.Effect<${resultType("findUnique", true)}, ${errorType("PrismaFindError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.findUnique(args as any)${promiseCast("findUnique", true)},
-            catch: (error) => ${mapperFn("mapFindError")}(error, "findUnique", "${modelName}")
-          })
-        ),
-
-      findUniqueOrThrow: <A extends PrismaNamespace.Args<${delegate}, 'findUniqueOrThrow'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'findUniqueOrThrow'>>
-      ): Effect.Effect<${resultType("findUniqueOrThrow")}, ${errorType("PrismaFindOrThrowError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.findUniqueOrThrow(args as any)${promiseCast("findUniqueOrThrow")},
-            catch: (error) => ${mapperFn("mapFindOrThrowError")}(error, "findUniqueOrThrow", "${modelName}")
-          })
-        ),
-
-      findFirst: <A extends PrismaNamespace.Args<${delegate}, 'findFirst'> = {}>(
-        args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'findFirst'>>
-      ): Effect.Effect<${resultType("findFirst", true)}, ${errorType("PrismaFindError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.findFirst(args as any)${promiseCast("findFirst", true)},
-            catch: (error) => ${mapperFn("mapFindError")}(error, "findFirst", "${modelName}")
-          })
-        ),
-
-      findFirstOrThrow: <A extends PrismaNamespace.Args<${delegate}, 'findFirstOrThrow'> = {}>(
-        args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'findFirstOrThrow'>>
-      ): Effect.Effect<${resultType("findFirstOrThrow")}, ${errorType("PrismaFindOrThrowError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.findFirstOrThrow(args as any)${promiseCast("findFirstOrThrow")},
-            catch: (error) => ${mapperFn("mapFindOrThrowError")}(error, "findFirstOrThrow", "${modelName}")
-          })
-        ),
-
-      findMany: <A extends PrismaNamespace.Args<${delegate}, 'findMany'> = {}>(
-        args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'findMany'>>
-      ): Effect.Effect<${resultType("findMany")}, ${errorType("PrismaFindError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.findMany(args as any)${promiseCast("findMany")},
-            catch: (error) => ${mapperFn("mapFindError")}(error, "findMany", "${modelName}")
-          })
-        ),
-
-      create: <A extends PrismaNamespace.Args<${delegate}, 'create'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'create'>>
-      ): Effect.Effect<${resultType("create")}, ${errorType("PrismaCreateError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.create(args as any)${promiseCast("create")},
-            catch: (error) => ${mapperFn("mapCreateError")}(error, "create", "${modelName}")
-          })
-        ),
-
-      createMany: (
-        args?: PrismaNamespace.Args<${delegate}, 'createMany'>
-      ): Effect.Effect<PrismaNamespace.BatchPayload, ${errorType("PrismaCreateError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.createMany(args as any),
-            catch: (error) => ${mapperFn("mapCreateError")}(error, "createMany", "${modelName}")
-          })
-        ),${supportsManyAndReturn
+      findUnique: ${wrapTelemetry(`Prisma.${modelNameCamel}.findUnique`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaFindError")}>({
+          try: () => actualClient.${modelNameCamel}.findUnique(args as any)${promiseCast()},
+          catch: (error) => ${mapperFn("mapFindError")}(error, "findUnique", "${modelName}")
+        });
+      }`)},
+
+      findUniqueOrThrow: ${wrapTelemetry(`Prisma.${modelNameCamel}.findUniqueOrThrow`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaFindOrThrowError")}>({
+          try: () => actualClient.${modelNameCamel}.findUniqueOrThrow(args as any)${promiseCast()},
+          catch: (error) => ${mapperFn("mapFindOrThrowError")}(error, "findUniqueOrThrow", "${modelName}")
+        });
+      }`)},
+
+      findFirst: ${wrapTelemetry(`Prisma.${modelNameCamel}.findFirst`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaFindError")}>({
+          try: () => actualClient.${modelNameCamel}.findFirst(args as any)${promiseCast()},
+          catch: (error) => ${mapperFn("mapFindError")}(error, "findFirst", "${modelName}")
+        });
+      }`)},
+
+      findFirstOrThrow: ${wrapTelemetry(`Prisma.${modelNameCamel}.findFirstOrThrow`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaFindOrThrowError")}>({
+          try: () => actualClient.${modelNameCamel}.findFirstOrThrow(args as any)${promiseCast()},
+          catch: (error) => ${mapperFn("mapFindOrThrowError")}(error, "findFirstOrThrow", "${modelName}")
+        });
+      }`)},
+
+      findMany: ${wrapTelemetry(`Prisma.${modelNameCamel}.findMany`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaFindError")}>({
+          try: () => actualClient.${modelNameCamel}.findMany(args as any)${promiseCast()},
+          catch: (error) => ${mapperFn("mapFindError")}(error, "findMany", "${modelName}")
+        });
+      }`)},
+
+      create: ${wrapTelemetry(`Prisma.${modelNameCamel}.create`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaCreateError")}>({
+          try: () => actualClient.${modelNameCamel}.create(args as any)${promiseCast()},
+          catch: (error) => ${mapperFn("mapCreateError")}(error, "create", "${modelName}")
+        });
+      }`)},
+
+      createMany: ${wrapTelemetry(`Prisma.${modelNameCamel}.createMany`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaCreateError")}>({
+          try: () => actualClient.${modelNameCamel}.createMany(args as any),
+          catch: (error) => ${mapperFn("mapCreateError")}(error, "createMany", "${modelName}")
+        });
+      }`)},${supportsManyAndReturn
             ? `
 
-      createManyAndReturn: <A extends PrismaNamespace.Args<${delegate}, 'createManyAndReturn'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'createManyAndReturn'>>
-      ): Effect.Effect<${resultType("createManyAndReturn")}, ${errorType("PrismaCreateError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.createManyAndReturn(args as any)${promiseCast("createManyAndReturn")},
-            catch: (error) => ${mapperFn("mapCreateError")}(error, "createManyAndReturn", "${modelName}")
-          })
-        ),`
+      createManyAndReturn: ${wrapTelemetry(`Prisma.${modelNameCamel}.createManyAndReturn`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaCreateError")}>({
+          try: () => actualClient.${modelNameCamel}.createManyAndReturn(args as any)${promiseCast()},
+          catch: (error) => ${mapperFn("mapCreateError")}(error, "createManyAndReturn", "${modelName}")
+        });
+      }`)},`
             : ""}
 
-      delete: <A extends PrismaNamespace.Args<${delegate}, 'delete'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'delete'>>
-      ): Effect.Effect<${resultType("delete")}, ${errorType("PrismaDeleteError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.delete(args as any)${promiseCast("delete")},
-            catch: (error) => ${mapperFn("mapDeleteError")}(error, "delete", "${modelName}")
-          })
-        ),
-
-      update: <A extends PrismaNamespace.Args<${delegate}, 'update'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'update'>>
-      ): Effect.Effect<${resultType("update")}, ${errorType("PrismaUpdateError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.update(args as any)${promiseCast("update")},
-            catch: (error) => ${mapperFn("mapUpdateError")}(error, "update", "${modelName}")
-          })
-        ),
-
-      deleteMany: (
-        args?: PrismaNamespace.Args<${delegate}, 'deleteMany'>
-      ): Effect.Effect<PrismaNamespace.BatchPayload, ${errorType("PrismaDeleteManyError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.deleteMany(args as any),
-            catch: (error) => ${mapperFn("mapDeleteManyError")}(error, "deleteMany", "${modelName}")
-          })
-        ),
-
-      updateMany: (
-        args: PrismaNamespace.Args<${delegate}, 'updateMany'>
-      ): Effect.Effect<PrismaNamespace.BatchPayload, ${errorType("PrismaUpdateManyError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.updateMany(args as any),
-            catch: (error) => ${mapperFn("mapUpdateManyError")}(error, "updateMany", "${modelName}")
-          })
-        ),${supportsManyAndReturn
+      delete: ${wrapTelemetry(`Prisma.${modelNameCamel}.delete`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaDeleteError")}>({
+          try: () => actualClient.${modelNameCamel}.delete(args as any)${promiseCast()},
+          catch: (error) => ${mapperFn("mapDeleteError")}(error, "delete", "${modelName}")
+        });
+      }`)},
+
+      update: ${wrapTelemetry(`Prisma.${modelNameCamel}.update`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaUpdateError")}>({
+          try: () => actualClient.${modelNameCamel}.update(args as any)${promiseCast()},
+          catch: (error) => ${mapperFn("mapUpdateError")}(error, "update", "${modelName}")
+        });
+      }`)},
+
+      deleteMany: ${wrapTelemetry(`Prisma.${modelNameCamel}.deleteMany`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaDeleteManyError")}>({
+          try: () => actualClient.${modelNameCamel}.deleteMany(args as any),
+          catch: (error) => ${mapperFn("mapDeleteManyError")}(error, "deleteMany", "${modelName}")
+        });
+      }`)},
+
+      updateMany: ${wrapTelemetry(`Prisma.${modelNameCamel}.updateMany`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaUpdateManyError")}>({
+          try: () => actualClient.${modelNameCamel}.updateMany(args as any),
+          catch: (error) => ${mapperFn("mapUpdateManyError")}(error, "updateMany", "${modelName}")
+        });
+      }`)},${supportsManyAndReturn
             ? `
 
-      updateManyAndReturn: <A extends PrismaNamespace.Args<${delegate}, 'updateManyAndReturn'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'updateManyAndReturn'>>
-      ): Effect.Effect<${resultType("updateManyAndReturn")}, ${errorType("PrismaUpdateManyError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.updateManyAndReturn(args as any)${promiseCast("updateManyAndReturn")},
-            catch: (error) => ${mapperFn("mapUpdateManyError")}(error, "updateManyAndReturn", "${modelName}")
-          })
-        ),`
+      updateManyAndReturn: ${wrapTelemetry(`Prisma.${modelNameCamel}.updateManyAndReturn`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaUpdateManyError")}>({
+          try: () => actualClient.${modelNameCamel}.updateManyAndReturn(args as any)${promiseCast()},
+          catch: (error) => ${mapperFn("mapUpdateManyError")}(error, "updateManyAndReturn", "${modelName}")
+        });
+      }`)},`
             : ""}
 
-      upsert: <A extends PrismaNamespace.Args<${delegate}, 'upsert'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'upsert'>>
-      ): Effect.Effect<${resultType("upsert")}, ${errorType("PrismaCreateError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.upsert(args as any)${promiseCast("upsert")},
-            catch: (error) => ${mapperFn("mapCreateError")}(error, "upsert", "${modelName}")
-          })
-        ),
+      upsert: ${wrapTelemetry(`Prisma.${modelNameCamel}.upsert`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaCreateError")}>({
+          try: () => actualClient.${modelNameCamel}.upsert(args as any)${promiseCast()},
+          catch: (error) => ${mapperFn("mapCreateError")}(error, "upsert", "${modelName}")
+        });
+      }`)},
 
       // Aggregation operations
-      count: <A extends PrismaNamespace.Args<${delegate}, 'count'> = {}>(
-        args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'count'>>
-      ): Effect.Effect<${resultType("count")}, ${errorType("PrismaFindError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.count(args as any)${promiseCast("count")},
-            catch: (error) => ${mapperFn("mapFindError")}(error, "count", "${modelName}")
-          })
-        ),
-
-      aggregate: <A extends PrismaNamespace.Args<${delegate}, 'aggregate'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'aggregate'>>
-      ): Effect.Effect<${resultType("aggregate")}, ${errorType("PrismaFindError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.aggregate(args as any)${strongPromiseCast("aggregate")},
-            catch: (error) => ${mapperFn("mapFindError")}(error, "aggregate", "${modelName}")
-          })
-        ),
-
-      groupBy: <A extends PrismaNamespace.Args<${delegate}, 'groupBy'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'groupBy'>>
-      ): Effect.Effect<${resultType("groupBy")}, ${errorType("PrismaFindError")}, PrismaClient> =>
-        Effect.flatMap(PrismaClient, ({ tx: client }) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.groupBy(args as any)${strongPromiseCast("groupBy")},
-            catch: (error) => ${mapperFn("mapFindError")}(error, "groupBy", "${modelName}")
-          })
-        )
+      count: ${wrapTelemetry(`Prisma.${modelNameCamel}.count`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaFindError")}>({
+          try: () => actualClient.${modelNameCamel}.count(args as any)${promiseCast()},
+          catch: (error) => ${mapperFn("mapFindError")}(error, "count", "${modelName}")
+        });
+      }`)},
+
+      aggregate: ${wrapTelemetry(`Prisma.${modelNameCamel}.aggregate`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaFindError")}>({
+          try: () => actualClient.${modelNameCamel}.aggregate(args as any)${strongPromiseCast()},
+          catch: (error) => ${mapperFn("mapFindError")}(error, "aggregate", "${modelName}")
+        });
+      }`)},
+
+      groupBy: ${wrapTelemetry(`Prisma.${modelNameCamel}.groupBy`, `function* (args) {
+        const actualClient = yield* clientOrTx(client);
+        return yield* Effect.tryPromise<any, ${errorType("PrismaFindError")}>({
+          try: () => actualClient.${modelNameCamel}.groupBy(args as any)${strongPromiseCast()},
+          catch: (error) => ${mapperFn("mapFindError")}(error, "groupBy", "${modelName}")
+        });
+      }`)}
     }`;
     })
         .join(",\n\n");
@@ -351,27 +536,48 @@ function parseErrorImportPath(errorImportPath) {
     }
     return { path, className };
 }
-async function generateUnifiedService(models, outputDir, clientImportPath, errorImportPath, provider) {
+async function generateUnifiedService(models, outputDir, clientImportPath, errorImportPath, enableTelemetry, supportsManyAndReturn) {
     const customError = parseErrorImportPath(errorImportPath);
-    const rawSqlOperations = generateRawSqlOperations(customError);
-    const modelOperations = generateModelOperations(models, customError, provider);
+    const rawSqlOperations = generateRawSqlOperations(customError, enableTelemetry);
+    const modelTypeAliases = generateModelTypeAliases(models, supportsManyAndReturn);
+    const prismaInterface = generatePrismaInterface(models, customError, supportsManyAndReturn);
+    const modelOperations = generateModelOperations(models, customError, enableTelemetry, supportsManyAndReturn);
     // Generate different content based on whether custom error is configured
     const serviceContent = customError
-        ? generateCustomErrorService(customError, clientImportPath, rawSqlOperations, modelOperations)
-        : generateDefaultErrorService(clientImportPath, rawSqlOperations, modelOperations);
-    await promises_1.default.writeFile(node_path_1.default.join(outputDir, "index.ts"), serviceContent);
+        ? generateCustomErrorService(customError, clientImportPath, rawSqlOperations, modelTypeAliases, prismaInterface, modelOperations, enableTelemetry)
+        : generateDefaultErrorService(clientImportPath, rawSqlOperations, modelTypeAliases, prismaInterface, modelOperations, enableTelemetry);
+    const outputPath = node_path_1.default.join(outputDir, "index.ts");
+    await promises_1.default.writeFile(outputPath, serviceContent);
+    // Format the generated file with Biome
+    try {
+        (0, node_child_process_1.execSync)(`npx @biomejs/biome format --write "${outputPath}"`, {
+            stdio: "inherit",
+            cwd: process.cwd(),
+        });
+    }
+    catch (error) {
+        console.warn("Warning: Failed to format generated code with Biome:", error);
+    }
 }
 /**
  * Generate service with custom user-provided error class.
  * All operations use a single error type and a simple mapError function.
  */
-function generateCustomErrorService(customError, clientImportPath, rawSqlOperations, modelOperations) {
+function generateCustomErrorService(customError, clientImportPath, rawSqlOperations, modelTypeAliases, prismaInterface, modelOperations, enableTelemetry) {
+    const _errorType = customError.className;
     return `${header}
-import { Context, Effect, Exit, Layer } from "effect"
-import { Service } from "effect/Effect"
+import { Effect, Exit, Layer, Option, Scope, ServiceMap } from "effect"
+import type { Effect as EffectType, Error as EffectError, Services as EffectServices, Success as EffectSuccess } from "effect/Effect"
 import { Prisma as PrismaNamespace, PrismaClient as BasePrismaClient } from "${clientImportPath}"
 import { ${customError.className}, mapPrismaError } from "${customError.path}"
 
+// ============================================================================
+// Type aliases for model operations (performance optimization)
+// These are computed once and reused, reducing TypeScript's type-checking workload
+// ============================================================================
+
+${modelTypeAliases}
+
 // Symbol used to identify intentional rollbacks vs actual errors
 const ROLLBACK = Symbol.for("prisma.effect.rollback")
 
@@ -390,59 +596,44 @@ type TransactionOptions = {
 
 /**
  * Context tag for the Prisma client instance.
- * Holds the transaction client (tx) and root client.
  *
  * Use \`PrismaClient.layer()\` or \`PrismaClient.layerEffect()\` to create a layer.
  *
  * @example
- * // Prisma 6 - all options are optional
- * const layer = PrismaClient.layer({ datasourceUrl: "..." })
- *
  * // Prisma 7 - adapter or accelerateUrl is required
  * const layer = PrismaClient.layer({ adapter: myAdapter })
  *
  * // With transaction options (Prisma uses these as defaults for $transaction)
  * const layer = PrismaClient.layer({
- *   adapter: myAdapter,  // or datasourceUrl for Prisma 6
+ *   adapter: myAdapter,
  *   transactionOptions: { isolationLevel: "Serializable", timeout: 10000 }
  * })
  */
-export class PrismaClient extends Context.Tag("PrismaClient")<
-  PrismaClient,
-  {
-    tx: BasePrismaClient | PrismaNamespace.TransactionClient
-    client: BasePrismaClient
-  }
->() {
+export class PrismaClient extends ServiceMap.Service<PrismaClient, BasePrismaClient>()("PrismaClient") {
   /**
    * Create a PrismaClient layer with the given options.
    * The client will be automatically disconnected when the layer scope ends.
    *
    * Pass options directly - the signature matches PrismaClient's constructor.
-   * Prisma 6: all options are optional
-   * Prisma 7: requires either \`adapter\` or \`accelerateUrl\`
+   * Prisma 7: requires either \`adapter\`
    *
    * @example
-   * // Prisma 6
-   * const layer = PrismaClient.layer({ datasourceUrl: process.env.DATABASE_URL })
-   *
    * // Prisma 7 with adapter
    * const layer = PrismaClient.layer({ adapter: myAdapter })
-   *
    * // With transaction options
    * const layer = PrismaClient.layer({
    *   adapter: myAdapter,
    *   transactionOptions: { isolationLevel: "Serializable" }
    * })
    */
-  static layer = (
+  static layer: (
     ...args: ConstructorParameters<typeof BasePrismaClient>
-  ) => Layer.scoped(
+  ) => Layer.Layer<PrismaClient, never, never> = (...args) => Layer.effect(
     PrismaClient,
     Effect.gen(function* () {
-      const prisma = new BasePrismaClient(...args)
+      const prisma: BasePrismaClient = new BasePrismaClient(...args)
       yield* Effect.addFinalizer(() => Effect.promise(() => prisma.$disconnect()))
-      return { tx: prisma, client: prisma }
+      return prisma
     })
   )
 
@@ -470,25 +661,78 @@ export class PrismaClient extends Context.Tag("PrismaClient")<
    *   })
    * )
    */
-  static layerEffect = <R, E>(
-    optionsEffect: Effect.Effect<ConstructorParameters<typeof BasePrismaClient>[0], E, R>
-  ) => Layer.scoped(
+  static layerEffect: <R, E>(
+    optionsEffect: EffectType<ConstructorParameters<typeof BasePrismaClient>[0], E, R>
+  ) => Layer.Layer<PrismaClient, E, Exclude<R, Scope.Scope>> = (optionsEffect) => Layer.effect(
     PrismaClient,
     Effect.gen(function* () {
-      const options = yield* optionsEffect
-      const prisma = new BasePrismaClient(options)
+      const options: ConstructorParameters<typeof BasePrismaClient>[0] = yield* optionsEffect
+      const prisma: BasePrismaClient = new BasePrismaClient(options)
       yield* Effect.addFinalizer(() => Effect.promise(() => prisma.$disconnect()))
-      return { tx: prisma, client: prisma }
+      return prisma
     })
   )
 }
 
+/**
+ * Context tag for the transaction client within a transaction scope.
+ * This service is only available inside \`$transaction\` calls.
+ * Use \`Effect.serviceOption(PrismaTransactionClientService)\` to check if you're in a transaction.
+ */
+export class PrismaTransactionClientService extends ServiceMap.Service<PrismaTransactionClientService, PrismaNamespace.TransactionClient>()("PrismaTransactionClientService") {}
+
 // Re-export the custom error type for convenience
 export { ${customError.className} }
 
 // Use the user-provided error mapper
 const mapError = mapPrismaError
 
+/**
+ * Helper to get the current client - either the transaction client if in a transaction,
+ * or the root client if not. Uses Effect.serviceOption to detect transaction context.
+ */
+const clientOrTx = (client: BasePrismaClient) => Effect.map(
+  Effect.serviceOption(PrismaTransactionClientService),
+  Option.getOrElse(() => client),
+);
+
+/**
+ * Like Effect.acquireUseRelease, but allows the release function to fail.
+ * Release errors are surfaced in the error channel instead of becoming defects.
+ *
+ * Key properties:
+ * - The release function is always called, even if use fails
+ * - The release function is uninterruptible to ensure cleanup completes
+ * - Release errors are surfaced in the error channel, not as defects
+ */
+const acquireUseReleaseWithErrors = <A, E, R, A2, E2, R2, X, E3, R3>(
+  acquire: EffectType<A, E, R>,
+  use: (a: A) => EffectType<A2, E2, R2>,
+  release: (a: A, exit: Exit.Exit<A2, E2>) => EffectType<X, E3, R3>
+): EffectType<A2, E | E2 | E3, R | R2 | R3> =>
+  Effect.uninterruptibleMask((restore) =>
+    Effect.flatMap(acquire, (a) =>
+      Effect.flatMap(
+        Effect.exit(restore(use(a))),
+        (exit) =>
+          Effect.flatMap(
+            // Make release uninterruptible to ensure cleanup always completes
+            Effect.exit(release(a, exit)),
+            (releaseExit) => {
+              if (Exit.isFailure(releaseExit)) {
+                // Release failed - surface the release error
+                return releaseExit as any;
+              }
+              // Release succeeded - return the original use result
+              return exit as any;
+            }
+          )
+      )
+    )
+  );
+
+${prismaInterface}
+
 /**
  * Internal helper to begin a callback-free interactive transaction.
  * Returns a transaction client with $commit and $rollback methods.
@@ -501,8 +745,8 @@ const $begin = (
     timeout?: number
     isolationLevel?: PrismaNamespace.TransactionIsolationLevel
   }
-): Effect.Effect<FlatTransactionClient, ${customError.className}> =>
-  Effect.async<FlatTransactionClient, ${customError.className}>((resume) => {
+): EffectType<FlatTransactionClient, ${customError.className}> =>
+  Effect.callback<FlatTransactionClient, ${customError.className}>((resume) => {
     let setTxClient: (txClient: PrismaNamespace.TransactionClient) => void
     let commit: () => void
     let rollback: () => void
@@ -554,15 +798,14 @@ const $begin = (
  *   return user
  * })
  *
- * // Run with default layer (Prisma 6)
- * Effect.runPromise(program.pipe(Effect.provide(Prisma.Live)))
- *
- * // Or with custom options
+ * // Run with layer
  * Effect.runPromise(program.pipe(Effect.provide(Prisma.layer({ datasourceUrl: "..." }))))
  */
-export class Prisma extends Service<Prisma>()("Prisma", {
-  effect: Effect.gen(function* () {
-    return {
+const makePrismaService = Effect.gen(function* () {
+  const client = yield* PrismaClient;
+
+  const prismaService: IPrismaService = {
+      client,
       /**
        * Execute an effect within a database transaction.
        * All operations within the effect will be atomic - they either all succeed or all fail.
@@ -570,7 +813,8 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        * This implementation uses a callback-free transaction pattern that keeps the effect
        * running in the same fiber as the parent, preserving Ref, FiberRef, and Context access.
        *
-       * Options passed here override any defaults set via TransactionConfig layer.
+       * Uses default transaction options from PrismaClient constructor.
+       * For custom options, use \`$transactionWith\`.
        *
        * @example
        * const result = yield* prisma.$transaction(
@@ -580,47 +824,101 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        *     return user
        *   })
        * )
+       */
+      $transaction: ${enableTelemetry ? 'Effect.fn("Prisma.$transaction")' : "Effect.fnUntraced"}(function* (effect) {
+          const currentTx = yield* Effect.serviceOption(PrismaTransactionClientService);
+
+          // If already in a transaction, just run the effect
+          if (Option.isSome(currentTx)) {
+            // have to get this to pass the Exclude type
+            return yield* (effect as EffectType<
+            EffectSuccess<typeof effect>,
+            EffectError<typeof effect>,
+            Exclude<
+              EffectServices<typeof effect>,
+              PrismaTransactionClientService
+            >
+          >);
+          }
+
+          // Otherwise, start a new transaction
+          return yield* acquireUseReleaseWithErrors(
+            // Acquire: begin a new transaction with default options
+            $begin(client),
+
+            // Use: run the effect with the transaction client injected
+            (txClient) =>
+              effect.pipe(
+                Effect.provideService(PrismaTransactionClientService, txClient)
+              ),
+
+            // Release: commit on success, rollback on failure/interruption
+            (txClient, exit) =>
+              Exit.isSuccess(exit)
+                ? Effect.tryPromise({
+                    try: () => txClient.$commit(),
+                    catch: (error) => mapError(error, "$commit", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$commit"))
+                : Effect.tryPromise({
+                    try: () => txClient.$rollback(),
+                    catch: (error) => mapError(error, "$rollback", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+          );
+        }),
+
+      /**
+       * Execute an effect within a database transaction with custom options.
+       * All operations within the effect will be atomic - they either all succeed or all fail.
+       *
+       * This implementation uses a callback-free transaction pattern that keeps the effect
+       * running in the same fiber as the parent, preserving Ref, FiberRef, and Context access.
+       *
+       * Options passed here override any defaults set in PrismaClient constructor.
        *
        * @example
        * // Override default isolation level for this transaction
-       * const result = yield* prisma.$transaction(myEffect, {
-       *   isolationLevel: "ReadCommitted"
-       * })
+       * const result = yield* prisma.$transactionWith(
+       *   Effect.gen(function* () {
+       *     const user = yield* prisma.user.create({ data: { name: "Alice" } })
+       *     yield* prisma.post.create({ data: { title: "Hello", authorId: user.id } })
+       *     return user
+       *   }),
+       *   { isolationLevel: "ReadCommitted", timeout: 10000 }
+       * )
        */
-      $transaction: <R, E, A>(
-        effect: Effect.Effect<A, E, R>,
-        options?: TransactionOptions
-      ) =>
-        Effect.flatMap(
-          PrismaClient,
-          ({ client, tx }): Effect.Effect<A, E | ${customError.className}, R> => {
-            // If we're already in a transaction, just run the effect directly (no nesting)
-            const isRootClient = "$transaction" in tx
-            if (!isRootClient) {
-              return effect
-            }
+      $transactionWith: ${enableTelemetry ? 'Effect.fn("Prisma.$transactionWith")' : "Effect.fnUntraced"}(function* (effect, options) {
+          const currentTx = yield* Effect.serviceOption(PrismaTransactionClientService);
 
-            // Use acquireUseRelease to manage the transaction lifecycle
-            // This keeps everything in the same fiber, preserving Ref/FiberRef/Context
-            return Effect.acquireUseRelease(
-              // Acquire: begin a new transaction
-              // Prisma merges per-call options with constructor defaults internally
-              $begin(client, options),
-
-              // Use: run the effect with the transaction client injected
-              (txClient) =>
-                effect.pipe(
-                  Effect.provideService(PrismaClient, { tx: txClient, client })
-                ),
-
-              // Release: commit on success, rollback on failure/interruption
-              (txClient, exit) =>
-                Exit.isSuccess(exit)
-                  ? Effect.promise(() => txClient.$commit())
-                  : Effect.promise(() => txClient.$rollback())
-            )
+          // If already in a transaction, just run the effect
+          if (Option.isSome(currentTx)) {
+            return yield* effect;
           }
-        ),
+
+          // Otherwise, start a new transaction
+          return yield* acquireUseReleaseWithErrors(
+            // Acquire: begin a new transaction
+            // Prisma merges per-call options with constructor defaults internally
+            $begin(client, options),
+
+            // Use: run the effect with the transaction client injected
+            (txClient) =>
+              effect.pipe(
+                Effect.provideService(PrismaTransactionClientService, txClient)
+              ),
+
+            // Release: commit on success, rollback on failure/interruption
+            (txClient, exit) =>
+              Exit.isSuccess(exit)
+                ? Effect.tryPromise({
+                    try: () => txClient.$commit(),
+                    catch: (error) => mapError(error, "$commit", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+                : Effect.tryPromise({
+                    try: () => txClient.$rollback(),
+                    catch: (error) => mapError(error, "$rollback", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+          );
+        }),
 
       /**
        * Execute an effect in a NEW transaction, even if already inside a transaction.
@@ -634,6 +932,9 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        * ⚠️ WARNING: The isolated transaction can commit while the parent rolls back,
        * or vice versa. Use carefully to avoid data inconsistencies.
        *
+       * Uses default transaction options from PrismaClient constructor.
+       * For custom options, use \`$isolatedTransactionWith\`.
+       *
        * @example
        * yield* prisma.$transaction(
        *   Effect.gen(function* () {
@@ -646,46 +947,99 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        *   })
        * )
        */
-      $isolatedTransaction: <R, E, A>(
-        effect: Effect.Effect<A, E, R>,
-        options?: TransactionOptions
-      ) =>
-        Effect.flatMap(
-          PrismaClient,
-          ({ client }): Effect.Effect<A, E | ${customError.className}, R> => {
-            // Always use the root client to create a fresh transaction
-            return Effect.acquireUseRelease(
-              $begin(client, options),
-              (txClient) =>
-                effect.pipe(
-                  Effect.provideService(PrismaClient, { tx: txClient, client })
-                ),
-              (txClient, exit) =>
-                Exit.isSuccess(exit)
-                  ? Effect.promise(() => txClient.$commit())
-                  : Effect.promise(() => txClient.$rollback())
-            )
-          }
-        ),
+      $isolatedTransaction: ${enableTelemetry ? 'Effect.fn("Prisma.$isolatedTransaction")' : "Effect.fnUntraced"}(function* (effect) {
+          // Always create a fresh transaction
+          return yield* acquireUseReleaseWithErrors(
+            $begin(client),
+            (txClient) =>
+              effect.pipe(
+                Effect.provideService(PrismaTransactionClientService, txClient)
+              ),
+            (txClient, exit) =>
+              Exit.isSuccess(exit)
+                ? Effect.tryPromise({
+                    try: () => txClient.$commit(),
+                    catch: (error) => mapError(error, "$commit", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+                : Effect.tryPromise({
+                    try: () => txClient.$rollback(),
+                    catch: (error) => mapError(error, "$rollback", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+          );
+        }),
+
+      /**
+       * Execute an effect in a NEW transaction with custom options, even if already inside a transaction.
+       * Unlike \`$transaction\`, this always creates a fresh, independent transaction.
+       *
+       * Use this for operations that should NOT be rolled back with the parent:
+       * - Audit logging that must persist even if main operation fails
+       * - Saga pattern where each step has independent commit/rollback
+       * - Background job queuing that should commit immediately
+       *
+       * ⚠️ WARNING: The isolated transaction can commit while the parent rolls back,
+       * or vice versa. Use carefully to avoid data inconsistencies.
+       *
+       * Options passed here override any defaults set in PrismaClient constructor.
+       *
+       * @example
+       * yield* prisma.$transaction(
+       *   Effect.gen(function* () {
+       *     // This audit log commits independently with custom isolation level
+       *     yield* prisma.$isolatedTransactionWith(
+       *       prisma.auditLog.create({ data: { action: "attempt", userId } }),
+       *       { isolationLevel: "Serializable" }
+       *     )
+       *     // Main operation - if this fails, audit log is still committed
+       *     yield* prisma.user.delete({ where: { id: userId } })
+       *   })
+       * )
+       */
+      $isolatedTransactionWith: ${enableTelemetry ? 'Effect.fn("Prisma.$isolatedTransactionWith")' : "Effect.fnUntraced"}(function* (effect, options) {
+          // Always create a fresh transaction
+          return yield* acquireUseReleaseWithErrors(
+            $begin(client, options),
+            (txClient) =>
+              effect.pipe(
+                Effect.provideService(PrismaTransactionClientService, txClient)
+              ),
+            (txClient, exit) =>
+              Exit.isSuccess(exit)
+                ? Effect.tryPromise({
+                    try: () => txClient.$commit(),
+                    catch: (error) => mapError(error, "$commit", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+                : Effect.tryPromise({
+                    try: () => txClient.$rollback(),
+                    catch: (error) => mapError(error, "$rollback", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+          );
+        }),
       ${rawSqlOperations}
 
       ${modelOperations}
-    }
-  })
-}) {
+  };
+
+  return prismaService;
+});
+
+export class Prisma extends ServiceMap.Service<Prisma, IPrismaService>()("Prisma") {
+  /**
+   * Effect that constructs the Prisma service.
+   * Used internally by layer constructors.
+   */
+  static make: EffectType<IPrismaService, never, PrismaClient> = makePrismaService;
+  static Default: Layer.Layer<Prisma, never, PrismaClient> = Layer.effect(Prisma, this.make);
+
   /**
    * Create a complete Prisma layer with the given PrismaClient options.
    * This is the recommended way to create a Prisma layer - it bundles both
    * PrismaClient and Prisma service together.
    *
    * Pass options directly - the signature matches PrismaClient's constructor.
-   * Prisma 6: all options are optional
    * Prisma 7: requires either \`adapter\` or \`accelerateUrl\`
    *
    * @example
-   * // Prisma 6
-   * const MainLayer = Prisma.layer({ datasourceUrl: process.env.DATABASE_URL })
-   *
    * // Prisma 7 with adapter
    * const MainLayer = Prisma.layer({ adapter: myAdapter })
    *
@@ -698,9 +1052,11 @@ export class Prisma extends Service<Prisma>()("Prisma", {
    * // Use it
    * Effect.runPromise(program.pipe(Effect.provide(MainLayer)))
    */
-  static layer = (
+  static layer: (
     ...args: ConstructorParameters<typeof BasePrismaClient>
-  ) => Layer.merge(PrismaClient.layer(...args), Prisma.Default)
+  ) => Layer.Layer<Prisma | PrismaClient, never, never> = (...args) => this.Default.pipe(
+    Layer.provideMerge(PrismaClient.layer(...args))
+  );
 
   /**
    * Create a complete Prisma layer where PrismaClient options are computed via an Effect.
@@ -725,23 +1081,42 @@ export class Prisma extends Service<Prisma>()("Prisma", {
    *   })
    * )
    */
-  static layerEffect = <R, E>(
-    optionsEffect: Effect.Effect<ConstructorParameters<typeof BasePrismaClient>[0], E, R>
-  ) => Layer.merge(PrismaClient.layerEffect(optionsEffect), Prisma.Default)
-
+  static layerEffect: <R, E>(
+    optionsEffect: EffectType<ConstructorParameters<typeof BasePrismaClient>[0], E, R>
+  ) => Layer.Layer<Prisma | PrismaClient, E, Exclude<R, Scope.Scope>> = (optionsEffect) => this.Default.pipe(
+    Layer.provideMerge(PrismaClient.layerEffect(optionsEffect))
+  );
 }
+
 `;
 }
 /**
  * Generate service with default tagged error classes.
  * Operations have per-operation error types for fine-grained error handling.
  */
-function generateDefaultErrorService(clientImportPath, rawSqlOperations, modelOperations) {
+function generateDefaultErrorService(clientImportPath, rawSqlOperations, modelTypeAliases, prismaInterface, modelOperations, enableTelemetry) {
+    const _errorType = "PrismaError";
     return `${header}
-import { Context, Data, Effect, Exit, Layer } from "effect"
-import { Service } from "effect/Effect"
+import { Data, Effect, Exit, Layer, Option, Scope, ServiceMap } from "effect"
+import type { Effect as EffectType, Error as EffectError, Services as EffectServices, Success as EffectSuccess } from "effect/Effect"
 import { Prisma as PrismaNamespace, PrismaClient as BasePrismaClient } from "${clientImportPath}"
 
+// Create local reference to error class for proper type narrowing
+const PrismaClientKnownRequestError = PrismaNamespace.PrismaClientKnownRequestError
+
+// Type guard function to help TypeScript narrow the error type
+// This is needed for Prisma 7 which re-exports error classes from external packages
+function isPrismaClientKnownRequestError(error: unknown): error is PrismaNamespace.PrismaClientKnownRequestError {
+  return error instanceof PrismaClientKnownRequestError
+}
+
+// ============================================================================
+// Type aliases for model operations (performance optimization)
+// These are computed once and reused, reducing TypeScript's type-checking workload
+// ============================================================================
+
+${modelTypeAliases}
+
 // Symbol used to identify intentional rollbacks vs actual errors
 const ROLLBACK = Symbol.for("prisma.effect.rollback")
 
@@ -760,42 +1135,28 @@ type TransactionOptions = {
 
 /**
  * Context tag for the Prisma client instance.
- * Holds the transaction client (tx) and root client.
  *
  * Use \`PrismaClient.layer()\` or \`PrismaClient.layerEffect()\` to create a layer.
  *
  * @example
- * // Prisma 6 - all options are optional
- * const layer = PrismaClient.layer({ datasourceUrl: "..." })
- *
  * // Prisma 7 - adapter or accelerateUrl is required
  * const layer = PrismaClient.layer({ adapter: myAdapter })
  *
  * // With transaction options (Prisma uses these as defaults for $transaction)
  * const layer = PrismaClient.layer({
- *   adapter: myAdapter,  // or datasourceUrl for Prisma 6
+ *   adapter: myAdapter,
  *   transactionOptions: { isolationLevel: "Serializable", timeout: 10000 }
  * })
  */
-export class PrismaClient extends Context.Tag("PrismaClient")<
-  PrismaClient,
-  {
-    tx: BasePrismaClient | PrismaNamespace.TransactionClient
-    client: BasePrismaClient
-  }
->() {
+export class PrismaClient extends ServiceMap.Service<PrismaClient, BasePrismaClient>()("PrismaClient") {
   /**
    * Create a PrismaClient layer with the given options.
    * The client will be automatically disconnected when the layer scope ends.
    *
    * Pass options directly - the signature matches PrismaClient's constructor.
-   * Prisma 6: all options are optional
    * Prisma 7: requires either \`adapter\` or \`accelerateUrl\`
    *
    * @example
-   * // Prisma 6
-   * const layer = PrismaClient.layer({ datasourceUrl: process.env.DATABASE_URL })
-   *
    * // Prisma 7 with adapter
    * const layer = PrismaClient.layer({ adapter: myAdapter })
    *
@@ -805,14 +1166,14 @@ export class PrismaClient extends Context.Tag("PrismaClient")<
    *   transactionOptions: { isolationLevel: "Serializable" }
    * })
    */
-  static layer = (
+  static layer: (
     ...args: ConstructorParameters<typeof BasePrismaClient>
-  ) => Layer.scoped(
+  ) => Layer.Layer<PrismaClient, never, never> = (...args) => Layer.effect(
     PrismaClient,
     Effect.gen(function* () {
-      const prisma = new BasePrismaClient(...args)
+      const prisma: BasePrismaClient = new BasePrismaClient(...args)
       yield* Effect.addFinalizer(() => Effect.promise(() => prisma.$disconnect()))
-      return { tx: prisma, client: prisma }
+      return prisma
     })
   )
 
@@ -840,19 +1201,26 @@ export class PrismaClient extends Context.Tag("PrismaClient")<
    *   })
    * )
    */
-  static layerEffect = <R, E>(
-    optionsEffect: Effect.Effect<ConstructorParameters<typeof BasePrismaClient>[0], E, R>
-  ) => Layer.scoped(
+  static layerEffect: <R, E>(
+    optionsEffect: EffectType<ConstructorParameters<typeof BasePrismaClient>[0], E, R>
+  ) => Layer.Layer<PrismaClient, E, Exclude<R, Scope.Scope>> = (optionsEffect) => Layer.effect(
     PrismaClient,
     Effect.gen(function* () {
-      const options = yield* optionsEffect
-      const prisma = new BasePrismaClient(options)
+      const options: ConstructorParameters<typeof BasePrismaClient>[0] = yield* optionsEffect
+      const prisma: BasePrismaClient = new BasePrismaClient(options)
       yield* Effect.addFinalizer(() => Effect.promise(() => prisma.$disconnect()))
-      return { tx: prisma, client: prisma }
+      return prisma
     })
   )
 }
 
+/**
+ * Context tag for the transaction client within a transaction scope.
+ * This service is only available inside \`$transaction\` calls.
+ * Use \`Effect.serviceOption(PrismaTransactionClientService)\` to check if you're in a transaction.
+ */
+export class PrismaTransactionClientService extends ServiceMap.Service<PrismaTransactionClientService, PrismaNamespace.TransactionClient>()("PrismaTransactionClientService") {}
+
 export class PrismaUniqueConstraintError extends Data.TaggedError("PrismaUniqueConstraintError")<{
   cause: PrismaNamespace.PrismaClientKnownRequestError
   operation: string
@@ -998,8 +1366,9 @@ export type PrismaError =
 
 // Generic mapper for raw operations and fallback
 const mapError = (error: unknown, operation: string, model: string): PrismaError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
+  if (isPrismaClientKnownRequestError(error)) {
+    const knownError = error;
+    switch (knownError.code) {
       case "P2000":
         return new PrismaValueTooLongError({ cause: error, operation, model });
       case "P2002":
@@ -1038,8 +1407,9 @@ const mapError = (error: unknown, operation: string, model: string): PrismaError
 
 // Create, Upsert
 const mapCreateError = (error: unknown, operation: string, model: string): PrismaCreateError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
+  if (isPrismaClientKnownRequestError(error)) {
+    const knownError = error;
+    switch (knownError.code) {
       case "P2000":
         return new PrismaValueTooLongError({ cause: error, operation, model });
       case "P2002":
@@ -1071,8 +1441,9 @@ const mapCreateError = (error: unknown, operation: string, model: string): Prism
 
 // Update
 const mapUpdateError = (error: unknown, operation: string, model: string): PrismaUpdateError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
+  if (isPrismaClientKnownRequestError(error)) {
+    const knownError = error;
+    switch (knownError.code) {
       case "P2000":
         return new PrismaValueTooLongError({ cause: error, operation, model });
       case "P2002":
@@ -1108,8 +1479,9 @@ const mapUpdateError = (error: unknown, operation: string, model: string): Prism
 
 // Delete
 const mapDeleteError = (error: unknown, operation: string, model: string): PrismaDeleteError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
+  if (isPrismaClientKnownRequestError(error)) {
+    const knownError = error;
+    switch (knownError.code) {
       case "P2003":
         return new PrismaForeignKeyConstraintError({ cause: error, operation, model });
       case "P2014":
@@ -1127,8 +1499,9 @@ const mapDeleteError = (error: unknown, operation: string, model: string): Prism
 
 // FindOrThrow
 const mapFindOrThrowError = (error: unknown, operation: string, model: string): PrismaFindOrThrowError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
+  if (isPrismaClientKnownRequestError(error)) {
+    const knownError = error;
+    switch (knownError.code) {
       case "P2024":
         return new PrismaConnectionError({ cause: error, operation, model });
       case "P2025":
@@ -1140,8 +1513,9 @@ const mapFindOrThrowError = (error: unknown, operation: string, model: string):
 
 // Find
 const mapFindError = (error: unknown, operation: string, model: string): PrismaFindError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
+  if (isPrismaClientKnownRequestError(error)) {
+    const knownError = error;
+    switch (knownError.code) {
       case "P2024":
         return new PrismaConnectionError({ cause: error, operation, model });
     }
@@ -1151,8 +1525,9 @@ const mapFindError = (error: unknown, operation: string, model: string): PrismaF
 
 // DeleteMany
 const mapDeleteManyError = (error: unknown, operation: string, model: string): PrismaDeleteManyError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
+  if (isPrismaClientKnownRequestError(error)) {
+    const knownError = error;
+    switch (knownError.code) {
       case "P2003":
         return new PrismaForeignKeyConstraintError({ cause: error, operation, model });
       case "P2014":
@@ -1168,8 +1543,9 @@ const mapDeleteManyError = (error: unknown, operation: string, model: string): P
 
 // UpdateMany
 const mapUpdateManyError = (error: unknown, operation: string, model: string): PrismaUpdateManyError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
+  if (isPrismaClientKnownRequestError(error)) {
+    const knownError = error;
+    switch (knownError.code) {
       case "P2000":
         return new PrismaValueTooLongError({ cause: error, operation, model });
       case "P2002":
@@ -1196,6 +1572,52 @@ const mapUpdateManyError = (error: unknown, operation: string, model: string): P
   throw error;
 }
 
+/**
+ * Helper to get the current client - either the transaction client if in a transaction,
+ * or the root client if not. Uses Effect.serviceOption to detect transaction context.
+ */
+const clientOrTx = (client: BasePrismaClient) => Effect.map(
+  Effect.serviceOption(PrismaTransactionClientService),
+  Option.getOrElse(() => client),
+);
+
+/**
+ * Like Effect.acquireUseRelease, but allows the release function to fail.
+ * Release errors are surfaced in the error channel instead of becoming defects.
+ *
+ * Key properties:
+ * - The release function is always called, even if use fails
+ * - The release function is uninterruptible to ensure cleanup completes
+ * - Release errors are surfaced in the error channel, not as defects
+ */
+const acquireUseReleaseWithErrors = <A, E, R, A2, E2, R2, X, E3, R3>(
+  acquire: EffectType<A, E, R>,
+  use: (a: A) => EffectType<A2, E2, R2>,
+  release: (a: A, exit: Exit.Exit<A2, E2>) => EffectType<X, E3, R3>
+): EffectType<A2, E | E2 | E3, R | R2 | R3> =>
+  Effect.uninterruptibleMask((restore) =>
+    Effect.flatMap(acquire, (a) =>
+      Effect.flatMap(
+        Effect.exit(restore(use(a))),
+        (exit) =>
+          Effect.flatMap(
+            // Make release uninterruptible to ensure cleanup always completes
+            Effect.exit(Effect.uninterruptible(release(a, exit))),
+            (releaseExit) => {
+              if (Exit.isFailure(releaseExit)) {
+                // Release failed - surface the release error
+                return releaseExit as any;
+              }
+              // Release succeeded - return the original use result
+              return exit as any;
+            }
+          )
+      )
+    )
+  );
+
+${prismaInterface}
+
 /**
  * Internal helper to begin a callback-free interactive transaction.
  * Returns a transaction client with $commit and $rollback methods.
@@ -1208,8 +1630,8 @@ const $begin = (
     timeout?: number
     isolationLevel?: PrismaNamespace.TransactionIsolationLevel
   }
-): Effect.Effect<FlatTransactionClient, PrismaError> =>
-  Effect.async<FlatTransactionClient, PrismaError>((resume) => {
+): EffectType<FlatTransactionClient, PrismaError> =>
+  Effect.callback<FlatTransactionClient, PrismaError>((resume) => {
     let setTxClient: (txClient: PrismaNamespace.TransactionClient) => void
     let commit: () => void
     let rollback: () => void
@@ -1261,15 +1683,14 @@ const $begin = (
  *   return user
  * })
  *
- * // Run with default layer (Prisma 6)
- * Effect.runPromise(program.pipe(Effect.provide(Prisma.Live)))
- *
- * // Or with custom options
+ * // Run with layer
  * Effect.runPromise(program.pipe(Effect.provide(Prisma.layer({ datasourceUrl: "..." }))))
  */
-export class Prisma extends Service<Prisma>()("Prisma", {
-  effect: Effect.gen(function* () {
-    return {
+const makePrismaService = Effect.gen(function* () {
+  const client = yield* PrismaClient;
+
+  const prismaService: IPrismaService = {
+      client,
       /**
        * Execute an effect within a database transaction.
        * All operations within the effect will be atomic - they either all succeed or all fail.
@@ -1277,7 +1698,8 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        * This implementation uses a callback-free transaction pattern that keeps the effect
        * running in the same fiber as the parent, preserving Ref, FiberRef, and Context access.
        *
-       * Options passed here override any defaults set via transactionOptions in the layer.
+       * Uses default transaction options from PrismaClient constructor.
+       * For custom options, use \`$transactionWith\`.
        *
        * @example
        * const result = yield* prisma.$transaction(
@@ -1287,47 +1709,100 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        *     return user
        *   })
        * )
+       */
+      $transaction: ${enableTelemetry ? 'Effect.fn("Prisma.$transaction")' : "Effect.fnUntraced"}(function* (effect) {
+          const currentTx = yield* Effect.serviceOption(PrismaTransactionClientService);
+
+          // If already in a transaction, just run the effect
+          if (Option.isSome(currentTx)) {
+            return yield* (effect as EffectType<
+            EffectSuccess<typeof effect>,
+            EffectError<typeof effect>,
+            Exclude<
+              EffectServices<typeof effect>,
+              PrismaTransactionClientService
+            >
+          >);
+          }
+
+          // Otherwise, start a new transaction
+          return yield* acquireUseReleaseWithErrors(
+            // Acquire: begin a new transaction with default options
+            $begin(client),
+
+            // Use: run the effect with the transaction client injected
+            (txClient) =>
+              effect.pipe(
+                Effect.provideService(PrismaTransactionClientService, txClient)
+              ),
+
+            // Release: commit on success, rollback on failure/interruption
+            (txClient, exit) =>
+              Exit.isSuccess(exit)
+                ? Effect.tryPromise({
+                    try: () => txClient.$commit(),
+                    catch: (error) => mapError(error, "$commit", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+                : Effect.tryPromise({
+                    try: () => txClient.$rollback(),
+                    catch: (error) => mapError(error, "$rollback", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+          );
+        }),
+
+      /**
+       * Execute an effect within a database transaction with custom options.
+       * All operations within the effect will be atomic - they either all succeed or all fail.
+       *
+       * This implementation uses a callback-free transaction pattern that keeps the effect
+       * running in the same fiber as the parent, preserving Ref, FiberRef, and Context access.
+       *
+       * Options passed here override any defaults set in PrismaClient constructor.
        *
        * @example
        * // Override default isolation level for this transaction
-       * const result = yield* prisma.$transaction(myEffect, {
-       *   isolationLevel: "ReadCommitted"
-       * })
+       * const result = yield* prisma.$transactionWith(
+       *   Effect.gen(function* () {
+       *     const user = yield* prisma.user.create({ data: { name: "Alice" } })
+       *     yield* prisma.post.create({ data: { title: "Hello", authorId: user.id } })
+       *     return user
+       *   }),
+       *   { isolationLevel: "ReadCommitted", timeout: 10000 }
+       * )
        */
-      $transaction: <R, E, A>(
-        effect: Effect.Effect<A, E, R>,
-        options?: TransactionOptions
-      ) =>
-        Effect.flatMap(
-          PrismaClient,
-          ({ client, tx }): Effect.Effect<A, E | PrismaError, R> => {
-            // If we're already in a transaction, just run the effect directly (no nesting)
-            const isRootClient = "$transaction" in tx
-            if (!isRootClient) {
-              return effect
-            }
+      $transactionWith: ${enableTelemetry ? 'Effect.fn("Prisma.$transactionWith")' : "Effect.fnUntraced"}(function* (effect, options) {
+          const currentTx = yield* Effect.serviceOption(PrismaTransactionClientService);
 
-            // Use acquireUseRelease to manage the transaction lifecycle
-            // This keeps everything in the same fiber, preserving Ref/FiberRef/Context
-            return Effect.acquireUseRelease(
-              // Acquire: begin a new transaction
-              // Prisma merges per-call options with constructor defaults internally
-              $begin(client, options),
-
-              // Use: run the effect with the transaction client injected
-              (txClient) =>
-                effect.pipe(
-                  Effect.provideService(PrismaClient, { tx: txClient, client })
-                ),
-
-              // Release: commit on success, rollback on failure/interruption
-              (txClient, exit) =>
-                Exit.isSuccess(exit)
-                  ? Effect.promise(() => txClient.$commit())
-                  : Effect.promise(() => txClient.$rollback())
-            )
+          // If already in a transaction, just run the effect
+          if (Option.isSome(currentTx)) {
+            return yield* effect;
           }
-        ),
+
+          // Otherwise, start a new transaction
+          return yield* acquireUseReleaseWithErrors(
+            // Acquire: begin a new transaction
+            // Prisma merges per-call options with constructor defaults internally
+            $begin(client, options),
+
+            // Use: run the effect with the transaction client injected
+            (txClient) =>
+              effect.pipe(
+                Effect.provideService(PrismaTransactionClientService, txClient)
+              ),
+
+            // Release: commit on success, rollback on failure/interruption
+            (txClient, exit) =>
+              Exit.isSuccess(exit)
+                ? Effect.tryPromise({
+                    try: () => txClient.$commit(),
+                    catch: (error) => mapError(error, "$commit", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+                : Effect.tryPromise({
+                    try: () => txClient.$rollback(),
+                    catch: (error) => mapError(error, "$rollback", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+          );
+        }),
 
       /**
        * Execute an effect in a NEW transaction, even if already inside a transaction.
@@ -1341,6 +1816,9 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        * ⚠️ WARNING: The isolated transaction can commit while the parent rolls back,
        * or vice versa. Use carefully to avoid data inconsistencies.
        *
+       * Uses default transaction options from PrismaClient constructor.
+       * For custom options, use \`$isolatedTransactionWith\`.
+       *
        * @example
        * yield* prisma.$transaction(
        *   Effect.gen(function* () {
@@ -1353,46 +1831,99 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        *   })
        * )
        */
-      $isolatedTransaction: <R, E, A>(
-        effect: Effect.Effect<A, E, R>,
-        options?: TransactionOptions
-      ) =>
-        Effect.flatMap(
-          PrismaClient,
-          ({ client }): Effect.Effect<A, E | PrismaError, R> => {
-            // Always use the root client to create a fresh transaction
-            return Effect.acquireUseRelease(
-              $begin(client, options),
-              (txClient) =>
-                effect.pipe(
-                  Effect.provideService(PrismaClient, { tx: txClient, client })
-                ),
-              (txClient, exit) =>
-                Exit.isSuccess(exit)
-                  ? Effect.promise(() => txClient.$commit())
-                  : Effect.promise(() => txClient.$rollback())
-            )
-          }
-        ),
+      $isolatedTransaction: ${enableTelemetry ? 'Effect.fn("Prisma.$isolatedTransaction")' : "Effect.fnUntraced"}(function* (effect) {
+          // Always create a fresh transaction
+          return yield* acquireUseReleaseWithErrors(
+            $begin(client),
+            (txClient) =>
+              effect.pipe(
+                Effect.provideService(PrismaTransactionClientService, txClient)
+              ),
+            (txClient, exit) =>
+              Exit.isSuccess(exit)
+                ? Effect.tryPromise({
+                    try: () => txClient.$commit(),
+                    catch: (error) => mapError(error, "$commit", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+                : Effect.tryPromise({
+                    try: () => txClient.$rollback(),
+                    catch: (error) => mapError(error, "$rollback", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+          );
+        }),
+
+      /**
+       * Execute an effect in a NEW transaction with custom options, even if already inside a transaction.
+       * Unlike \`$transaction\`, this always creates a fresh, independent transaction.
+       *
+       * Use this for operations that should NOT be rolled back with the parent:
+       * - Audit logging that must persist even if main operation fails
+       * - Saga pattern where each step has independent commit/rollback
+       * - Background job queuing that should commit immediately
+       *
+       * ⚠️ WARNING: The isolated transaction can commit while the parent rolls back,
+       * or vice versa. Use carefully to avoid data inconsistencies.
+       *
+       * Options passed here override any defaults set in PrismaClient constructor.
+       *
+       * @example
+       * yield* prisma.$transaction(
+       *   Effect.gen(function* () {
+       *     // This audit log commits independently with custom isolation level
+       *     yield* prisma.$isolatedTransactionWith(
+       *       prisma.auditLog.create({ data: { action: "attempt", userId } }),
+       *       { isolationLevel: "Serializable" }
+       *     )
+       *     // Main operation - if this fails, audit log is still committed
+       *     yield* prisma.user.delete({ where: { id: userId } })
+       *   })
+       * )
+       */
+      $isolatedTransactionWith: ${enableTelemetry ? 'Effect.fn("Prisma.$isolatedTransactionWith")' : "Effect.fnUntraced"}(function* (effect, options) {
+          // Always create a fresh transaction
+          return yield* acquireUseReleaseWithErrors(
+            $begin(client, options),
+            (txClient) =>
+              effect.pipe(
+                Effect.provideService(PrismaTransactionClientService, txClient)
+              ),
+            (txClient, exit) =>
+              Exit.isSuccess(exit)
+                ? Effect.tryPromise({
+                    try: () => txClient.$commit(),
+                    catch: (error) => mapError(error, "$commit", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+                : Effect.tryPromise({
+                    try: () => txClient.$rollback(),
+                    catch: (error) => mapError(error, "$rollback", "Prisma")
+                  }).pipe(Effect.withSpan("txClient.$rollback"))
+          );
+        }),
       ${rawSqlOperations}
 
       ${modelOperations}
-    }
-  })
-}) {
+  };
+
+  return prismaService;
+});
+
+export class Prisma extends ServiceMap.Service<Prisma, IPrismaService>()("Prisma") {
+  /**
+   * Effect that constructs the Prisma service.
+   * Used internally by layer constructors.
+   */
+  static make: EffectType<IPrismaService, never, PrismaClient> = makePrismaService;
+  static Default: Layer.Layer<Prisma, never, PrismaClient> = Layer.effect(Prisma, this.make);
+
   /**
    * Create a complete Prisma layer with the given PrismaClient options.
    * This is the recommended way to create a Prisma layer - it bundles both
    * PrismaClient and Prisma service together.
    *
    * Pass options directly - the signature matches PrismaClient's constructor.
-   * Prisma 6: all options are optional
    * Prisma 7: requires either \`adapter\` or \`accelerateUrl\`
    *
    * @example
-   * // Prisma 6
-   * const MainLayer = Prisma.layer({ datasourceUrl: process.env.DATABASE_URL })
-   *
    * // Prisma 7 with adapter
    * const MainLayer = Prisma.layer({ adapter: myAdapter })
    *
@@ -1405,9 +1936,11 @@ export class Prisma extends Service<Prisma>()("Prisma", {
    * // Use it
    * Effect.runPromise(program.pipe(Effect.provide(MainLayer)))
    */
-  static layer = (
+  static layer: (
     ...args: ConstructorParameters<typeof BasePrismaClient>
-  ) => Layer.merge(PrismaClient.layer(...args), Prisma.Default)
+  ) => Layer.Layer<Prisma | PrismaClient, never, never> = (...args) => this.Default.pipe(
+    Layer.provideMerge(PrismaClient.layer(...args))
+  );
 
   /**
    * Create a complete Prisma layer where PrismaClient options are computed via an Effect.
@@ -1432,10 +1965,12 @@ export class Prisma extends Service<Prisma>()("Prisma", {
    *   })
    * )
    */
-  static layerEffect = <R, E>(
-    optionsEffect: Effect.Effect<ConstructorParameters<typeof BasePrismaClient>[0], E, R>
-  ) => Layer.merge(PrismaClient.layerEffect(optionsEffect), Prisma.Default)
-
+  static layerEffect: <R, E>(
+    optionsEffect: EffectType<ConstructorParameters<typeof BasePrismaClient>[0], E, R>
+  ) => Layer.Layer<Prisma | PrismaClient, E, Exclude<R, Scope.Scope>> = (optionsEffect) => this.Default.pipe(
+    Layer.provideMerge(PrismaClient.layerEffect(optionsEffect))
+  );
 }
+
 `;
 }