@prisma/client-generator-ts 6.6.0-dev.95 → 6.6.0-dev.97

package/dist/index.mjs

@@ -2220,10 +2220,9 @@ import {
   assertNever as assertNever3,
   ClientEngineType as ClientEngineType3,
   getClientEngineType as getClientEngineType2,
-  pathToPosix as pathToPosix4,
+  pathToPosix as pathToPosix3,
   setClassName
 } from "@prisma/internals";
-import paths from "env-paths";
 import { glob } from "fast-glob";
 
 // ../../node_modules/.pnpm/kleur@4.1.5/node_modules/kleur/colors.mjs
@@ -2277,6 +2276,75 @@ var bgWhite = init(47, 49);
 // src/generateClient.ts
 import pkgUp from "pkg-up";
 
+// src/file-extensions.ts
+import { capitalize as capitalize2 } from "@prisma/client-common";
+var expectedGeneratedFileExtensions = ["ts", "mts", "cts"];
+var expectedImportFileExtensions = ["", "ts", "mts", "cts", "js", "mjs", "cjs"];
+function validateFileExtension(extension, kind, recommended) {
+  if (!recommended.includes(extension) && !process.env.PRISMA_DISABLE_WARNINGS) {
+    console.warn(
+      `${capitalize2(kind)} file extension ${JSON.stringify(
+        extension
+      )} is unexpected and may be a mistake. Expected one of: ${recommended.map((ext) => JSON.stringify(ext)).join(", ")}`
+    );
+  }
+  return extension;
+}
+function parseFileExtensionFromUnknown(extension, kind, recommended) {
+  if (typeof extension === "string") {
+    return validateFileExtension(extension, kind, recommended);
+  }
+  throw new Error(`Invalid ${kind} file extension: ${JSON.stringify(extension)}, expected a string`);
+}
+function parseGeneratedFileExtension(extension) {
+  return parseFileExtensionFromUnknown(extension, "generated", expectedGeneratedFileExtensions);
+}
+function parseImportFileExtension(extension) {
+  return parseFileExtensionFromUnknown(extension, "import", expectedImportFileExtensions);
+}
+function extensionToSuffix(extension) {
+  return extension === "" ? "" : `.${extension}`;
+}
+function generatedFileNameMapper(generatedFileExtension) {
+  return (baseName) => baseName + extensionToSuffix(generatedFileExtension);
+}
+function importFileNameMapper(importFileExtension) {
+  return (baseName) => baseName + extensionToSuffix(importFileExtension);
+}
+function inferImportFileExtension({
+  tsconfig,
+  generatedFileExtension
+}) {
+  if (tsconfig) {
+    return inferImportFileExtensionFromTsConfig(tsconfig, generatedFileExtension);
+  }
+  return generatedFileExtension;
+}
+function inferImportFileExtensionFromTsConfig(tsconfig, generatedFileExtension) {
+  if (tsconfig.compilerOptions?.allowImportingTsExtensions || // @ts-expect-error `get-tsconfig` types don't yet include the new option introduced in TypeScript 5.7
+  tsconfig.compilerOptions?.rewriteRelativeImportExtensions) {
+    return generatedFileExtension;
+  }
+  const moduleResolution = tsconfig.compilerOptions?.moduleResolution?.toLowerCase();
+  const module = tsconfig.compilerOptions?.module?.toLowerCase();
+  if (moduleResolution !== void 0 && moduleResolution !== "classic" && module === "commonjs") {
+    return "";
+  }
+  return matchingJsExtension(generatedFileExtension);
+}
+function matchingJsExtension(generatedFileExtension) {
+  switch (generatedFileExtension) {
+    case "ts":
+      return "js";
+    case "mts":
+      return "mjs";
+    case "cts":
+      return "cjs";
+    default:
+      return generatedFileExtension;
+  }
+}
+
 // src/getDMMF.ts
 import { getDMMF as getRawDMMF } from "@prisma/internals";
 function getPrismaClientDMMF(dmmf) {
@@ -2306,42 +2374,22 @@ var Enum = class {
   isStrictEnum() {
     return this.useNamespace && strictEnumNames.includes(this.type.name);
   }
-  toJS() {
-    const { type } = this;
-    const enumVariants = `{
-${indent(type.values.map((v) => `${v}: ${this.getValueJS(v)}`).join(",\n"), TAB_SIZE)}
-}`;
-    const enumBody = this.isStrictEnum() ? `makeStrictEnum(${enumVariants})` : enumVariants;
-    return this.useNamespace ? `exports.Prisma.${type.name} = ${enumBody};` : `exports.${type.name} = exports.$Enums.${type.name} = ${enumBody};`;
-  }
-  getValueJS(value) {
-    return this.isObjectEnum() ? `Prisma.${value}` : `'${value}'`;
-  }
   toTS() {
     const { type } = this;
-    return `export const ${type.name}: {
-${indent(type.values.map((v) => `${v}: ${this.getValueTS(v)}`).join(",\n"), TAB_SIZE)}
-};
+    const enumVariants = `{
+${indent(type.values.map((v) => `${v}: ${this.getValue(v)}`).join(",\n"), TAB_SIZE)}
+} as const`;
+    const enumBody = this.isStrictEnum() ? `runtime.makeStrictEnum(${enumVariants})` : enumVariants;
+    return `export const ${type.name} = ${enumBody}
 
 export type ${type.name} = (typeof ${type.name})[keyof typeof ${type.name}]
 `;
   }
-  getValueTS(value) {
-    return this.isObjectEnum() ? `typeof ${value}` : `'${value}'`;
+  getValue(value) {
+    return this.isObjectEnum() ? value : `'${value}'`;
   }
 };
 
-// src/TSClient/Generable.ts
-function JS(gen) {
-  return gen.toJS?.() ?? "";
-}
-function BrowserJS(gen) {
-  return gen.toBrowserJS?.() ?? "";
-}
-function TS(gen) {
-  return gen.toTS();
-}
-
 // src/TSClient/Input.ts
 import { uniqueBy } from "@prisma/client-common";
 import * as ts2 from "@prisma/ts-builders";
@@ -2379,28 +2427,28 @@ function getOmitName(modelName) {
   return `${modelName}Omit`;
 }
 function getAggregateName(modelName) {
-  return `Aggregate${capitalize2(modelName)}`;
+  return `Aggregate${capitalize3(modelName)}`;
 }
 function getGroupByName(modelName) {
-  return `${capitalize2(modelName)}GroupByOutputType`;
+  return `${capitalize3(modelName)}GroupByOutputType`;
 }
 function getAvgAggregateName(modelName) {
-  return `${capitalize2(modelName)}AvgAggregateOutputType`;
+  return `${capitalize3(modelName)}AvgAggregateOutputType`;
 }
 function getSumAggregateName(modelName) {
-  return `${capitalize2(modelName)}SumAggregateOutputType`;
+  return `${capitalize3(modelName)}SumAggregateOutputType`;
 }
 function getMinAggregateName(modelName) {
-  return `${capitalize2(modelName)}MinAggregateOutputType`;
+  return `${capitalize3(modelName)}MinAggregateOutputType`;
 }
 function getMaxAggregateName(modelName) {
-  return `${capitalize2(modelName)}MaxAggregateOutputType`;
+  return `${capitalize3(modelName)}MaxAggregateOutputType`;
 }
 function getCountAggregateInputName(modelName) {
-  return `${capitalize2(modelName)}CountAggregateInputType`;
+  return `${capitalize3(modelName)}CountAggregateInputType`;
 }
 function getCountAggregateOutputName(modelName) {
-  return `${capitalize2(modelName)}CountAggregateOutputType`;
+  return `${capitalize3(modelName)}CountAggregateOutputType`;
 }
 function getAggregateInputType(aggregateOutputType) {
   return aggregateOutputType.replace(/OutputType$/, "InputType");
@@ -2409,13 +2457,13 @@ function getGroupByArgsName(modelName) {
   return `${modelName}GroupByArgs`;
 }
 function getGroupByPayloadName(modelName) {
-  return `Get${capitalize2(modelName)}GroupByPayload`;
+  return `Get${capitalize3(modelName)}GroupByPayload`;
 }
 function getAggregateArgsName(modelName) {
-  return `${capitalize2(modelName)}AggregateArgs`;
+  return `${capitalize3(modelName)}AggregateArgs`;
 }
 function getAggregateGetName(modelName) {
-  return `Get${capitalize2(modelName)}AggregateType`;
+  return `Get${capitalize3(modelName)}AggregateType`;
 }
 function getFieldArgName(field, modelName) {
   if (field.args.length) {
@@ -2473,8 +2521,8 @@ function getModelArgName(modelName, action) {
       assertNever(action, `Unknown action: ${action}`);
   }
 }
-function getPayloadName(modelName, namespace3 = true) {
-  if (namespace3) {
+function getPayloadName(modelName, namespace2 = true) {
+  if (namespace2) {
     return `Prisma.${getPayloadName(modelName, false)}`;
   }
   return `$${modelName}Payload`;
@@ -2482,7 +2530,7 @@ function getPayloadName(modelName, namespace3 = true) {
 function getFieldRefsTypeName(name) {
   return `${name}FieldRefs`;
 }
-function capitalize2(str) {
+function capitalize3(str) {
   return str[0].toUpperCase() + str.slice(1);
 }
 function getRefAllowedTypeName(type) {
@@ -2494,11 +2542,11 @@ function getRefAllowedTypeName(type) {
 }
 function appendSkipType(context, type) {
   if (context.isPreviewFeatureOn("strictUndefinedChecks")) {
-    return ts.unionType([type, ts.namedType("$Types.Skip")]);
+    return ts.unionType([type, ts.namedType("runtime.Types.Skip")]);
   }
   return type;
 }
-var extArgsParam = ts.genericParameter("ExtArgs").extends(ts.namedType("$Extensions.InternalArgs")).default(ts.namedType("$Extensions.DefaultArgs"));
+var extArgsParam = ts.genericParameter("ExtArgs").extends(ts.namedType("runtime.Types.Extensions.InternalArgs")).default(ts.namedType("runtime.Types.Extensions.DefaultArgs"));
 
 // src/utils/common.ts
 function needsNamespace(field) {
@@ -2656,11 +2704,11 @@ import { klona } from "klona";
 import * as ts3 from "@prisma/ts-builders";
 
 // src/TSClient/helpers.ts
-import { capitalize as capitalize4, lowerCase as lowerCase3 } from "@prisma/client-common";
+import { capitalize as capitalize5, lowerCase as lowerCase3 } from "@prisma/client-common";
 import pluralize2 from "pluralize";
 
 // src/TSClient/jsdoc.ts
-import { capitalize as capitalize3, lowerCase as lowerCase2 } from "@prisma/client-common";
+import { capitalize as capitalize4, lowerCase as lowerCase2 } from "@prisma/client-common";
 var Docs = {
   cursor: `{@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}`,
   pagination: `{@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}`,
@@ -2747,7 +2795,7 @@ const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
     body: (ctx) => {
       const onlySelect = ctx.firstScalar ? `
 // Create many ${ctx.plural} and only return the \`${ctx.firstScalar.name}\`
-const ${lowerCase2(ctx.mapping.model)}With${capitalize3(ctx.firstScalar.name)}Only = await ${ctx.method}({
+const ${lowerCase2(ctx.mapping.model)}With${capitalize4(ctx.firstScalar.name)}Only = await ${ctx.method}({
   select: { ${ctx.firstScalar.name}: true },
   data: [
     // ... provide data here
@@ -2844,7 +2892,7 @@ const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
     body: (ctx) => {
       const onlySelect = ctx.firstScalar ? `
 // Only select the \`${ctx.firstScalar.name}\`
-const ${lowerCase2(ctx.mapping.model)}With${capitalize3(ctx.firstScalar.name)}Only = await ${ctx.method}({ select: { ${ctx.firstScalar.name}: true } })` : "";
+const ${lowerCase2(ctx.mapping.model)}With${capitalize4(ctx.firstScalar.name)}Only = await ${ctx.method}({ select: { ${ctx.firstScalar.name}: true } })` : "";
       return `Find zero or more ${ctx.plural} that matches the filter.
 ${undefinedNote}
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to filter and select certain fields only.
@@ -3002,7 +3050,7 @@ const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
     body: (ctx) => {
       const onlySelect = ctx.firstScalar ? `
 // Update zero or more ${ctx.plural} and only return the \`${ctx.firstScalar.name}\`
-const ${lowerCase2(ctx.mapping.model)}With${capitalize3(ctx.firstScalar.name)}Only = await ${ctx.method}({
+const ${lowerCase2(ctx.mapping.model)}With${capitalize4(ctx.firstScalar.name)}Only = await ${ctx.method}({
   select: { ${ctx.firstScalar.name}: true },
   where: {
     // ... provide filter here
@@ -3081,8 +3129,8 @@ const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
 // src/TSClient/helpers.ts
 function getMethodJSDocBody(action, mapping, model) {
   const ctx = {
-    singular: capitalize4(mapping.model),
-    plural: capitalize4(mapping.plural),
+    singular: capitalize5(mapping.model),
+    plural: capitalize5(mapping.plural),
     firstScalar: model.fields.find((f) => f.kind === "scalar"),
     method: `prisma.${lowerCase3(mapping.model)}.${action}`,
     action,
@@ -3126,7 +3174,6 @@ var ArgsTypeBuilder = class {
     ).setDocComment(ts3.docComment(`${type.name} ${action ?? "without action"}`));
   }
   moduleExport;
-  hasDefaultName = true;
   addProperty(prop) {
     this.moduleExport.declaration.type.add(prop);
   }
@@ -3176,7 +3223,6 @@ var ArgsTypeBuilder = class {
     return this;
   }
   setGeneratedName(name) {
-    this.hasDefaultName = false;
     this.moduleExport.declaration.setName(name);
     return this;
   }
@@ -3201,7 +3247,7 @@ var ModelFieldRefs = class {
 /**
  * Fields of the ${name} model
  */
-interface ${getFieldRefsTypeName(name)} {
+export interface ${getFieldRefsTypeName(name)} {
 ${this.stringifyFields()}
 }
     `;
@@ -3276,8 +3322,8 @@ function buildOutputField(field) {
 }
 function enumTypeName(ref) {
   const name = ref.type;
-  const namespace3 = ref.namespace === "model" ? "$Enums" : "Prisma";
-  return `${namespace3}.${name}`;
+  const namespace2 = ref.namespace === "model" ? "$Enums" : "Prisma";
+  return `${namespace2}.${name}`;
 }
 
 // src/TSClient/Payload.ts
@@ -3299,7 +3345,7 @@ function buildModelPayload(model, context) {
       scalars.add(buildModelOutputProperty(field, context.dmmf));
     }
   }
-  const scalarsType = isComposite ? scalars : ts5.namedType("$Extensions.GetPayloadResult").addGenericArgument(scalars).addGenericArgument(ts5.namedType("ExtArgs").subKey("result").subKey(lowerCase4(model.name)));
+  const scalarsType = isComposite ? scalars : ts5.namedType("runtime.Types.Extensions.GetPayloadResult").addGenericArgument(scalars).addGenericArgument(ts5.namedType("ExtArgs").subKey("result").subKey(lowerCase4(model.name)));
   const payloadTypeDeclaration = ts5.typeDeclaration(
     getPayloadName(model.name, false),
     ts5.objectType().add(ts5.property("name", ts5.stringLiteral(model.name))).add(ts5.property("objects", objects)).add(ts5.property("scalars", scalarsType)).add(ts5.property("composites", composites))
@@ -3328,9 +3374,9 @@ function buildOmitType({ modelName, fields, context }) {
       (field) => field.outputType.location === "scalar" || field.outputType.location === "enumTypes" || context.dmmf.isComposite(field.outputType.type)
     ).map((field) => ts6.stringLiteral(field.name))
   );
-  const omitType = ts6.namedType("$Extensions.GetOmit").addGenericArgument(keysType).addGenericArgument(modelResultExtensionsType(modelName));
+  const omitType = ts6.namedType("runtime.Types.Extensions.GetOmit").addGenericArgument(keysType).addGenericArgument(modelResultExtensionsType(modelName));
   if (context.isPreviewFeatureOn("strictUndefinedChecks")) {
-    omitType.addGenericArgument(ts6.namedType("$Types.Skip"));
+    omitType.addGenericArgument(ts6.namedType("runtime.Types.Skip"));
   }
   return buildExport(getOmitName(modelName), omitType);
 }
@@ -3341,7 +3387,7 @@ function buildSelectType({
   context
 }) {
   const objectType9 = buildSelectOrIncludeObject(modelName, fields, context);
-  const selectType = ts6.namedType("$Extensions.GetSelect").addGenericArgument(objectType9).addGenericArgument(modelResultExtensionsType(modelName));
+  const selectType = ts6.namedType("runtime.Types.Extensions.GetSelect").addGenericArgument(objectType9).addGenericArgument(modelResultExtensionsType(modelName));
   return buildExport(typeName, selectType);
 }
 function modelResultExtensionsType(modelName) {
@@ -3393,6 +3439,18 @@ function getModelActions(dmmf, name) {
   return mappingKeys;
 }
 
+// src/TSClient/utils/type-builders.ts
+import { NamedType } from "@prisma/ts-builders";
+function promise(resultType) {
+  return new NamedType("runtime.Types.Utils.JsPromise").addGenericArgument(resultType);
+}
+function prismaPromise(resultType) {
+  return new NamedType("Prisma.PrismaPromise").addGenericArgument(resultType);
+}
+function optional(innerType) {
+  return new NamedType("runtime.Types.Utils.Optional").addGenericArgument(innerType);
+}
+
 // src/TSClient/Model.ts
 var Model = class {
   constructor(model, context) {
@@ -3482,7 +3540,7 @@ var Model = class {
     return `
 
 
-export type ${groupByArgsName}<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+export type ${groupByArgsName}<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
 ${indent3(
       groupByRootField.args.map((arg) => {
         const updatedArg = { ...arg, comment: getArgFieldJSDoc(this.type, DMMF2.ModelAction.groupBy, arg) };
@@ -3575,7 +3633,7 @@ ${aggregateTypes.length > 1 ? aggregateTypes.slice(1).map((type) => {
       return new InputType(newType, this.context).toTS();
     }).join("\n") : ""}
 
-export type ${aggregateArgsName}<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+export type ${aggregateArgsName}<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
 ${indent3(
       aggregateRootField.args.map((arg) => {
         const updatedArg = { ...arg, comment: getArgFieldJSDoc(this.type, DMMF2.ModelAction.aggregate, arg) };
@@ -3614,7 +3672,7 @@ export type ${getAggregateGetName(model.name)}<T extends ${getAggregateArgsName(
     const modelTypeExport = ts7.moduleExport(
       ts7.typeDeclaration(
         model.name,
-        ts7.namedType(`$Result.DefaultSelection`).addGenericArgument(ts7.namedType(getPayloadName(model.name)))
+        ts7.namedType(`runtime.Types.Result.DefaultSelection`).addGenericArgument(ts7.namedType(getPayloadName(model.name)))
       )
     ).setDocComment(ts7.docComment(docs));
     return ts7.stringify(modelTypeExport);
@@ -3692,9 +3750,9 @@ ${omitType}${includeType}${createManyAndReturnIncludeType}${updateManyAndReturnI
 
 ${ts7.stringify(buildModelPayload(this.model, this.context), { newLine: "none" })}
 
-type ${model.name}GetPayload<S extends boolean | null | undefined | ${getModelArgName(
+export type ${model.name}GetPayload<S extends boolean | null | undefined | ${getModelArgName(
       model.name
-    )}> = $Result.GetResult<${getPayloadName(model.name)}, S>
+    )}> = runtime.Types.Result.GetResult<${getPayloadName(model.name)}, S>
 
 ${isComposite ? "" : new ModelDelegate(this.type, this.context).toTS()}
 
@@ -3738,7 +3796,7 @@ var ModelDelegate = class {
       excludedArgsForCount.push("relationLoadStrategy");
     }
     const excludedArgsForCountType = excludedArgsForCount.map((name2) => `'${name2}'`).join(" | ");
-    return `${availableActions.includes(DMMF2.ModelAction.aggregate) ? `type ${countArgsName}<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
+    return `${availableActions.includes(DMMF2.ModelAction.aggregate) ? `export type ${countArgsName}<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
   Omit<${getModelArgName(name, DMMF2.ModelAction.findMany)}, ${excludedArgsForCountType}> & {
     select?: ${getCountAggregateInputName(name)} | true
   }
@@ -3754,7 +3812,7 @@ ${availableActions.includes(DMMF2.ModelAction.aggregate) ? `${indent3(getMethodJ
   count<T extends ${countArgsName}>(
     args?: Subset<T, ${countArgsName}>,
   ): Prisma.PrismaPromise<
-    T extends $Utils.Record<'select', any>
+    T extends runtime.Types.Utils.Record<'select', any>
       ? T['select'] extends true
         ? number
         : GetScalarType<T['select'], ${getCountAggregateOutputName(name)}>
@@ -3885,16 +3943,16 @@ function getReturnType({
   isNullable = false
 }) {
   if (actionName === DMMF2.ModelAction.count) {
-    return ts7.promise(ts7.numberType);
+    return promise(ts7.numberType);
   }
   if (actionName === DMMF2.ModelAction.aggregate) {
-    return ts7.promise(ts7.namedType(getAggregateGetName(modelName)).addGenericArgument(ts7.namedType("T")));
+    return promise(ts7.namedType(getAggregateGetName(modelName)).addGenericArgument(ts7.namedType("T")));
   }
   if (actionName === DMMF2.ModelAction.findRaw || actionName === DMMF2.ModelAction.aggregateRaw) {
-    return ts7.prismaPromise(ts7.namedType("JsonObject"));
+    return prismaPromise(ts7.namedType("JsonObject"));
   }
   if (actionName === DMMF2.ModelAction.deleteMany || actionName === DMMF2.ModelAction.updateMany || actionName === DMMF2.ModelAction.createMany) {
-    return ts7.prismaPromise(ts7.namedType("BatchPayload"));
+    return prismaPromise(ts7.namedType("BatchPayload"));
   }
   const isList = actionName === DMMF2.ModelAction.findMany || actionName === DMMF2.ModelAction.createManyAndReturn || actionName === DMMF2.ModelAction.updateManyAndReturn;
   if (isList) {
@@ -3902,7 +3960,7 @@ function getReturnType({
     if (isChaining) {
       result = ts7.unionType(result).addVariant(ts7.namedType("Null"));
     }
-    return ts7.prismaPromise(result);
+    return prismaPromise(result);
   }
   if (isChaining && actionName === DMMF2.ModelAction.findUniqueOrThrow) {
     const nullType7 = isNullable ? ts7.nullType : ts7.namedType("Null");
@@ -3919,11 +3977,11 @@ function getFluentWrapper(modelName, resultType, nullType7 = ts7.neverType) {
   return ts7.namedType(fluentWrapperName(modelName)).addGenericArgument(resultType).addGenericArgument(nullType7).addGenericArgument(extArgsParam.toArgument()).addGenericArgument(ts7.namedType("GlobalOmitOptions"));
 }
 function getResultType(modelName, actionName) {
-  return ts7.namedType("$Result.GetResult").addGenericArgument(ts7.namedType(getPayloadName(modelName)).addGenericArgument(extArgsParam.toArgument())).addGenericArgument(ts7.namedType("T")).addGenericArgument(ts7.stringLiteral(actionName)).addGenericArgument(ts7.namedType("GlobalOmitOptions"));
+  return ts7.namedType("runtime.Types.Result.GetResult").addGenericArgument(ts7.namedType(getPayloadName(modelName)).addGenericArgument(extArgsParam.toArgument())).addGenericArgument(ts7.namedType("T")).addGenericArgument(ts7.stringLiteral(actionName)).addGenericArgument(ts7.namedType("GlobalOmitOptions"));
 }
 function buildFluentWrapperDefinition(modelName, outputType, context) {
   const definition = ts7.interfaceDeclaration(fluentWrapperName(modelName));
-  definition.addGenericParameter(ts7.genericParameter("T")).addGenericParameter(ts7.genericParameter("Null").default(ts7.neverType)).addGenericParameter(extArgsParam).addGenericParameter(ts7.genericParameter("GlobalOmitOptions").default(ts7.objectType())).extends(ts7.prismaPromise(ts7.namedType("T")));
+  definition.addGenericParameter(ts7.genericParameter("T")).addGenericParameter(ts7.genericParameter("Null").default(ts7.neverType)).addGenericParameter(extArgsParam).addGenericParameter(ts7.genericParameter("GlobalOmitOptions").default(ts7.objectType())).extends(prismaPromise(ts7.namedType("T")));
   definition.add(ts7.property(ts7.toStringTag, ts7.stringLiteral("PrismaPromise")).readonly());
   definition.addMultiple(
     outputType.fields.filter(
@@ -3949,7 +4007,7 @@ function buildFluentWrapperDefinition(modelName, outputType, context) {
           @param onrejected The callback to execute when the Promise is rejected.
           @returns A Promise for the completion of which ever callback is executed.
         `
-    ).addGenericParameter(ts7.genericParameter("TResult1").default(ts7.namedType("T"))).addGenericParameter(ts7.genericParameter("TResult2").default(ts7.neverType)).addParameter(promiseCallback("onfulfilled", ts7.parameter("value", ts7.namedType("T")), ts7.namedType("TResult1"))).addParameter(promiseCallback("onrejected", ts7.parameter("reason", ts7.anyType), ts7.namedType("TResult2"))).setReturnType(ts7.promise(ts7.unionType([ts7.namedType("TResult1"), ts7.namedType("TResult2")])))
+    ).addGenericParameter(ts7.genericParameter("TResult1").default(ts7.namedType("T"))).addGenericParameter(ts7.genericParameter("TResult2").default(ts7.neverType)).addParameter(promiseCallback("onfulfilled", ts7.parameter("value", ts7.namedType("T")), ts7.namedType("TResult1"))).addParameter(promiseCallback("onrejected", ts7.parameter("reason", ts7.anyType), ts7.namedType("TResult2"))).setReturnType(promise(ts7.unionType([ts7.namedType("TResult1"), ts7.namedType("TResult2")])))
   );
   definition.add(
     ts7.method("catch").setDocComment(
@@ -3958,7 +4016,7 @@ function buildFluentWrapperDefinition(modelName, outputType, context) {
           @param onrejected The callback to execute when the Promise is rejected.
           @returns A Promise for the completion of the callback.
         `
-    ).addGenericParameter(ts7.genericParameter("TResult").default(ts7.neverType)).addParameter(promiseCallback("onrejected", ts7.parameter("reason", ts7.anyType), ts7.namedType("TResult"))).setReturnType(ts7.promise(ts7.unionType([ts7.namedType("T"), ts7.namedType("TResult")])))
+    ).addGenericParameter(ts7.genericParameter("TResult").default(ts7.neverType)).addParameter(promiseCallback("onrejected", ts7.parameter("reason", ts7.anyType), ts7.namedType("TResult"))).setReturnType(promise(ts7.unionType([ts7.namedType("T"), ts7.namedType("TResult")])))
   );
   definition.add(
     ts7.method("finally").setDocComment(
@@ -3970,7 +4028,7 @@ function buildFluentWrapperDefinition(modelName, outputType, context) {
       `
     ).addParameter(
       ts7.parameter("onfinally", ts7.unionType([ts7.functionType(), ts7.undefinedType, ts7.nullType])).optional()
-    ).setReturnType(ts7.promise(ts7.namedType("T")))
+    ).setReturnType(promise(ts7.namedType("T")))
   );
   return ts7.moduleExport(definition).setDocComment(ts7.docComment`
       The delegate class that acts as a "Promise-like" for ${modelName}.
@@ -4000,13 +4058,13 @@ function fluentWrapperName(modelName) {
 }
 
 // src/TSClient/TSClient.ts
+import crypto from "node:crypto";
+import path2 from "node:path";
 import { datamodelEnumToSchemaEnum } from "@prisma/dmmf";
-import { ClientEngineType as ClientEngineType2, getClientEngineType, pathToPosix as pathToPosix3 } from "@prisma/internals";
+import { ClientEngineType as ClientEngineType2, getClientEngineType, pathToPosix as pathToPosix2 } from "@prisma/internals";
 import * as ts12 from "@prisma/ts-builders";
 import ciInfo from "ci-info";
-import crypto from "crypto";
-import indent8 from "indent-string";
-import path2 from "path";
+import indent7 from "indent-string";
 
 // src/dmmf.ts
 import { keyBy } from "@prisma/client-common";
@@ -4062,8 +4120,8 @@ var DMMFHelper = class {
       Object.values(this.mappings.otherOperations.read)
     ].flat();
   }
-  hasEnumInNamespace(enumName, namespace3) {
-    return this.schema.enumTypes[namespace3]?.find((schemaEnum) => schemaEnum.name === enumName) !== void 0;
+  hasEnumInNamespace(enumName, namespace2) {
+    return this.schema.enumTypes[namespace2]?.find((schemaEnum) => schemaEnum.name === enumName) !== void 0;
   }
   resolveInputObjectType(ref) {
     return this.inputTypesByName.get(fullyQualifiedName(ref.type, ref.namespace));
@@ -4118,9 +4176,9 @@ var DMMFHelper = class {
     return result;
   }
 };
-function fullyQualifiedName(typeName, namespace3) {
-  if (namespace3) {
-    return `${namespace3}.${typeName}`;
+function fullyQualifiedName(typeName, namespace2) {
+  if (namespace2) {
+    return `${namespace2}.${typeName}`;
   }
   return typeName;
 }
@@ -4240,40 +4298,17 @@ function buildDebugInitialization(edge) {
   }
   const debugVar = getRuntimeEdgeEnvVar("DEBUG");
   return `if (${debugVar}) {
-  Debug.enable(${debugVar})
+  runtime.Debug.enable(${debugVar})
 }
 `;
 }
 
 // src/utils/buildDirname.ts
-import { pathToPosix } from "@prisma/internals";
-function buildDirname(edge, relativeOutdir) {
+function buildDirname(edge) {
   if (edge === true) {
-    return buildDirnameDefault();
+    return `config.dirname = '/'`;
   }
-  return buildDirnameFind(relativeOutdir);
-}
-function buildDirnameFind(relativeOutdir) {
-  return `
-const fs = require('fs')
-
-config.dirname = __dirname
-if (!fs.existsSync(path.join(__dirname, 'schema.prisma'))) {
-  const alternativePaths = [
-    ${JSON.stringify(pathToPosix(relativeOutdir))},
-    ${JSON.stringify(pathToPosix(relativeOutdir).split("/").slice(1).join("/"))},
-  ]
-  
-  const alternativePath = alternativePaths.find((altPath) => {
-    return fs.existsSync(path.join(process.cwd(), altPath, 'schema.prisma'))
-  }) ?? alternativePaths[0]
-
-  config.dirname = path.join(process.cwd(), alternativePath)
-  config.isBundled = true
-}`;
-}
-function buildDirnameDefault() {
-  return `config.dirname = '/'`;
+  return `config.dirname = __dirname`;
 }
 
 // src/utils/buildDMMF.ts
@@ -4291,65 +4326,65 @@ function buildRuntimeDataModel(datamodel, runtimeName) {
   }
   const datamodelString = escapeJson(JSON.stringify(prunedDataModel));
   return `
-config.runtimeDataModel = JSON.parse(${JSON.stringify(datamodelString)})
-defineDmmfProperty(exports.Prisma, config.runtimeDataModel)`;
+config.runtimeDataModel = JSON.parse(${JSON.stringify(datamodelString)})`;
 }
 
-// src/utils/buildGetQueryCompilerWasmModule.ts
-function buildQueryCompilerWasmModule(wasm, copyCompiler, runtimeName) {
-  if (copyCompiler && runtimeName === "client") {
-    return `config.compilerWasm = {
-      getRuntime: () => require('./query_compiler_bg.js'),
-      getQueryCompilerWasmModule: async () => {
-        const queryCompilerWasmFilePath = require('path').join(config.dirname, 'query_compiler_bg.wasm')
-        const queryCompilerWasmFileBytes = require('fs').readFileSync(queryCompilerWasmFilePath)
-
-        return new WebAssembly.Module(queryCompilerWasmFileBytes)
-      }
-    }`;
-  }
-  if (copyCompiler && runtimeName === "client" && wasm === true) {
-    return `config.compilerWasm = {
-  getRuntime: () => require('./query_compiler_bg.js'),
-  getQueryCompilerWasmModule: async () => {
-    const loader = (await import('#wasm-compiler-loader')).default
-    const compiler = (await loader).default
-    return compiler
+// src/utils/buildGetWasmModule.ts
+import { capitalize as capitalize6 } from "@prisma/client-common";
+import { match } from "ts-pattern";
+function buildGetWasmModule({
+  component,
+  runtimeName,
+  runtimeBase,
+  target,
+  activeProvider,
+  moduleFormat
+}) {
+  const capitalizedComponent = capitalize6(component);
+  const wasmPathBase = `${runtimeBase}/query_compiler_bg.${activeProvider}`;
+  const wasmBindingsPath = `${wasmPathBase}.mjs`;
+  const wasmModulePath = `${wasmPathBase}.wasm`;
+  const buildNodeLoader = match(runtimeName).with("library", () => component === "engine" && !!process.env.PRISMA_CLIENT_FORCE_WASM).with("client", () => component === "compiler").otherwise(() => false);
+  const buildEdgeLoader = runtimeName === "wasm" && component === "engine";
+  if (buildNodeLoader) {
+    return `config.${component}Wasm = {
+  getRuntime: async () => await import(${JSON.stringify(wasmBindingsPath)}),
+
+  getQuery${capitalizedComponent}WasmModule: async () => {
+    const { readFile } = await import('node:fs/promises')
+    ${buildRequire(moduleFormat)}
+    const wasmModulePath = require.resolve(${JSON.stringify(wasmModulePath)})
+    const wasmModuleBytes = await readFile(wasmModulePath)
+
+    return new globalThis.WebAssembly.Module(wasmModuleBytes)
   }
 }`;
   }
-  return `config.compilerWasm = undefined`;
-}
-
-// src/utils/buildGetQueryEngineWasmModule.ts
-function buildQueryEngineWasmModule(wasm, copyEngine, runtimeName) {
-  if (copyEngine && runtimeName === "library" && process.env.PRISMA_CLIENT_FORCE_WASM) {
-    return `config.engineWasm = {
-      getRuntime: () => require('./query_engine_bg.js'),
-      getQueryEngineWasmModule: async () => {
-        const queryEngineWasmFilePath = require('path').join(config.dirname, 'query_engine_bg.wasm')
-        const queryEngineWasmFileBytes = require('fs').readFileSync(queryEngineWasmFilePath)
+  if (buildEdgeLoader) {
+    const fullWasmModulePath = target === "edge-light" ? `${wasmModulePath}?module` : wasmModulePath;
+    return `config.${component}Wasm = {
+  getRuntime: async () => await import(${JSON.stringify(wasmBindingsPath)}),
 
-        return new WebAssembly.Module(queryEngineWasmFileBytes)
-      }
-    }`;
-  }
-  if (copyEngine && wasm === true) {
-    return `config.engineWasm = {
-  getRuntime: () => require('./query_engine_bg.js'),
-  getQueryEngineWasmModule: async () => {
-    const loader = (await import('#wasm-engine-loader')).default
-    const engine = (await loader).default
-    return engine
+  getQuery${capitalizedComponent}WasmModule: async () => {
+    const { default: module } = await import(${JSON.stringify(fullWasmModulePath)})
+    return module
   }
 }`;
   }
-  return `config.engineWasm = undefined`;
+  return `config.${component}Wasm = undefined`;
+}
+function buildRequire(moduleFormat) {
+  if (moduleFormat === "cjs") {
+    return "";
+  }
+  return `const { createRequire } = await import('node:module')
+    const require = createRequire(import.meta.url)
+`;
 }
 
 // src/utils/buildNFTAnnotations.ts
 import { getNodeAPIName } from "@prisma/get-platform";
-import { ClientEngineType, parseAWSNodejsRuntimeEnvVarVersion, pathToPosix as pathToPosix2 } from "@prisma/internals";
+import { ClientEngineType, parseAWSNodejsRuntimeEnvVarVersion, pathToPosix } from "@prisma/internals";
 import path from "path";
 function buildNFTAnnotations(noEngine, engineType, binaryTargets, relativeOutdir) {
   if (noEngine === true) return "";
@@ -4387,207 +4422,70 @@ function buildNFTAnnotation(fileName, relativeOutdir) {
   const relativeFilePath = path.join(relativeOutdir, fileName);
   return `
 // file annotations for bundling tools to include these files
-path.join(__dirname, ${JSON.stringify(pathToPosix2(fileName))});
-path.join(process.cwd(), ${JSON.stringify(pathToPosix2(relativeFilePath))})`;
-}
-
-// src/utils/buildRequirePath.ts
-function buildRequirePath(edge) {
-  if (edge === true) return "";
-  return `
-  const path = require('path')`;
-}
-
-// src/utils/buildWarnEnvConflicts.ts
-function buildWarnEnvConflicts(edge, runtimeBase, runtimeName) {
-  if (edge === true) return "";
-  return `
-const { warnEnvConflicts } = require('${runtimeBase}/${runtimeName}')
-
-warnEnvConflicts({
-    rootEnvPath: config.relativeEnvPaths.rootEnvPath && path.resolve(config.dirname, config.relativeEnvPaths.rootEnvPath),
-    schemaEnvPath: config.relativeEnvPaths.schemaEnvPath && path.resolve(config.dirname, config.relativeEnvPaths.schemaEnvPath)
-})`;
+path.join(__dirname, ${JSON.stringify(pathToPosix(fileName))})
+path.join(process.cwd(), ${JSON.stringify(pathToPosix(relativeFilePath))})`;
 }
 
 // src/TSClient/common.ts
-import indent4 from "indent-string";
-var commonCodeJS = ({
+var commonCodeTS = ({
   runtimeBase,
   runtimeName,
-  browser,
   clientVersion,
   engineVersion,
   generator,
-  deno
-}) => `${deno ? "const exports = {}" : ""}
-Object.defineProperty(exports, "__esModule", { value: true });
-${deno ? `
-import {
-  PrismaClientKnownRequestError,
-  PrismaClientUnknownRequestError,
-  PrismaClientRustPanicError,
-  PrismaClientInitializationError,
-  PrismaClientValidationError,
-  getPrismaClient,
-  sqltag,
-  empty,
-  join,
-  raw,
-  Decimal,
-  Debug,
-  objectEnumValues,
-  makeStrictEnum,
-  Extensions,
-  defineDmmfProperty,
-  Public,
-  getRuntime,
-  skip
-} from '${runtimeBase}/${runtimeName}'` : browser ? `
-const {
-  Decimal,
-  objectEnumValues,
-  makeStrictEnum,
-  Public,
-  getRuntime,
-  skip
-} = require('${runtimeBase}/${runtimeName}')
-` : `
-const {
-  PrismaClientKnownRequestError,
-  PrismaClientUnknownRequestError,
-  PrismaClientRustPanicError,
-  PrismaClientInitializationError,
-  PrismaClientValidationError,
-  getPrismaClient,
-  sqltag,
-  empty,
-  join,
-  raw,
-  skip,
-  Decimal,
-  Debug,
-  objectEnumValues,
-  makeStrictEnum,
-  Extensions,
-  warnOnce,
-  defineDmmfProperty,
-  Public,
-  getRuntime,
-  createParam,
-} = require('${runtimeBase}/${runtimeName}')
-`}
-
-const Prisma = {}
-
-exports.Prisma = Prisma
-exports.$Enums = {}
+  moduleFormat,
+  edge
+}) => ({
+  tsWithoutNamespace: () => `import * as runtime from '${runtimeBase}/${runtimeName}'
+${buildPreamble(edge, moduleFormat)}
 
-/**
- * Prisma Client JS version: ${clientVersion}
- * Query Engine version: ${engineVersion}
- */
-Prisma.prismaVersion = {
-  client: "${clientVersion}",
-  engine: "${engineVersion}"
-}
+export type PrismaPromise<T> = runtime.Types.Public.PrismaPromise<T>
+`,
+  ts: () => `export type DMMF = typeof runtime.DMMF
 
-Prisma.PrismaClientKnownRequestError = ${notSupportOnBrowser("PrismaClientKnownRequestError", browser)};
-Prisma.PrismaClientUnknownRequestError = ${notSupportOnBrowser("PrismaClientUnknownRequestError", browser)}
-Prisma.PrismaClientRustPanicError = ${notSupportOnBrowser("PrismaClientRustPanicError", browser)}
-Prisma.PrismaClientInitializationError = ${notSupportOnBrowser("PrismaClientInitializationError", browser)}
-Prisma.PrismaClientValidationError = ${notSupportOnBrowser("PrismaClientValidationError", browser)}
-Prisma.Decimal = Decimal
+export type PrismaPromise<T> = runtime.Types.Public.PrismaPromise<T>
 
 /**
- * Re-export of sql-template-tag
+ * Validator
  */
-Prisma.sql = ${notSupportOnBrowser("sqltag", browser)}
-Prisma.empty = ${notSupportOnBrowser("empty", browser)}
-Prisma.join = ${notSupportOnBrowser("join", browser)}
-Prisma.raw = ${notSupportOnBrowser("raw", browser)}
-Prisma.validator = Public.validator
-
-/**
-* Extensions
-*/
-Prisma.getExtensionContext = ${notSupportOnBrowser("Extensions.getExtensionContext", browser)}
-Prisma.defineExtension = ${notSupportOnBrowser("Extensions.defineExtension", browser)}
+export const validator = runtime.Public.validator
 
 /**
- * Shorthand utilities for JSON filtering
+ * Prisma Errors
  */
-Prisma.DbNull = objectEnumValues.instances.DbNull
-Prisma.JsonNull = objectEnumValues.instances.JsonNull
-Prisma.AnyNull = objectEnumValues.instances.AnyNull
 
-Prisma.NullTypes = {
-  DbNull: objectEnumValues.classes.DbNull,
-  JsonNull: objectEnumValues.classes.JsonNull,
-  AnyNull: objectEnumValues.classes.AnyNull
-}
+export const PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
+export type PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
 
-${buildPrismaSkipJs(generator.previewFeatures)}
-`;
-var notSupportOnBrowser = (fnc, browser) => {
-  if (browser) {
-    return `() => {
-  const runtimeName = getRuntime().prettyName;
-  throw new Error(\`${fnc} is unable to run in this browser environment, or has been bundled for the browser (running in \${runtimeName}).
-In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report\`,
-)}`;
-  }
-  return fnc;
-};
-var commonCodeTS = ({
-  runtimeBase,
-  runtimeName,
-  clientVersion,
-  engineVersion,
-  generator
-}) => ({
-  tsWithoutNamespace: () => `import * as runtime from '${runtimeBase}/${runtimeName}';
-import $Types = runtime.Types // general types
-import $Public = runtime.Types.Public
-import $Utils = runtime.Types.Utils
-import $Extensions = runtime.Types.Extensions
-import $Result = runtime.Types.Result
-
-export type PrismaPromise<T> = $Public.PrismaPromise<T>
-`,
-  ts: () => `export import DMMF = runtime.DMMF
+export const PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
+export type PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
 
-export type PrismaPromise<T> = $Public.PrismaPromise<T>
+export const PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
+export type PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
 
-/**
- * Validator
- */
-export import validator = runtime.Public.validator
+export const PrismaClientInitializationError = runtime.PrismaClientInitializationError
+export type PrismaClientInitializationError = runtime.PrismaClientInitializationError
 
-/**
- * Prisma Errors
- */
-export import PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
-export import PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
-export import PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
-export import PrismaClientInitializationError = runtime.PrismaClientInitializationError
-export import PrismaClientValidationError = runtime.PrismaClientValidationError
+export const PrismaClientValidationError = runtime.PrismaClientValidationError
+export type PrismaClientValidationError = runtime.PrismaClientValidationError
 
 /**
  * Re-export of sql-template-tag
  */
-export import sql = runtime.sqltag
-export import empty = runtime.empty
-export import join = runtime.join
-export import raw = runtime.raw
-export import Sql = runtime.Sql
+export const sql = runtime.sqltag
+export const empty = runtime.empty
+export const join = runtime.join
+export const raw = runtime.raw
+export const Sql = runtime.Sql
+export type Sql = runtime.Sql
 
 ${buildPrismaSkipTs(generator.previewFeatures)}
 
 /**
  * Decimal.js
  */
-export import Decimal = runtime.Decimal
+export const Decimal = runtime.Decimal
+export type Decimal = runtime.Decimal
 
 export type DecimalJsLike = runtime.DecimalJsLike
 
@@ -4602,46 +4500,43 @@ export type MetricHistogramBucket = runtime.MetricHistogramBucket
 /**
 * Extensions
 */
-export import Extension = $Extensions.UserArgs
-export import getExtensionContext = runtime.Extensions.getExtensionContext
-export import Args = $Public.Args
-export import Payload = $Public.Payload
-export import Result = $Public.Result
-export import Exact = $Public.Exact
+export type Extension = runtime.Types.Extensions.UserArgs
+export const getExtensionContext = runtime.Extensions.getExtensionContext
+export type Args<T, F extends runtime.Operation> = runtime.Types.Public.Args<T, F>
+export type Payload<T, F extends runtime.Operation = never> = runtime.Types.Public.Payload<T, F>
+export type Result<T, A, F extends runtime.Operation> = runtime.Types.Public.Result<T, A, F>
+export type Exact<A, W> = runtime.Types.Public.Exact<A, W>
+
+export type PrismaVersion = {
+  client: string
+  engine: string
+}
 
 /**
  * Prisma Client JS version: ${clientVersion}
  * Query Engine version: ${engineVersion}
  */
-export type PrismaVersion = {
-  client: string
+export const prismaVersion: PrismaVersion = {
+  client: "${clientVersion}",
+  engine: "${engineVersion}"
 }
 
-export const prismaVersion: PrismaVersion
-
 /**
  * Utility Types
  */
 
 
-export import JsonObject = runtime.JsonObject
-export import JsonArray = runtime.JsonArray
-export import JsonValue = runtime.JsonValue
-export import InputJsonObject = runtime.InputJsonObject
-export import InputJsonArray = runtime.InputJsonArray
-export import InputJsonValue = runtime.InputJsonValue
+export type JsonObject = runtime.JsonObject
+export type JsonArray = runtime.JsonArray
+export type JsonValue = runtime.JsonValue
+export type InputJsonObject = runtime.InputJsonObject
+export type InputJsonArray = runtime.InputJsonArray
+export type InputJsonValue = runtime.InputJsonValue
 
-/**
- * Types of the values used to represent different kinds of \`null\` values when working with JSON fields.
- *
- * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
- */
-namespace NullTypes {
-${buildNullClass("DbNull")}
-
-${buildNullClass("JsonNull")}
-
-${buildNullClass("AnyNull")}
+export const NullTypes = {
+  DbNull: runtime.objectEnumValues.classes.DbNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.DbNull),
+  JsonNull: runtime.objectEnumValues.classes.JsonNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.JsonNull),
+  AnyNull: runtime.objectEnumValues.classes.AnyNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.AnyNull),
 }
 
 /**
@@ -4649,21 +4544,21 @@ ${buildNullClass("AnyNull")}
  *
  * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
  */
-export const DbNull: NullTypes.DbNull
+export const DbNull = runtime.objectEnumValues.instances.DbNull
 
 /**
  * Helper for filtering JSON entries that have JSON \`null\` values (not empty on the db)
  *
  * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
  */
-export const JsonNull: NullTypes.JsonNull
+export const JsonNull = runtime.objectEnumValues.instances.JsonNull
 
 /**
  * Helper for filtering JSON entries that are \`Prisma.DbNull\` or \`Prisma.JsonNull\`
  *
  * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
  */
-export const AnyNull: NullTypes.AnyNull
+export const AnyNull = runtime.objectEnumValues.instances.AnyNull
 
 type SelectAndInclude = {
   select: any
@@ -4675,16 +4570,6 @@ type SelectAndOmit = {
   omit: any
 }
 
-/**
- * Get the type of the value, that the Promise holds.
- */
-export type PromiseType<T extends PromiseLike<any>> = T extends PromiseLike<infer U> ? U : T;
-
-/**
- * Get the return type of a function which returns a Promise.
- */
-export type PromiseReturnType<T extends (...args: any) => $Utils.JsPromise<any>> = PromiseType<ReturnType<T>>
-
 /**
  * From T, pick a set of properties whose keys are in the union K
  */
@@ -4692,19 +4577,8 @@ type Prisma__Pick<T, K extends keyof T> = {
     [P in K]: T[P];
 };
 
-
 export type Enumerable<T> = T | Array<T>;
 
-export type RequiredKeys<T> = {
-  [K in keyof T]-?: {} extends Prisma__Pick<T, K> ? never : K
-}[keyof T]
-
-export type TruthyKeys<T> = keyof {
-  [K in keyof T as T[K] extends false | undefined | null ? never : K]: K
-}
-
-export type TrueKeys<T> = TruthyKeys<Prisma__Pick<T, RequiredKeys<T>>>
-
 /**
  * Subset
  * @desc From \`T\` pick properties that exist in \`U\`. Simple version of Intersection
@@ -4821,7 +4695,6 @@ type _Merge<U extends object> = IntersectOf<Overwrite<U, {
 }>>;
 
 type Key = string | number | symbol;
-type AtBasic<O extends object, K extends Key> = K extends keyof O ? O[K] : never;
 type AtStrict<O extends object, K extends Key> = O[K & keyof O];
 type AtLoose<O extends object, K extends Key> = O extends unknown ? AtStrict<O, K> : never;
 export type At<O extends object, K extends Key, strict extends Boolean = 1> = {
@@ -4845,7 +4718,7 @@ type _Record<K extends keyof any, T> = {
 type NoExpand<T> = T extends unknown ? T : never;
 
 // this type assumes the passed object is entirely optional
-type AtLeast<O extends object, K extends string> = NoExpand<
+export type AtLeast<O extends object, K extends string> = NoExpand<
   O extends unknown
   ? | (K extends keyof O ? { [P in K]: O[P] } & O : O)
     | {[P in keyof O as P extends K ? P : never]-?: O[P]} & O
@@ -4858,19 +4731,10 @@ export type Strict<U extends object> = ComputeRaw<_Strict<U>>;
 
 export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;
 
-/**
-A [[Boolean]]
-*/
 export type Boolean = True | False
 
-// /**
-// 1
-// */
 export type True = 1
 
-/**
-0
-*/
 export type False = 0
 
 export type Not<B extends Boolean> = {
@@ -4901,16 +4765,6 @@ export type Or<B1 extends Boolean, B2 extends Boolean> = {
 
 export type Keys<U extends Union> = U extends unknown ? keyof U : never
 
-type Cast<A, B> = A extends B ? A : B;
-
-export const type: unique symbol;
-
-
-
-/**
- * Used by group by
- */
-
 export type GetScalarType<T, O> = O extends object ? {
   [P in keyof T]: P extends keyof O
     ? O[P]
@@ -4962,43 +4816,36 @@ type FieldRefInputType<Model, FieldType> = Model extends never ? never : FieldRe
 
 `
 });
-function buildNullClass(name) {
-  const source = `/**
-* Type of \`Prisma.${name}\`.
-*
-* You cannot use other instances of this class. Please use the \`Prisma.${name}\` value.
-*
-* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
-*/
-class ${name} {
-  private ${name}: never
-  private constructor()
-}`;
-  return indent4(source, TAB_SIZE);
-}
 function buildPrismaSkipTs(previewFeatures) {
   if (previewFeatures.includes("strictUndefinedChecks")) {
     return `
 /**
  * Prisma.skip
  */
-export import skip = runtime.skip
+export const skip = runtime.skip
 `;
   }
   return "";
 }
-function buildPrismaSkipJs(previewFeatures) {
-  if (previewFeatures.includes("strictUndefinedChecks")) {
-    return `
-Prisma.skip = skip
+function buildPreamble(edge, moduleFormat) {
+  if (edge) {
+    return "";
+  }
+  let preamble = `import * as process from 'node:process'
+import * as path from 'node:path'
+`;
+  if (moduleFormat === "esm") {
+    preamble += `    import { fileURLToPath } from 'node:url'
+
+    const __dirname = path.dirname(fileURLToPath(import.meta.url))
 `;
   }
-  return "";
+  return preamble;
 }
 
 // src/TSClient/Count.ts
 import * as ts8 from "@prisma/ts-builders";
-import indent5 from "indent-string";
+import indent4 from "indent-string";
 var Count = class {
   constructor(type, context) {
     this.type = type;
@@ -5029,8 +4876,10 @@ var Count = class {
 
 ${ts8.stringify(outputType)}
 
-export type ${getSelectName(name)}<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-${indent5(
+export type ${getSelectName(
+      name
+    )}<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+${indent4(
       type.fields.map((field) => {
         const types = ["boolean"];
         if (field.outputType.location === "outputObjectTypes") {
@@ -5051,7 +4900,7 @@ ${this.argsTypes.map((typeExport) => ts8.stringify(typeExport)).join("\n\n")}
   }
 };
 function getCountArgsType(typeName, fieldName) {
-  return `${typeName}Count${capitalize2(fieldName)}Args`;
+  return `${typeName}Count${capitalize3(fieldName)}Args`;
 }
 
 // src/TSClient/FieldRefInput.ts
@@ -5092,7 +4941,7 @@ var GenerateContext = class {
 import { lowerCase as lowerCase7 } from "@prisma/client-common";
 import { assertNever as assertNever2 } from "@prisma/internals";
 import * as ts11 from "@prisma/ts-builders";
-import indent7 from "indent-string";
+import indent6 from "indent-string";
 
 // src/utils/runtimeImport.ts
 import * as ts9 from "@prisma/ts-builders";
@@ -5104,7 +4953,7 @@ function runtimeImportedType(name) {
 }
 
 // src/TSClient/Datasources.ts
-import indent6 from "indent-string";
+import indent5 from "indent-string";
 var Datasources = class {
   constructor(internalDatasources) {
     this.internalDatasources = internalDatasources;
@@ -5112,7 +4961,7 @@ var Datasources = class {
   toTS() {
     const sources = this.internalDatasources;
     return `export type Datasources = {
-${indent6(sources.map((s) => `${s.name}?: Datasource`).join("\n"), 2)}
+${indent5(sources.map((s) => `${s.name}?: Datasource`).join("\n"), 2)}
 }`;
   }
 };
@@ -5168,9 +5017,9 @@ function clientTypeMapModelsDefinition(context) {
 }
 function clientTypeMapModelsResultDefinition(modelName, action) {
   if (action === "count")
-    return ts11.unionType([ts11.optional(ts11.namedType(getCountAggregateOutputName(modelName))), ts11.numberType]);
-  if (action === "groupBy") return ts11.array(ts11.optional(ts11.namedType(getGroupByName(modelName))));
-  if (action === "aggregate") return ts11.optional(ts11.namedType(getAggregateName(modelName)));
+    return ts11.unionType([optional(ts11.namedType(getCountAggregateOutputName(modelName))), ts11.numberType]);
+  if (action === "groupBy") return ts11.array(optional(ts11.namedType(getGroupByName(modelName))));
+  if (action === "aggregate") return optional(ts11.namedType(getAggregateName(modelName)));
   if (action === "findRaw") return ts11.namedType("JsonObject");
   if (action === "aggregateRaw") return ts11.namedType("JsonObject");
   if (action === "deleteMany") return ts11.namedType("BatchPayload");
@@ -5190,7 +5039,7 @@ function clientTypeMapModelsResultDefinition(modelName, action) {
   assertNever2(action, `Unknown action: ${action}`);
 }
 function payloadToResult(modelName) {
-  return ts11.namedType("$Utils.PayloadToResult").addGenericArgument(ts11.namedType(getPayloadName(modelName)));
+  return ts11.namedType("runtime.Types.Utils.PayloadToResult").addGenericArgument(ts11.namedType(getPayloadName(modelName)));
 }
 function clientTypeMapOthersDefinition(context) {
   const otherOperationsNames = context.dmmf.getOtherOperationNames().flatMap((name) => {
@@ -5228,25 +5077,26 @@ function clientTypeMapOthersDefinition(context) {
 function clientTypeMapDefinition(context) {
   const typeMap = `${ts11.stringify(clientTypeMapModelsDefinition(context))} & ${clientTypeMapOthersDefinition(context)}`;
   return `
-interface TypeMapCb<ClientOptions = {}> extends $Utils.Fn<{extArgs: $Extensions.InternalArgs }, $Utils.Record<string, any>> {
+export interface TypeMapCb<ClientOptions = {}> extends runtime.Types.Utils.Fn<{extArgs: runtime.Types.Extensions.InternalArgs }, runtime.Types.Utils.Record<string, any>> {
   returns: Prisma.TypeMap<this['params']['extArgs'], ClientOptions extends { omit: infer OmitOptions } ? OmitOptions : {}>
 }
 
-export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> = ${typeMap}`;
+export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = ${typeMap}`;
 }
 function clientExtensionsDefinitions(context) {
   const typeMap = clientTypeMapDefinition(context);
   const define = ts11.moduleExport(
-    ts11.constDeclaration(
-      "defineExtension",
-      ts11.namedType("$Extensions.ExtendsHook").addGenericArgument(ts11.stringLiteral("define")).addGenericArgument(ts11.namedType("Prisma.TypeMapCb")).addGenericArgument(ts11.namedType("$Extensions.DefaultArgs"))
+    ts11.constDeclaration("defineExtension").setValue(
+      ts11.namedValue("runtime.Extensions.defineExtension").as(ts11.namedType("unknown")).as(
+        ts11.namedType("runtime.Types.Extensions.ExtendsHook").addGenericArgument(ts11.stringLiteral("define")).addGenericArgument(ts11.namedType("Prisma.TypeMapCb")).addGenericArgument(ts11.namedType("runtime.Types.Extensions.DefaultArgs"))
+      )
     )
   );
   return [typeMap, ts11.stringify(define)].join("\n");
 }
 function extendsPropertyDefinition() {
-  const extendsDefinition = ts11.namedType("$Extensions.ExtendsHook").addGenericArgument(ts11.stringLiteral("extends")).addGenericArgument(ts11.namedType("Prisma.TypeMapCb").addGenericArgument(ts11.namedType("ClientOptions"))).addGenericArgument(ts11.namedType("ExtArgs")).addGenericArgument(
-    ts11.namedType("$Utils.Call").addGenericArgument(ts11.namedType("Prisma.TypeMapCb").addGenericArgument(ts11.namedType("ClientOptions"))).addGenericArgument(ts11.objectType().add(ts11.property("extArgs", ts11.namedType("ExtArgs"))))
+  const extendsDefinition = ts11.namedType("runtime.Types.Extensions.ExtendsHook").addGenericArgument(ts11.stringLiteral("extends")).addGenericArgument(ts11.namedType("Prisma.TypeMapCb").addGenericArgument(ts11.namedType("ClientOptions"))).addGenericArgument(ts11.namedType("ExtArgs")).addGenericArgument(
+    ts11.namedType("runtime.Types.Utils.Call").addGenericArgument(ts11.namedType("Prisma.TypeMapCb").addGenericArgument(ts11.namedType("ClientOptions"))).addGenericArgument(ts11.objectType().add(ts11.property("extArgs", ts11.namedType("ExtArgs"))))
   );
   return ts11.stringify(ts11.property("$extends", extendsDefinition), { indentLevel: 1 });
 }
@@ -5265,7 +5115,7 @@ function batchingTransactionDefinition(context) {
 
         Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions).
       `
-  ).addGenericParameter(ts11.genericParameter("P").extends(ts11.array(ts11.prismaPromise(ts11.anyType)))).addParameter(ts11.parameter("arg", ts11.arraySpread(ts11.namedType("P")))).setReturnType(ts11.promise(ts11.namedType("runtime.Types.Utils.UnwrapTuple").addGenericArgument(ts11.namedType("P"))));
+  ).addGenericParameter(ts11.genericParameter("P").extends(ts11.array(prismaPromise(ts11.anyType)))).addParameter(ts11.parameter("arg", ts11.arraySpread(ts11.namedType("P")))).setReturnType(promise(ts11.namedType("runtime.Types.Utils.UnwrapTuple").addGenericArgument(ts11.namedType("P"))));
   if (context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma")) {
     const options = ts11.objectType().formatInline().add(ts11.property("isolationLevel", ts11.namedType("Prisma.TransactionIsolationLevel")).optional());
     method3.addParameter(ts11.parameter("options", options).optional());
@@ -5278,7 +5128,7 @@ function interactiveTransactionDefinition(context) {
     const isolationLevel = ts11.property("isolationLevel", ts11.namedType("Prisma.TransactionIsolationLevel")).optional();
     options.add(isolationLevel);
   }
-  const returnType = ts11.promise(ts11.namedType("R"));
+  const returnType = promise(ts11.namedType("R"));
   const callbackType = ts11.functionType().addParameter(
     ts11.parameter("prisma", ts11.omit(ts11.namedType("PrismaClient"), ts11.namedType("runtime.ITXClientDenyList")))
   ).setReturnType(returnType);
@@ -5364,7 +5214,7 @@ function queryRawTypedDefinition(context) {
       "typedSql",
       runtimeImportedType("TypedSql").addGenericArgument(ts11.array(ts11.unknownType)).addGenericArgument(param.toArgument())
     )
-  ).setReturnType(ts11.prismaPromise(ts11.array(param.toArgument())));
+  ).setReturnType(prismaPromise(ts11.array(param.toArgument())));
   return ts11.stringify(method3, { indentLevel: 1, newLine: "leading" });
 }
 function metricDefinition(context) {
@@ -5389,7 +5239,7 @@ function runCommandRawDefinition(context) {
   if (!context.dmmf.mappings.otherOperations.write.includes("runCommandRaw")) {
     return "";
   }
-  const method3 = ts11.method("$runCommandRaw").addParameter(ts11.parameter("command", ts11.namedType("Prisma.InputJsonObject"))).setReturnType(ts11.prismaPromise(ts11.namedType("Prisma.JsonObject"))).setDocComment(ts11.docComment`
+  const method3 = ts11.method("$runCommandRaw").addParameter(ts11.parameter("command", ts11.namedType("Prisma.InputJsonObject"))).setReturnType(prismaPromise(ts11.namedType("Prisma.JsonObject"))).setDocComment(ts11.docComment`
       Executes a raw MongoDB command and returns the result of it.
       @example
       \`\`\`
@@ -5408,25 +5258,24 @@ function applyPendingMigrationsDefinition() {
   if (this.runtimeName !== "react-native") {
     return null;
   }
-  const method3 = ts11.method("$applyPendingMigrations").setReturnType(ts11.promise(ts11.voidType)).setDocComment(
+  const method3 = ts11.method("$applyPendingMigrations").setReturnType(promise(ts11.voidType)).setDocComment(
     ts11.docComment`Tries to apply pending migrations one by one. If a migration fails to apply, the function will stop and throw an error. You are responsible for informing the user and possibly blocking the app as we cannot guarantee the state of the database.`
   );
   return ts11.stringify(method3, { indentLevel: 1, newLine: "leading" });
 }
 function eventRegistrationMethodDeclaration(runtimeName) {
   if (runtimeName === "binary") {
-    return `$on<V extends (U | 'beforeExit')>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : V extends 'beforeExit' ? () => $Utils.JsPromise<void> : Prisma.LogEvent) => void): PrismaClient;`;
+    return `$on<V extends (U | 'beforeExit')>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : V extends 'beforeExit' ? () => runtime.Types.Utils.JsPromise<void> : Prisma.LogEvent) => void): PrismaClient;`;
   } else {
     return `$on<V extends U>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): PrismaClient;`;
   }
 }
 var PrismaClientClass = class {
-  constructor(context, internalDatasources, outputDir, runtimeName, browser) {
+  constructor(context, internalDatasources, outputDir, runtimeName) {
     this.context = context;
     this.internalDatasources = internalDatasources;
     this.outputDir = outputDir;
     this.runtimeName = runtimeName;
-    this.browser = browser;
   }
   get jsDoc() {
     const { dmmf } = this.context;
@@ -5440,44 +5289,49 @@ var PrismaClientClass = class {
       };
     }
     return `/**
- * ##  Prisma Client \u02B2\u02E2
+ * ## Prisma Client
  *
- * Type-safe database client for TypeScript & Node.js
+ * Type-safe database client for TypeScript
  * @example
  * \`\`\`
  * const prisma = new PrismaClient()
- * // Fetch zero or more ${capitalize2(example.plural)}
+ * // Fetch zero or more ${capitalize3(example.plural)}
  * const ${lowerCase7(example.plural)} = await prisma.${lowerCase7(example.model)}.findMany()
  * \`\`\`
  *
- *
  * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
  */`;
   }
   toTSWithoutNamespace() {
     const { dmmf } = this.context;
-    return `${this.jsDoc}
-export class PrismaClient<
+    return `interface PrismaClientConstructor {
+  ${indent6(this.jsDoc, TAB_SIZE)}
+  new <
+    ClientOptions extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
+    U = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never,
+    ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs
+  >(options?: Prisma.Subset<ClientOptions, Prisma.PrismaClientOptions>): PrismaClient<ClientOptions, U, ExtArgs>
+}
+
+${this.jsDoc}
+export interface PrismaClient<
   ClientOptions extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
   U = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never,
-  ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs
+  ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs
 > {
   [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['other'] }
 
-  ${indent7(this.jsDoc, TAB_SIZE)}
-
-  constructor(optionsArg ?: Prisma.Subset<ClientOptions, Prisma.PrismaClientOptions>);
   ${eventRegistrationMethodDeclaration(this.runtimeName)}
 
   /**
    * Connect with the database
    */
-  $connect(): $Utils.JsPromise<void>;
+  $connect(): runtime.Types.Utils.JsPromise<void>;
 
   /**
    * Disconnect from the database
    */
-  $disconnect(): $Utils.JsPromise<void>;
+  $disconnect(): runtime.Types.Utils.JsPromise<void>;
 
   /**
    * Add a middleware
@@ -5498,7 +5352,7 @@ ${[
       extendsPropertyDefinition()
     ].filter((d) => d !== null).join("\n").trim()}
 
-    ${indent7(
+    ${indent6(
       dmmf.mappings.modelOperations.filter((m) => m.findMany).map((m) => {
         let methodName = lowerCase7(m.model);
         if (methodName === "constructor") {
@@ -5509,7 +5363,7 @@ ${[
  * \`prisma.${methodName}\`: Exposes CRUD operations for the **${m.model}** model.
   * Example usage:
   * \`\`\`ts
-  * // Fetch zero or more ${capitalize2(m.plural)}
+  * // Fetch zero or more ${capitalize3(m.plural)}
   * const ${lowerCase7(m.plural)} = await prisma.${methodName}.findMany()
   * \`\`\`
   */
@@ -5517,7 +5371,9 @@ get ${methodName}(): Prisma.${m.model}Delegate<${generics.join(", ")}>;`;
       }).join("\n\n"),
       2
     )}
-}`;
+}
+
+export const PrismaClient = runtime.getPrismaClient(config) as unknown as PrismaClientConstructor`;
   }
   toTS() {
     const clientOptions = this.buildClientOptions();
@@ -5595,11 +5451,8 @@ export type MiddlewareParams = {
  */
 export type Middleware<T = any> = (
   params: MiddlewareParams,
-  next: (params: MiddlewareParams) => $Utils.JsPromise<T>,
-) => $Utils.JsPromise<T>
-
-// tested in getLogLevel.test.ts
-export function getLogLevel(log: Array<LogLevel | LogDefinition>): LogLevel | undefined;
+  next: (params: MiddlewareParams) => runtime.Types.Utils.JsPromise<T>,
+) => runtime.Types.Utils.JsPromise<T>
 
 /**
  * \`PrismaClient\` proxy available in interactive transactions.
@@ -5679,10 +5532,9 @@ var TSClient = class {
   }
   dmmf;
   genericsInfo;
-  toJS() {
+  toTS() {
     const {
       edge,
-      wasm,
       binaryPaths,
       generator,
       outputDir,
@@ -5690,14 +5542,11 @@ var TSClient = class {
       runtimeBase,
       runtimeName,
       datasources,
-      deno,
       copyEngine = true,
-      envPaths
+      target,
+      activeProvider,
+      moduleFormat
     } = this.options;
-    const relativeEnvPaths = {
-      rootEnvPath: envPaths.rootEnvPath && pathToPosix3(path2.relative(outputDir, envPaths.rootEnvPath)),
-      schemaEnvPath: envPaths.schemaEnvPath && pathToPosix3(path2.relative(outputDir, envPaths.schemaEnvPath))
-    };
     const clientEngineType = getClientEngineType(generator);
     generator.config.engineType = clientEngineType;
     const binaryTargets = clientEngineType === ClientEngineType2.Library ? Object.keys(binaryPaths.libqueryEngine ?? {}) : Object.keys(binaryPaths.queryEngine ?? {});
@@ -5705,8 +5554,7 @@ var TSClient = class {
     const datasourceFilePath = datasources[0].sourceFilePath;
     const config = {
       generator,
-      relativeEnvPaths,
-      relativePath: pathToPosix3(path2.relative(outputDir, path2.dirname(datasourceFilePath))),
+      relativePath: pathToPosix2(path2.relative(outputDir, path2.dirname(datasourceFilePath))),
       clientVersion: this.options.clientVersion,
       engineVersion: this.options.engineVersion,
       datasourceNames: datasources.map((d) => d.name),
@@ -5718,44 +5566,24 @@ var TSClient = class {
       }, {}),
       inlineSchema,
       inlineSchemaHash,
-      copyEngine
+      copyEngine,
+      runtimeDataModel: { models: {}, enums: {}, types: {} },
+      dirname: ""
     };
     const relativeOutdir = path2.relative(process.cwd(), outputDir);
-    const code = `${commonCodeJS({ ...this.options, browser: false })}
-${buildRequirePath(edge)}
-
-/**
- * Enums
- */
-${this.dmmf.schema.enumTypes.prisma?.map((type) => new Enum(type, true).toJS()).join("\n\n")}
-${this.dmmf.datamodel.enums.map((datamodelEnum) => new Enum(datamodelEnumToSchemaEnum(datamodelEnum), false).toJS()).join("\n\n")}
-
-${new Enum(
-      {
-        name: "ModelName",
-        values: this.dmmf.mappings.modelOperations.map((m) => m.model)
-      },
-      true
-    ).toJS()}
+    const clientConfig = `
 /**
  * Create the Client
  */
-const config = ${JSON.stringify(config, null, 2)}
-${buildDirname(edge, relativeOutdir)}
+const config: runtime.GetPrismaClientConfig = ${JSON.stringify(config, null, 2)}
+${buildDirname(edge)}
 ${buildRuntimeDataModel(this.dmmf.datamodel, runtimeName)}
-${buildQueryEngineWasmModule(wasm, copyEngine, runtimeName)}
-${buildQueryCompilerWasmModule(wasm, copyEngine, runtimeName)}
+${buildGetWasmModule({ component: "engine", runtimeBase, runtimeName, target, activeProvider, moduleFormat })}
+${buildGetWasmModule({ component: "compiler", runtimeBase, runtimeName, target, activeProvider, moduleFormat })}
 ${buildInjectableEdgeEnv(edge, datasources)}
-${buildWarnEnvConflicts(edge, runtimeBase, runtimeName)}
 ${buildDebugInitialization(edge)}
-const PrismaClient = getPrismaClient(config)
-exports.PrismaClient = PrismaClient
-Object.assign(exports, Prisma)${deno ? "\nexport { exports as default, Prisma, PrismaClient }" : ""}
 ${buildNFTAnnotations(edge || !copyEngine, clientEngineType, binaryTargets, relativeOutdir)}
 `;
-    return code;
-  }
-  toTS() {
     const context = new GenerateContext({
       dmmf: this.dmmf,
       genericArgsInfo: this.genericsInfo,
@@ -5765,8 +5593,7 @@ ${buildNFTAnnotations(edge || !copyEngine, clientEngineType, binaryTargets, rela
       context,
       this.options.datasources,
       this.options.outputDir,
-      this.options.runtimeName,
-      this.options.browser
+      this.options.runtimeName
     );
     const commonCode = commonCodeTS(this.options);
     const modelAndTypes = Object.values(this.dmmf.typeAndModelMap).reduce((acc, modelOrType) => {
@@ -5785,7 +5612,9 @@ ${buildNFTAnnotations(edge || !copyEngine, clientEngineType, binaryTargets, rela
           ts12.moduleExport(ts12.typeDeclaration(datamodelEnum.name, ts12.namedType(`$Enums.${datamodelEnum.name}`)))
         ),
         ts12.stringify(
-          ts12.moduleExport(ts12.constDeclaration(datamodelEnum.name, ts12.namedType(`typeof $Enums.${datamodelEnum.name}`)))
+          ts12.moduleExport(
+            ts12.constDeclaration(datamodelEnum.name).setValue(ts12.namedValue(`$Enums.${datamodelEnum.name}`))
+          )
         )
       );
     }
@@ -5794,7 +5623,7 @@ ${buildNFTAnnotations(edge || !copyEngine, clientEngineType, binaryTargets, rela
     const code = `
 /**
  * Client
-**/
+ */
 
 ${commonCode.tsWithoutNamespace()}
 
@@ -5809,10 +5638,13 @@ export namespace $Enums {
 
 ${modelEnumsAliases.join("\n\n")}
 ` : ""}
+
+${clientConfig}
+
 ${prismaClientClass.toTSWithoutNamespace()}
 
 export namespace Prisma {
-${indent8(
+${indent7(
       `${commonCode.ts()}
 ${new Enum(
         {
@@ -5881,70 +5713,11 @@ ${this.dmmf.inputObjectTypes.model?.map((inputType) => new InputType(inputType,
 export type BatchPayload = {
   count: number
 }
-
-/**
- * DMMF
- */
-export const dmmf: runtime.BaseDMMF
 `,
       2
     )}}`;
     return code;
   }
-  toBrowserJS() {
-    const code = `${commonCodeJS({
-      ...this.options,
-      runtimeName: "index-browser",
-      browser: true
-    })}
-/**
- * Enums
- */
-
-${this.dmmf.schema.enumTypes.prisma?.map((type) => new Enum(type, true).toJS()).join("\n\n")}
-${this.dmmf.schema.enumTypes.model?.map((type) => new Enum(type, false).toJS()).join("\n\n") ?? ""}
-
-${new Enum(
-      {
-        name: "ModelName",
-        values: this.dmmf.mappings.modelOperations.map((m) => m.model)
-      },
-      true
-    ).toJS()}
-
-/**
- * This is a stub Prisma Client that will error at runtime if called.
- */
-class PrismaClient {
-  constructor() {
-    return new Proxy(this, {
-      get(target, prop) {
-        let message
-        const runtime = getRuntime()
-        if (runtime.isEdge) {
-          message = \`PrismaClient is not configured to run in \${runtime.prettyName}. In order to run Prisma Client on edge runtime, either:
-- Use Prisma Accelerate: https://pris.ly/d/accelerate
-- Use Driver Adapters: https://pris.ly/d/driver-adapters
-\`;
-        } else {
-          message = 'PrismaClient is unable to run in this browser environment, or has been bundled for the browser (running in \`' + runtime.prettyName + '\`).'
-        }
-
-        message += \`
-If this is unexpected, please open an issue: https://pris.ly/prisma-prisma-bug-report\`
-
-        throw new Error(message)
-      }
-    })
-  }
-}
-
-exports.PrismaClient = PrismaClient
-
-Object.assign(exports, Prisma)
-`;
-    return code;
-  }
 };
 
 // src/typedSql/buildDbEnums.ts
@@ -5981,23 +5754,12 @@ var DbEnumsList = class {
 };
 function buildDbEnums(list) {
   const file4 = ts13.file();
-  file4.add(buildInvalidIdentifierEnums(list));
-  file4.add(buildValidIdentifierEnums(list));
-  return ts13.stringify(file4);
-}
-function buildValidIdentifierEnums(list) {
-  const namespace3 = ts13.namespace("$DbEnums");
-  for (const dbEnum of list.validJsIdentifiers()) {
-    namespace3.add(ts13.typeDeclaration(dbEnum.name, enumToUnion(dbEnum)));
-  }
-  return ts13.moduleExport(namespace3);
-}
-function buildInvalidIdentifierEnums(list) {
   const iface = ts13.interfaceDeclaration("$DbEnums");
-  for (const dbEnum of list.invalidJsIdentifiers()) {
+  for (const dbEnum of list.enums) {
     iface.add(ts13.property(dbEnum.name, enumToUnion(dbEnum)));
   }
-  return ts13.moduleExport(iface);
+  file4.add(ts13.moduleExport(iface));
+  return ts13.stringify(file4);
 }
 function enumToUnion(dbEnum) {
   return ts13.unionType(dbEnum.values.map(ts13.stringLiteral));
@@ -6011,41 +5773,21 @@ function queryUsesEnums(query, enums) {
 
 // src/typedSql/buildIndex.ts
 import * as ts14 from "@prisma/ts-builders";
-import { Writer } from "@prisma/ts-builders";
-function buildIndexTs(queries, enums) {
+function buildIndex({ queries, enums, importName }) {
   const file4 = ts14.file();
   if (!enums.isEmpty()) {
-    file4.add(ts14.moduleExportFrom("./$DbEnums").named("$DbEnums"));
+    file4.add(ts14.moduleExportFrom(importName("./sql/$DbEnums")).named(ts14.namedExport("$DbEnums").typeOnly()));
   }
   for (const query of queries) {
-    file4.add(ts14.moduleExportFrom(`./${query.name}`));
+    file4.add(ts14.moduleExportFrom(importName(`./sql/${query.name}`)));
   }
   return ts14.stringify(file4);
 }
-function buildIndexCjs(queries, edgeRuntimeSuffix) {
-  const writer = new Writer(0, void 0);
-  writer.writeLine('"use strict"');
-  for (const { name } of queries) {
-    const fileName = edgeRuntimeSuffix ? `${name}.${edgeRuntimeSuffix}` : name;
-    writer.writeLine(`exports.${name} = require("./${fileName}.js").${name}`);
-  }
-  return writer.toString();
-}
-function buildIndexEsm(queries, edgeRuntimeSuffix) {
-  const writer = new Writer(0, void 0);
-  for (const { name } of queries) {
-    const fileName = edgeRuntimeSuffix ? `${name}.${edgeRuntimeSuffix}` : name;
-    writer.writeLine(`export * from "./${fileName}.mjs"`);
-  }
-  return writer.toString();
-}
 
 // src/typedSql/buildTypedQuery.ts
 import * as ts16 from "@prisma/ts-builders";
-import { Writer as Writer2 } from "@prisma/ts-builders";
 
 // src/typedSql/mapTypes.ts
-import { isValidJsIdentifier as isValidJsIdentifier2 } from "@prisma/internals";
 import * as ts15 from "@prisma/ts-builders";
 var decimal = ts15.namedType("$runtime.Decimal");
 var uint8Array = ts15.namedType("Uint8Array");
@@ -6139,18 +5881,15 @@ function getMappingConfig(introspectionType, enums) {
   return config;
 }
 function getEnumType(name) {
-  if (isValidJsIdentifier2(name)) {
-    return ts15.namedType(`$DbEnums.${name}`);
-  }
   return ts15.namedType("$DbEnums").subKey(name);
 }
 
 // src/typedSql/buildTypedQuery.ts
-function buildTypedQueryTs({ query, runtimeBase, runtimeName, enums }) {
+function buildTypedQuery({ query, runtimeBase, runtimeName, enums, importName }) {
   const file4 = ts16.file();
   file4.addImport(ts16.moduleImport(`${runtimeBase}/${runtimeName}`).asNamespace("$runtime"));
   if (queryUsesEnums(query, enums)) {
-    file4.addImport(ts16.moduleImport("./$DbEnums").named("$DbEnums"));
+    file4.addImport(ts16.moduleImport(importName("./$DbEnums")).named(ts16.namedImport("$DbEnums").typeOnly()));
   }
   const doc = ts16.docComment(query.documentation ?? void 0);
   const factoryType = ts16.functionType();
@@ -6168,11 +5907,17 @@ function buildTypedQueryTs({ query, runtimeBase, runtimeName, enums }) {
   factoryType.setReturnType(
     ts16.namedType("$runtime.TypedSql").addGenericArgument(ts16.namedType(`${query.name}.Parameters`)).addGenericArgument(ts16.namedType(`${query.name}.Result`))
   );
-  file4.add(ts16.moduleExport(ts16.constDeclaration(query.name, factoryType)).setDocComment(doc));
-  const namespace3 = ts16.namespace(query.name);
-  namespace3.add(ts16.moduleExport(ts16.typeDeclaration("Parameters", parametersType)));
-  namespace3.add(buildResultType(query, enums));
-  file4.add(ts16.moduleExport(namespace3));
+  file4.add(
+    ts16.moduleExport(
+      ts16.constDeclaration(query.name).setValue(
+        ts16.functionCall("$runtime.makeTypedQueryFactory").addArgument(ts16.stringLiteral(query.source).asValue()).as(factoryType)
+      )
+    ).setDocComment(doc)
+  );
+  const namespace2 = ts16.namespace(query.name);
+  namespace2.add(ts16.moduleExport(ts16.typeDeclaration("Parameters", parametersType)));
+  namespace2.add(buildResultType(query, enums));
+  file4.add(ts16.moduleExport(namespace2));
   return ts16.stringify(file4);
 }
 function buildResultType(query, enums) {
@@ -6181,47 +5926,28 @@ function buildResultType(query, enums) {
   );
   return ts16.moduleExport(ts16.typeDeclaration("Result", type));
 }
-function buildTypedQueryCjs({ query, runtimeBase, runtimeName }) {
-  const writer = new Writer2(0, void 0);
-  writer.writeLine('"use strict"');
-  writer.writeLine(`const { makeTypedQueryFactory: $mkFactory } = require("${runtimeBase}/${runtimeName}")`);
-  writer.writeLine(`exports.${query.name} = /*#__PURE__*/ $mkFactory(${JSON.stringify(query.source)})`);
-  return writer.toString();
-}
-function buildTypedQueryEsm({ query, runtimeBase, runtimeName }) {
-  const writer = new Writer2(0, void 0);
-  writer.writeLine(`import { makeTypedQueryFactory as $mkFactory } from "${runtimeBase}/${runtimeName}"`);
-  writer.writeLine(`export const ${query.name} = /*#__PURE__*/ $mkFactory(${JSON.stringify(query.source)})`);
-  return writer.toString();
-}
 
 // src/typedSql/typedSql.ts
 function buildTypedSql({
   queries,
   runtimeBase,
-  edgeRuntimeName,
-  mainRuntimeName,
-  dmmf
+  runtimeName,
+  dmmf,
+  outputName,
+  importName
 }) {
-  const fileMap = {};
+  const fileMap = {
+    sql: {}
+  };
   const enums = new DbEnumsList(dmmf.datamodel.enums);
   if (!enums.isEmpty()) {
-    fileMap["$DbEnums.d.ts"] = buildDbEnums(enums);
+    fileMap.sql[outputName("$DbEnums")] = buildDbEnums(enums);
   }
   for (const query of queries) {
-    const options = { query, runtimeBase, runtimeName: mainRuntimeName, enums };
-    const edgeOptions = { ...options, runtimeName: `${edgeRuntimeName}.js` };
-    fileMap[`${query.name}.d.ts`] = buildTypedQueryTs(options);
-    fileMap[`${query.name}.js`] = buildTypedQueryCjs(options);
-    fileMap[`${query.name}.${edgeRuntimeName}.js`] = buildTypedQueryCjs(edgeOptions);
-    fileMap[`${query.name}.mjs`] = buildTypedQueryEsm(options);
-    fileMap[`${query.name}.edge.mjs`] = buildTypedQueryEsm(edgeOptions);
-  }
-  fileMap["index.d.ts"] = buildIndexTs(queries, enums);
-  fileMap["index.js"] = buildIndexCjs(queries);
-  fileMap["index.mjs"] = buildIndexEsm(queries);
-  fileMap[`index.${edgeRuntimeName}.mjs`] = buildIndexEsm(queries, edgeRuntimeName);
-  fileMap[`index.${edgeRuntimeName}.js`] = buildIndexCjs(queries, edgeRuntimeName);
+    const options = { query, runtimeBase, runtimeName, enums, importName };
+    fileMap.sql[outputName(query.name)] = buildTypedQuery(options);
+  }
+  fileMap[outputName("sql")] = buildIndex({ queries, enums, importName });
   return fileMap;
 }
 
@@ -6248,10 +5974,17 @@ function buildClient({
   postinstall,
   copyEngine,
   envPaths,
-  typedSql
+  typedSql,
+  target,
+  generatedFileExtension,
+  importFileExtension,
+  moduleFormat
 }) {
   const clientEngineType = getClientEngineType2(generator);
-  const baseClientOptions = {
+  const runtimeName = getRuntimeNameForTarget(target, clientEngineType, generator.previewFeatures);
+  const outputName = generatedFileNameMapper(generatedFileExtension);
+  const importName = importFileNameMapper(importFileExtension);
+  const clientOptions = {
     dmmf: getPrismaClientDMMF(dmmf),
     envPaths: envPaths ?? { rootEnvPath: null, schemaEnvPath: void 0 },
     datasources,
@@ -6266,89 +5999,32 @@ function buildClient({
     postinstall,
     copyEngine,
     datamodel,
-    browser: false,
-    deno: false,
-    edge: false,
-    wasm: false
-  };
-  const nodeClientOptions = {
-    ...baseClientOptions,
-    runtimeName: getNodeRuntimeName(clientEngineType)
+    edge: ["edge", "wasm", "react-native"].includes(runtimeName),
+    runtimeName,
+    target,
+    generatedFileExtension,
+    importFileExtension,
+    moduleFormat
   };
-  const nodeClient = new TSClient(nodeClientOptions);
-  const defaultClient = new TSClient({
-    ...nodeClientOptions
-  });
-  const edgeClient = new TSClient({
-    ...baseClientOptions,
-    runtimeName: "edge",
-    edge: true
-  });
-  const rnTsClient = new TSClient({
-    ...baseClientOptions,
-    runtimeName: "react-native",
-    edge: true
-  });
-  const fileMap = {};
-  fileMap["index.js"] = JS(nodeClient);
-  fileMap["index.d.ts"] = TS(nodeClient);
-  fileMap["default.js"] = JS(defaultClient);
-  fileMap["default.d.ts"] = TS(defaultClient);
-  fileMap["index-browser.js"] = BrowserJS(nodeClient);
-  fileMap["edge.js"] = JS(edgeClient);
-  fileMap["edge.d.ts"] = TS(edgeClient);
-  fileMap["client.js"] = JS(defaultClient);
-  fileMap["client.d.ts"] = TS(defaultClient);
-  if (generator.previewFeatures.includes("reactNative")) {
-    fileMap["react-native.js"] = JS(rnTsClient);
-    fileMap["react-native.d.ts"] = TS(rnTsClient);
-  }
-  const usesWasmRuntime = generator.previewFeatures.includes("driverAdapters");
-  if (usesWasmRuntime) {
-    const usesClientEngine = clientEngineType === ClientEngineType3.Client;
-    if (usesClientEngine) {
-      fileMap["wasm-worker-loader.mjs"] = `export default import('./query_compiler_bg.wasm')`;
-      fileMap["wasm-edge-light-loader.mjs"] = `export default import('./query_compiler_bg.wasm?module')`;
-    } else {
-      fileMap["wasm-worker-loader.mjs"] = `export default import('./query_engine_bg.wasm')`;
-      fileMap["wasm-edge-light-loader.mjs"] = `export default import('./query_engine_bg.wasm?module')`;
-    }
-    const wasmClient = new TSClient({
-      ...baseClientOptions,
-      runtimeName: "wasm",
-      edge: true,
-      wasm: true
-    });
-    fileMap["wasm.js"] = JS(wasmClient);
-    fileMap["wasm.d.ts"] = TS(wasmClient);
-  } else {
-    fileMap["wasm.js"] = fileMap["index-browser.js"];
-    fileMap["wasm.d.ts"] = fileMap["default.d.ts"];
-  }
-  if (generator.previewFeatures.includes("deno") && !!globalThis.Deno) {
-    const denoEdgeClient = new TSClient({
-      ...baseClientOptions,
-      runtimeBase: `../${runtimeBase}`,
-      runtimeName: "edge",
-      deno: true,
-      edge: true
-    });
-    fileMap["deno/edge.js"] = JS(denoEdgeClient);
-    fileMap["deno/index.d.ts"] = TS(denoEdgeClient);
-    fileMap["deno/edge.ts"] = `
-import './polyfill.js'
-// @deno-types="./index.d.ts"
-export * from './edge.js'`;
-    fileMap["deno/polyfill.js"] = "globalThis.process = { env: Deno.env.toObject() }; globalThis.global = globalThis";
+  if (runtimeName === "react-native" && !generator.previewFeatures.includes("reactNative")) {
+    throw new Error(`Using the "react-native" runtime requires the "reactNative" preview feature to be enabled.`);
   }
+  const client = new TSClient(clientOptions);
+  let fileMap = {};
+  fileMap[outputName("client")] = client.toTS();
+  fileMap[outputName("index")] = `export * from '${importName("./client")}'`;
   if (typedSql && typedSql.length > 0) {
-    fileMap["sql"] = buildTypedSql({
-      dmmf,
-      runtimeBase: getTypedSqlRuntimeBase(runtimeBase),
-      mainRuntimeName: getNodeRuntimeName(clientEngineType),
-      queries: typedSql,
-      edgeRuntimeName: usesWasmRuntime ? "wasm" : "edge"
-    });
+    fileMap = {
+      ...fileMap,
+      ...buildTypedSql({
+        dmmf,
+        runtimeBase: getTypedSqlRuntimeBase(runtimeBase),
+        runtimeName,
+        queries: typedSql,
+        outputName,
+        importName
+      })
+    };
   }
   return {
     fileMap,
@@ -6380,7 +6056,11 @@ async function generateClient(options) {
     postinstall,
     envPaths,
     copyEngine = true,
-    typedSql
+    typedSql,
+    target,
+    generatedFileExtension,
+    importFileExtension,
+    moduleFormat
   } = options;
   const clientEngineType = getClientEngineType2(generator);
   const { runtimeBase, outputDir } = await getGenerationDirs(options);
@@ -6399,7 +6079,11 @@ async function generateClient(options) {
     postinstall,
     copyEngine,
     envPaths,
-    typedSql
+    typedSql,
+    target,
+    generatedFileExtension,
+    importFileExtension,
+    moduleFormat
   });
   const denylistsErrors = validateDmmfAgainstDenylists(prismaClientDmmf);
   if (denylistsErrors) {
@@ -6416,40 +6100,23 @@ To learn more about how to rename models, check out https://pris.ly/d/naming-mod
   }
   await deleteOutputDir(outputDir);
   await (0, import_fs_extra.ensureDir)(outputDir);
-  if (generator.previewFeatures.includes("deno") && !!globalThis.Deno) {
-    await (0, import_fs_extra.ensureDir)(path3.join(outputDir, "deno"));
-  }
   await writeFileMap(outputDir, fileMap);
   const enginePath = clientEngineType === ClientEngineType3.Library ? binaryPaths.libqueryEngine : binaryPaths.queryEngine;
-  if (!enginePath) {
-    throw new Error(
-      `Prisma Client needs \`${clientEngineType === ClientEngineType3.Library ? "libqueryEngine" : "queryEngine"}\` in the \`binaryPaths\` object.`
-    );
-  }
-  if (copyEngine) {
+  if (copyEngine && enginePath) {
     if (process.env.NETLIFY) {
       await (0, import_fs_extra.ensureDir)("/tmp/prisma-engines");
     }
     for (const [binaryTarget, filePath] of Object.entries(enginePath)) {
       const fileName = path3.basename(filePath);
-      let target;
+      let target2;
       if (process.env.NETLIFY && !["rhel-openssl-1.0.x", "rhel-openssl-3.0.x"].includes(binaryTarget)) {
-        target = path3.join("/tmp/prisma-engines", fileName);
+        target2 = path3.join("/tmp/prisma-engines", fileName);
       } else {
-        target = path3.join(outputDir, fileName);
+        target2 = path3.join(outputDir, fileName);
       }
-      await overwriteFile(filePath, target);
+      await overwriteFile(filePath, target2);
     }
   }
-  const schemaTargetPath = path3.join(outputDir, "schema.prisma");
-  await fs.writeFile(schemaTargetPath, datamodel, { encoding: "utf-8" });
-  try {
-    const prismaCache = paths("prisma").cache;
-    const signalsPath = path3.join(prismaCache, "last-generate");
-    await fs.mkdir(prismaCache, { recursive: true });
-    await fs.writeFile(signalsPath, Date.now().toString());
-  } catch {
-  }
 }
 function writeFileMap(outputDir, fileMap) {
   return Promise.all(
@@ -6544,7 +6211,7 @@ function validateDmmfAgainstDenylists(prismaClientDmmf) {
 }
 async function getGenerationDirs({ runtimeBase, outputDir }) {
   const normalizedOutputDir = path3.normalize(outputDir);
-  const normalizedRuntimeBase = pathToPosix4(runtimeBase);
+  const normalizedRuntimeBase = pathToPosix3(runtimeBase);
   const userPackageRoot = await pkgUp({ cwd: path3.dirname(normalizedOutputDir) });
   const userProjectRoot = userPackageRoot ? path3.dirname(userPackageRoot) : process.cwd();
   return {
@@ -6553,6 +6220,26 @@ async function getGenerationDirs({ runtimeBase, outputDir }) {
     projectRoot: userProjectRoot
   };
 }
+function getRuntimeNameForTarget(target, engineType, previewFeatures) {
+  switch (target) {
+    case "nodejs":
+    case "deno":
+    case "bun":
+      return getNodeRuntimeName(engineType);
+    case "workerd":
+    case "edge-light":
+    case "deno-deploy":
+      if (previewFeatures.includes("driverAdapters")) {
+        return "wasm";
+      } else {
+        return "edge";
+      }
+    case "react-native":
+      return "react-native";
+    default:
+      assertNever3(target, "Unknown runtime target");
+  }
+}
 function getNodeRuntimeName(engineType) {
   if (engineType === ClientEngineType3.Binary) {
     return "binary";
@@ -6576,15 +6263,13 @@ async function deleteOutputDir(outputDir) {
     if (files.length === 0) {
       return;
     }
-    if (!files.includes("client.d.ts")) {
+    if (!files.includes("client.ts") && !files.includes("client.mts") && !files.includes("client.cts")) {
       throw new Error(
         `${outputDir} exists and is not empty but doesn't look like a generated Prisma Client. Please check your output path and remove the existing directory if you indeed want to generate the Prisma Client in that location.`
       );
     }
     await Promise.allSettled(
-      (await glob(`${outputDir}/**/*.ts`, {
-        globstar: true,
-        onlyFiles: true,
+      (await glob([`${outputDir}/**/*.{ts,mts,cts}`, `${outputDir}/*.node`, `${outputDir}/{query,schema}-engine-*`], {
         followSymbolicLinks: false
       })).map(fs.unlink)
     );
@@ -6596,13 +6281,88 @@ async function deleteOutputDir(outputDir) {
 }
 
 // src/generator.ts
-import Debug from "@prisma/debug";
+import { Debug } from "@prisma/debug";
 import { enginesVersion } from "@prisma/engines-version";
 import { ClientEngineType as ClientEngineType4, getClientEngineType as getClientEngineType3, parseEnvValue } from "@prisma/internals";
-import { match } from "ts-pattern";
+import { getTsconfig } from "get-tsconfig";
+import { match as match2 } from "ts-pattern";
 
 // package.json
-var version = "6.6.0-dev.95";
+var version = "6.6.0-dev.97";
+
+// src/module-format.ts
+function parseModuleFormat(format) {
+  switch (format.toLowerCase()) {
+    case "cjs":
+    case "commonjs":
+      return "cjs";
+    case "esm":
+      return "esm";
+    default:
+      throw new Error(`Invalid module format: "${format}", expected "esm" or "cjs"`);
+  }
+}
+function parseModuleFormatFromUnknown(value) {
+  if (typeof value === "string") {
+    return parseModuleFormat(value);
+  } else {
+    throw new Error(`Invalid module format: ${JSON.stringify(value)}, expected "esm" or "cjs"`);
+  }
+}
+function inferModuleFormat({
+  tsconfig,
+  generatedFileExtension,
+  importFileExtension
+}) {
+  if (tsconfig?.compilerOptions?.module) {
+    return fromTsConfigModule(tsconfig.compilerOptions.module);
+  }
+  if (generatedFileExtension === "cts" || importFileExtension === "cjs") {
+    return "cjs";
+  }
+  return "esm";
+}
+function fromTsConfigModule(module) {
+  const normalizedModule = module.toLowerCase();
+  if (normalizedModule === "commonjs") {
+    return "cjs";
+  }
+  return "esm";
+}
+
+// src/runtime-targets.ts
+var supportedRuntimes = ["nodejs", "deno", "deno-deploy", "bun", "workerd", "edge-light", "react-native"];
+function parseRuntimeTarget(target) {
+  switch (target.toLowerCase()) {
+    case "node":
+    case "nodejs":
+      return "nodejs";
+    case "deno":
+      return "deno";
+    case "deno-deploy":
+      return "deno-deploy";
+    case "bun":
+      return "bun";
+    case "workerd":
+    case "cloudflare":
+      return "workerd";
+    case "edge-light":
+    case "vercel":
+      return "edge-light";
+    case "react-native":
+      return "react-native";
+    default:
+      throw new Error(
+        `Unknown target runtime: "${target}". The available options are: ${supportedRuntimes.map((runtime) => `"${runtime}"`).join(", ")}`
+      );
+  }
+}
+function parseRuntimeTargetFromUnknown(target) {
+  if (typeof target !== "string") {
+    throw new Error(`Invalid target runtime: ${JSON.stringify(target)}. Expected a string.`);
+  }
+  return parseRuntimeTarget(target);
+}
 
 // src/generator.ts
 var debug = Debug("prisma:client:generator");
@@ -6624,7 +6384,7 @@ function getOutputPath(config) {
 var PrismaClientTsGenerator = class {
   name = "prisma-client-ts";
   getManifest(config) {
-    const requiresEngines = match(getClientEngineType3(config)).with(ClientEngineType4.Library, () => ["libqueryEngine"]).with(ClientEngineType4.Binary, () => ["queryEngine"]).with(ClientEngineType4.Client, () => []).exhaustive();
+    const requiresEngines = match2(getClientEngineType3(config)).with(ClientEngineType4.Library, () => ["libqueryEngine"]).with(ClientEngineType4.Binary, () => ["queryEngine"]).with(ClientEngineType4.Client, () => []).exhaustive();
     debug("requiresEngines", requiresEngines);
     return Promise.resolve({
       defaultOutput: getOutputPath(config),
@@ -6635,13 +6395,27 @@ var PrismaClientTsGenerator = class {
     });
   }
   async generate(options) {
+    const { config } = options.generator;
+    const outputDir = getOutputPath(options.generator);
+    const tsconfig = getTsconfig(outputDir)?.config;
+    const target = config.runtime !== void 0 ? parseRuntimeTargetFromUnknown(config.runtime) : "nodejs";
+    const generatedFileExtension = config.generatedFileExtension !== void 0 ? parseGeneratedFileExtension(config.generatedFileExtension) : "ts";
+    const importFileExtension = config.importFileExtension !== void 0 ? parseImportFileExtension(config.importFileExtension) : inferImportFileExtension({
+      tsconfig,
+      generatedFileExtension
+    });
+    const moduleFormat = config.moduleFormat !== void 0 ? parseModuleFormatFromUnknown(config.moduleFormat) : inferModuleFormat({
+      tsconfig,
+      generatedFileExtension,
+      importFileExtension
+    });
     await generateClient({
       datamodel: options.datamodel,
       schemaPath: options.schemaPath,
       binaryPaths: options.binaryPaths,
       datasources: options.datasources,
       envPaths: options.envPaths,
-      outputDir: getOutputPath(options.generator),
+      outputDir,
       runtimeBase: "@prisma/client/runtime",
       dmmf: options.dmmf,
       generator: options.generator,
@@ -6650,48 +6424,16 @@ var PrismaClientTsGenerator = class {
       activeProvider: options.datasources[0]?.activeProvider,
       postinstall: options.postinstall,
       copyEngine: !options.noEngine,
-      typedSql: options.typedSql
+      typedSql: options.typedSql,
+      target,
+      generatedFileExtension,
+      importFileExtension,
+      moduleFormat
     });
   }
 };
-
-// src/utils/types/dmmfToTypes.ts
-function dmmfToTypes(dmmf) {
-  return new TSClient({
-    dmmf,
-    datasources: [],
-    clientVersion: "",
-    engineVersion: "",
-    runtimeBase: "@prisma/client",
-    runtimeName: "library",
-    schemaPath: "",
-    outputDir: "",
-    activeProvider: "",
-    binaryPaths: {},
-    generator: {
-      binaryTargets: [],
-      config: {},
-      name: "prisma-client-ts",
-      output: null,
-      provider: { value: "prisma-client-ts", fromEnvVar: null },
-      previewFeatures: [],
-      isCustomOutput: false,
-      sourceFilePath: "schema.prisma"
-    },
-    datamodel: "",
-    browser: false,
-    deno: false,
-    edge: false,
-    wasm: false,
-    envPaths: {
-      rootEnvPath: null,
-      schemaEnvPath: void 0
-    }
-  }).toTS();
-}
 export {
   PrismaClientTsGenerator,
-  dmmfToTypes,
   externalToInternalDmmf,
   generateClient,
   getDMMF