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

package/dist/index.js

@@ -2170,7 +2170,6 @@ var require_lib = __commonJS({
 var index_exports = {};
 __export(index_exports, {
   PrismaClientTsGenerator: () => PrismaClientTsGenerator,
-  dmmfToTypes: () => dmmfToTypes,
   externalToInternalDmmf: () => externalToInternalDmmf,
   generateClient: () => generateClient,
   getDMMF: () => getDMMF
@@ -2224,10 +2223,9 @@ function getMappings(mappings, datamodel) {
 
 // src/generateClient.ts
 var import_promises = __toESM(require("node:fs/promises"));
-var import_node_path = __toESM(require("node:path"));
+var import_node_path2 = __toESM(require("node:path"));
 var import_fetch_engine = require("@prisma/fetch-engine");
-var import_internals10 = require("@prisma/internals");
-var import_env_paths = __toESM(require("env-paths"));
+var import_internals8 = require("@prisma/internals");
 var import_fast_glob = require("fast-glob");
 var import_fs_extra = __toESM(require_lib());
 
@@ -2282,6 +2280,75 @@ var bgWhite = init(47, 49);
 // src/generateClient.ts
 var import_pkg_up = __toESM(require("pkg-up"));
 
+// src/file-extensions.ts
+var import_client_common2 = require("@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(
+      `${(0, import_client_common2.capitalize)(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 module2 = tsconfig.compilerOptions?.module?.toLowerCase();
+  if (moduleResolution !== void 0 && moduleResolution !== "classic" && module2 === "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
 var import_internals = require("@prisma/internals");
 function getPrismaClientDMMF(dmmf) {
@@ -2293,7 +2360,7 @@ async function getDMMF(options) {
 }
 
 // src/TSClient/Enum.ts
-var import_client_common2 = require("@prisma/client-common");
+var import_client_common3 = require("@prisma/client-common");
 var import_indent_string = __toESM(require("indent-string"));
 
 // src/TSClient/constants.ts
@@ -2306,49 +2373,29 @@ var Enum = class {
     this.useNamespace = useNamespace;
   }
   isObjectEnum() {
-    return this.useNamespace && import_client_common2.objectEnumNames.includes(this.type.name);
+    return this.useNamespace && import_client_common3.objectEnumNames.includes(this.type.name);
   }
   isStrictEnum() {
-    return this.useNamespace && import_client_common2.strictEnumNames.includes(this.type.name);
-  }
-  toJS() {
-    const { type } = this;
-    const enumVariants = `{
-${(0, import_indent_string.default)(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}'`;
+    return this.useNamespace && import_client_common3.strictEnumNames.includes(this.type.name);
   }
   toTS() {
     const { type } = this;
-    return `export const ${type.name}: {
-${(0, import_indent_string.default)(type.values.map((v) => `${v}: ${this.getValueTS(v)}`).join(",\n"), TAB_SIZE)}
-};
+    const enumVariants = `{
+${(0, import_indent_string.default)(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
-var import_client_common3 = require("@prisma/client-common");
+var import_client_common4 = require("@prisma/client-common");
 var ts2 = __toESM(require("@prisma/ts-builders"));
 var import_indent_string2 = __toESM(require("indent-string"));
 
@@ -2384,28 +2431,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");
@@ -2414,13 +2461,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) {
@@ -2478,8 +2525,8 @@ function getModelArgName(modelName, action) {
       (0, import_internals2.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`;
@@ -2487,7 +2534,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) {
@@ -2499,11 +2546,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) {
@@ -2620,7 +2667,7 @@ var InputType = class {
   toTS() {
     const { type } = this;
     const source = type.meta?.source;
-    const fields = (0, import_client_common3.uniqueBy)(type.fields, (f) => f.name);
+    const fields = (0, import_client_common4.uniqueBy)(type.fields, (f) => f.name);
     const body = `{
 ${(0, import_indent_string2.default)(
       fields.map((arg) => {
@@ -2661,11 +2708,11 @@ var import_klona = require("klona");
 var ts3 = __toESM(require("@prisma/ts-builders"));
 
 // src/TSClient/helpers.ts
-var import_client_common5 = require("@prisma/client-common");
+var import_client_common6 = require("@prisma/client-common");
 var import_pluralize2 = __toESM(require("pluralize"));
 
 // src/TSClient/jsdoc.ts
-var import_client_common4 = require("@prisma/client-common");
+var import_client_common5 = require("@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}`,
@@ -2738,7 +2785,7 @@ const ${ctx.singular} = await ${ctx.method}({
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to create many ${ctx.plural}.
 @example
 // Create many ${ctx.plural}
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
   data: [
     // ... provide data here
   ]
@@ -2752,7 +2799,7 @@ const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.m
     body: (ctx) => {
       const onlySelect = ctx.firstScalar ? `
 // Create many ${ctx.plural} and only return the \`${ctx.firstScalar.name}\`
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)}With${(0, import_client_common4.capitalize)(ctx.firstScalar.name)}Only = await ${ctx.method}({
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)}With${(0, import_client_common5.capitalize)(ctx.firstScalar.name)}Only = await ${ctx.method}({
   select: { ${ctx.firstScalar.name}: true },
   data: [
     // ... provide data here
@@ -2762,7 +2809,7 @@ const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)}With${(0, import
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to create many ${ctx.plural}.
 @example
 // Create many ${ctx.plural}
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
   data: [
     // ... provide data here
   ]
@@ -2780,7 +2827,7 @@ ${undefinedNote}
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to find a ${ctx.singular}
 @example
 // Get one ${ctx.singular}
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
   where: {
     // ... provide filter here
   }
@@ -2795,7 +2842,7 @@ if no matches were found.
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to find a ${ctx.singular}
 @example
 // Get one ${ctx.singular}
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
   where: {
     // ... provide filter here
   }
@@ -2810,7 +2857,7 @@ ${undefinedNote}
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to find a ${ctx.singular}
 @example
 // Get one ${ctx.singular}
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
   where: {
     // ... provide filter here
   }
@@ -2831,7 +2878,7 @@ ${undefinedNote}
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to find a ${ctx.singular}
 @example
 // Get one ${ctx.singular}
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
   where: {
     // ... provide filter here
   }
@@ -2849,7 +2896,7 @@ const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.m
     body: (ctx) => {
       const onlySelect = ctx.firstScalar ? `
 // Only select the \`${ctx.firstScalar.name}\`
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)}With${(0, import_client_common4.capitalize)(ctx.firstScalar.name)}Only = await ${ctx.method}({ select: { ${ctx.firstScalar.name}: true } })` : "";
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)}With${(0, import_client_common5.capitalize)(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.
@@ -2875,7 +2922,7 @@ ${onlySelect}
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to update one ${ctx.singular}.
 @example
 // Update one ${ctx.singular}
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
   where: {
     // ... provide filter here
   },
@@ -2894,7 +2941,7 @@ const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.m
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to update or create a ${ctx.singular}.
 @example
 // Update or create a ${ctx.singular}
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
   create: {
     // ... data to create a ${ctx.singular}
   },
@@ -2988,7 +3035,7 @@ ${undefinedNote}
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to update one or more rows.
 @example
 // Update many ${ctx.plural}
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
   where: {
     // ... provide filter here
   },
@@ -3007,7 +3054,7 @@ const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.m
     body: (ctx) => {
       const onlySelect = ctx.firstScalar ? `
 // Update zero or more ${ctx.plural} and only return the \`${ctx.firstScalar.name}\`
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)}With${(0, import_client_common4.capitalize)(ctx.firstScalar.name)}Only = await ${ctx.method}({
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)}With${(0, import_client_common5.capitalize)(ctx.firstScalar.name)}Only = await ${ctx.method}({
   select: { ${ctx.firstScalar.name}: true },
   where: {
     // ... provide filter here
@@ -3020,7 +3067,7 @@ const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)}With${(0, import
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to update many ${ctx.plural}.
 @example
 // Update many ${ctx.plural}
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
   where: {
     // ... provide filter here
   },
@@ -3058,7 +3105,7 @@ const { count } = await ${ctx.method}({
     body: (ctx) => `Perform aggregation operations on a ${ctx.singular}.
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Select which aggregations you would like to apply.
 @example
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
   pipeline: [
     { $match: { status: "registered" } },
     { $group: { _id: "$country", total: { $sum: 1 } } }
@@ -3073,7 +3120,7 @@ const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.m
     body: (ctx) => `Find zero or more ${ctx.plural} that matches the filter.
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Select which filters you would like to apply.
 @example
-const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
+const ${(0, import_client_common5.lowerCase)(ctx.mapping.model)} = await ${ctx.method}({
   filter: { age: { $gt: 25 } }
 })`,
     fields: {
@@ -3086,10 +3133,10 @@ const ${(0, import_client_common4.lowerCase)(ctx.mapping.model)} = await ${ctx.m
 // src/TSClient/helpers.ts
 function getMethodJSDocBody(action, mapping, model) {
   const ctx = {
-    singular: (0, import_client_common5.capitalize)(mapping.model),
-    plural: (0, import_client_common5.capitalize)(mapping.plural),
+    singular: (0, import_client_common6.capitalize)(mapping.model),
+    plural: (0, import_client_common6.capitalize)(mapping.plural),
     firstScalar: model.fields.find((f) => f.kind === "scalar"),
-    method: `prisma.${(0, import_client_common5.lowerCase)(mapping.model)}.${action}`,
+    method: `prisma.${(0, import_client_common6.lowerCase)(mapping.model)}.${action}`,
     action,
     mapping,
     model
@@ -3131,7 +3178,6 @@ var ArgsTypeBuilder = class {
     ).setDocComment(ts3.docComment(`${type.name} ${action ?? "without action"}`));
   }
   moduleExport;
-  hasDefaultName = true;
   addProperty(prop) {
     this.moduleExport.declaration.type.add(prop);
   }
@@ -3181,7 +3227,6 @@ var ArgsTypeBuilder = class {
     return this;
   }
   setGeneratedName(name) {
-    this.hasDefaultName = false;
     this.moduleExport.declaration.setName(name);
     return this;
   }
@@ -3206,7 +3251,7 @@ var ModelFieldRefs = class {
 /**
  * Fields of the ${name} model
  */
-interface ${getFieldRefsTypeName(name)} {
+export interface ${getFieldRefsTypeName(name)} {
 ${this.stringifyFields()}
 }
     `;
@@ -3281,12 +3326,12 @@ 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
-var import_client_common6 = require("@prisma/client-common");
+var import_client_common7 = require("@prisma/client-common");
 var ts5 = __toESM(require("@prisma/ts-builders"));
 function buildModelPayload(model, context) {
   const isComposite = context.dmmf.isComposite(model.name);
@@ -3304,7 +3349,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((0, import_client_common6.lowerCase)(model.name)));
+  const scalarsType = isComposite ? scalars : ts5.namedType("runtime.Types.Extensions.GetPayloadResult").addGenericArgument(scalars).addGenericArgument(ts5.namedType("ExtArgs").subKey("result").subKey((0, import_client_common7.lowerCase)(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))
@@ -3316,7 +3361,7 @@ function buildModelPayload(model, context) {
 }
 
 // src/TSClient/SelectIncludeOmit.ts
-var import_client_common7 = require("@prisma/client-common");
+var import_client_common8 = require("@prisma/client-common");
 var ts6 = __toESM(require("@prisma/ts-builders"));
 function buildIncludeType({
   modelName,
@@ -3333,9 +3378,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);
 }
@@ -3346,11 +3391,11 @@ 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) {
-  return extArgsParam.toArgument().subKey("result").subKey((0, import_client_common7.lowerCase)(modelName));
+  return extArgsParam.toArgument().subKey("result").subKey((0, import_client_common8.lowerCase)(modelName));
 }
 function buildScalarSelectType({ modelName, fields, context }) {
   const object = buildSelectOrIncludeObject(
@@ -3398,6 +3443,18 @@ function getModelActions(dmmf, name) {
   return mappingKeys;
 }
 
+// src/TSClient/utils/type-builders.ts
+var import_ts_builders = require("@prisma/ts-builders");
+function promise(resultType) {
+  return new import_ts_builders.NamedType("runtime.Types.Utils.JsPromise").addGenericArgument(resultType);
+}
+function prismaPromise(resultType) {
+  return new import_ts_builders.NamedType("Prisma.PrismaPromise").addGenericArgument(resultType);
+}
+function optional(innerType) {
+  return new import_ts_builders.NamedType("runtime.Types.Utils.Optional").addGenericArgument(innerType);
+}
+
 // src/TSClient/Model.ts
 var Model = class {
   constructor(model, context) {
@@ -3487,7 +3544,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> = {
 ${(0, import_indent_string3.default)(
       groupByRootField.args.map((arg) => {
         const updatedArg = { ...arg, comment: getArgFieldJSDoc(this.type, DMMF2.ModelAction.groupBy, arg) };
@@ -3580,7 +3637,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> = {
 ${(0, import_indent_string3.default)(
       aggregateRootField.args.map((arg) => {
         const updatedArg = { ...arg, comment: getArgFieldJSDoc(this.type, DMMF2.ModelAction.aggregate, arg) };
@@ -3619,7 +3676,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);
@@ -3697,9 +3754,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()}
 
@@ -3743,7 +3800,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
   }
@@ -3759,7 +3816,7 @@ ${availableActions.includes(DMMF2.ModelAction.aggregate) ? `${(0, import_indent_
   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)}>
@@ -3890,16 +3947,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) {
@@ -3907,7 +3964,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");
@@ -3924,11 +3981,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(
@@ -3954,7 +4011,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(
@@ -3963,7 +4020,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(
@@ -3975,7 +4032,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}.
@@ -4005,16 +4062,16 @@ function fluentWrapperName(modelName) {
 }
 
 // src/TSClient/TSClient.ts
+var import_node_crypto = __toESM(require("node:crypto"));
+var import_node_path = __toESM(require("node:path"));
 var import_dmmf = require("@prisma/dmmf");
-var import_internals7 = require("@prisma/internals");
+var import_internals6 = require("@prisma/internals");
 var ts12 = __toESM(require("@prisma/ts-builders"));
 var import_ci_info = __toESM(require("ci-info"));
-var import_crypto = __toESM(require("crypto"));
-var import_indent_string8 = __toESM(require("indent-string"));
-var import_path2 = __toESM(require("path"));
+var import_indent_string7 = __toESM(require("indent-string"));
 
 // src/dmmf.ts
-var import_client_common8 = require("@prisma/client-common");
+var import_client_common9 = require("@prisma/client-common");
 var DMMFHelper = class {
   constructor(document) {
     this.document = document;
@@ -4067,8 +4124,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));
@@ -4080,33 +4137,33 @@ var DMMFHelper = class {
     return this.outputObjectTypes[ref.namespace ?? "prisma"].find((outputObject) => outputObject.name === ref.type);
   }
   buildModelMap() {
-    return (0, import_client_common8.keyBy)(this.datamodel.models, "name");
+    return (0, import_client_common9.keyBy)(this.datamodel.models, "name");
   }
   buildTypeMap() {
-    return (0, import_client_common8.keyBy)(this.datamodel.types, "name");
+    return (0, import_client_common9.keyBy)(this.datamodel.types, "name");
   }
   buildTypeModelMap() {
     return { ...this.buildTypeMap(), ...this.buildModelMap() };
   }
   buildMappingsMap() {
-    return (0, import_client_common8.keyBy)(this.mappings.modelOperations, "model");
+    return (0, import_client_common9.keyBy)(this.mappings.modelOperations, "model");
   }
   buildMergedOutputTypeMap() {
     if (!this.schema.outputObjectTypes.prisma) {
       return {
-        model: (0, import_client_common8.keyBy)(this.schema.outputObjectTypes.model, "name"),
-        prisma: (0, import_client_common8.keyBy)([], "name")
+        model: (0, import_client_common9.keyBy)(this.schema.outputObjectTypes.model, "name"),
+        prisma: (0, import_client_common9.keyBy)([], "name")
       };
     }
     return {
-      model: (0, import_client_common8.keyBy)(this.schema.outputObjectTypes.model, "name"),
-      prisma: (0, import_client_common8.keyBy)(this.schema.outputObjectTypes.prisma, "name")
+      model: (0, import_client_common9.keyBy)(this.schema.outputObjectTypes.model, "name"),
+      prisma: (0, import_client_common9.keyBy)(this.schema.outputObjectTypes.prisma, "name")
     };
   }
   buildRootFieldMap() {
     return {
-      ...(0, import_client_common8.keyBy)(this.outputTypeMap.prisma.Query.fields, "name"),
-      ...(0, import_client_common8.keyBy)(this.outputTypeMap.prisma.Mutation.fields, "name")
+      ...(0, import_client_common9.keyBy)(this.outputTypeMap.prisma.Query.fields, "name"),
+      ...(0, import_client_common9.keyBy)(this.outputTypeMap.prisma.Mutation.fields, "name")
     };
   }
   buildInputTypesMap() {
@@ -4123,20 +4180,20 @@ 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;
 }
 
 // src/GenericsArgsInfo.ts
-var import_client_common9 = require("@prisma/client-common");
+var import_client_common10 = require("@prisma/client-common");
 var GenericArgsInfo = class {
   constructor(_dmmf) {
     this._dmmf = _dmmf;
   }
-  _cache = new import_client_common9.Cache();
+  _cache = new import_client_common10.Cache();
   /**
    * Determines if arg types need generic <$PrismaModel> argument added.
    * Essentially, performs breadth-first search for any fieldRefTypes that
@@ -4245,113 +4302,90 @@ function buildDebugInitialization(edge) {
   }
   const debugVar = getRuntimeEdgeEnvVar("DEBUG");
   return `if (${debugVar}) {
-  Debug.enable(${debugVar})
+  runtime.Debug.enable(${debugVar})
 }
 `;
 }
 
 // src/utils/buildDirname.ts
-var import_internals4 = require("@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((0, import_internals4.pathToPosix)(relativeOutdir))},
-    ${JSON.stringify((0, import_internals4.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
-var import_client_common10 = require("@prisma/client-common");
+var import_client_common11 = require("@prisma/client-common");
 function buildRuntimeDataModel(datamodel, runtimeName) {
-  const runtimeDataModel = (0, import_client_common10.dmmfToRuntimeDataModel)(datamodel);
+  const runtimeDataModel = (0, import_client_common11.dmmfToRuntimeDataModel)(datamodel);
   let prunedDataModel;
   if (runtimeName === "wasm" || runtimeName === "client") {
-    prunedDataModel = (0, import_client_common10.pruneRuntimeDataModel)(runtimeDataModel);
+    prunedDataModel = (0, import_client_common11.pruneRuntimeDataModel)(runtimeDataModel);
   } else {
     prunedDataModel = runtimeDataModel;
   }
   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
+var import_client_common12 = require("@prisma/client-common");
+var import_ts_pattern = require("ts-pattern");
+function buildGetWasmModule({
+  component,
+  runtimeName,
+  runtimeBase,
+  target,
+  activeProvider,
+  moduleFormat
+}) {
+  const capitalizedComponent = (0, import_client_common12.capitalize)(component);
+  const wasmPathBase = `${runtimeBase}/query_compiler_bg.${activeProvider}`;
+  const wasmBindingsPath = `${wasmPathBase}.mjs`;
+  const wasmModulePath = `${wasmPathBase}.wasm`;
+  const buildNodeLoader = (0, import_ts_pattern.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`;
-}
+  if (buildEdgeLoader) {
+    const fullWasmModulePath = target === "edge-light" ? `${wasmModulePath}?module` : wasmModulePath;
+    return `config.${component}Wasm = {
+  getRuntime: async () => await import(${JSON.stringify(wasmBindingsPath)}),
 
-// 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)
-
-        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
 var import_get_platform = require("@prisma/get-platform");
-var import_internals5 = require("@prisma/internals");
+var import_internals4 = require("@prisma/internals");
 var import_path = __toESM(require("path"));
 function buildNFTAnnotations(noEngine, engineType, binaryTargets, relativeOutdir) {
   if (noEngine === true) return "";
@@ -4360,7 +4394,7 @@ function buildNFTAnnotations(noEngine, engineType, binaryTargets, relativeOutdir
   }
   if (process.env.NETLIFY) {
     const isNodeMajor20OrUp = parseInt(process.versions.node.split(".")[0]) >= 20;
-    const awsRuntimeVersion = (0, import_internals5.parseAWSNodejsRuntimeEnvVarVersion)();
+    const awsRuntimeVersion = (0, import_internals4.parseAWSNodejsRuntimeEnvVarVersion)();
     const isRuntimeEnvVar20OrUp = awsRuntimeVersion && awsRuntimeVersion >= 20;
     const isRuntimeEnvVar18OrDown = awsRuntimeVersion && awsRuntimeVersion <= 18;
     if ((isNodeMajor20OrUp || isRuntimeEnvVar20OrUp) && !isRuntimeEnvVar18OrDown) {
@@ -4377,10 +4411,10 @@ function buildNFTAnnotations(noEngine, engineType, binaryTargets, relativeOutdir
   return `${engineAnnotations}${schemaAnnotations}`;
 }
 function getQueryEngineFilename(engineType, binaryTarget) {
-  if (engineType === import_internals5.ClientEngineType.Library) {
+  if (engineType === import_internals4.ClientEngineType.Library) {
     return (0, import_get_platform.getNodeAPIName)(binaryTarget, "fs");
   }
-  if (engineType === import_internals5.ClientEngineType.Binary) {
+  if (engineType === import_internals4.ClientEngineType.Binary) {
     return `query-engine-${binaryTarget}`;
   }
   return void 0;
@@ -4389,207 +4423,70 @@ function buildNFTAnnotation(fileName, relativeOutdir) {
   const relativeFilePath = import_path.default.join(relativeOutdir, fileName);
   return `
 // file annotations for bundling tools to include these files
-path.join(__dirname, ${JSON.stringify((0, import_internals5.pathToPosix)(fileName))});
-path.join(process.cwd(), ${JSON.stringify((0, import_internals5.pathToPosix)(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((0, import_internals4.pathToPosix)(fileName))})
+path.join(process.cwd(), ${JSON.stringify((0, import_internals4.pathToPosix)(relativeFilePath))})`;
 }
 
 // src/TSClient/common.ts
-var import_indent_string4 = __toESM(require("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
+export const validator = runtime.Public.validator
 
 /**
-* Extensions
-*/
-Prisma.getExtensionContext = ${notSupportOnBrowser("Extensions.getExtensionContext", browser)}
-Prisma.defineExtension = ${notSupportOnBrowser("Extensions.defineExtension", browser)}
-
-/**
- * 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
 
@@ -4604,46 +4501,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
-
-/**
- * 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")}
+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
 
-${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),
 }
 
 /**
@@ -4651,21 +4545,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
@@ -4677,16 +4571,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
  */
@@ -4694,19 +4578,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
@@ -4823,7 +4696,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> = {
@@ -4847,7 +4719,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
@@ -4860,19 +4732,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> = {
@@ -4903,16 +4766,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]
@@ -4964,43 +4817,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 (0, import_indent_string4.default)(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
 var ts8 = __toESM(require("@prisma/ts-builders"));
-var import_indent_string5 = __toESM(require("indent-string"));
+var import_indent_string4 = __toESM(require("indent-string"));
 var Count = class {
   constructor(type, context) {
     this.type = type;
@@ -5031,8 +4877,10 @@ var Count = class {
 
 ${ts8.stringify(outputType)}
 
-export type ${getSelectName(name)}<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-${(0, import_indent_string5.default)(
+export type ${getSelectName(
+      name
+    )}<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+${(0, import_indent_string4.default)(
       type.fields.map((field) => {
         const types = ["boolean"];
         if (field.outputType.location === "outputObjectTypes") {
@@ -5053,7 +4901,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
@@ -5091,10 +4939,10 @@ var GenerateContext = class {
 };
 
 // src/TSClient/PrismaClient.ts
-var import_client_common12 = require("@prisma/client-common");
-var import_internals6 = require("@prisma/internals");
+var import_client_common14 = require("@prisma/client-common");
+var import_internals5 = require("@prisma/internals");
 var ts11 = __toESM(require("@prisma/ts-builders"));
-var import_indent_string7 = __toESM(require("indent-string"));
+var import_indent_string6 = __toESM(require("indent-string"));
 
 // src/utils/runtimeImport.ts
 var ts9 = __toESM(require("@prisma/ts-builders"));
@@ -5106,7 +4954,7 @@ function runtimeImportedType(name) {
 }
 
 // src/TSClient/Datasources.ts
-var import_indent_string6 = __toESM(require("indent-string"));
+var import_indent_string5 = __toESM(require("indent-string"));
 var Datasources = class {
   constructor(internalDatasources) {
     this.internalDatasources = internalDatasources;
@@ -5114,19 +4962,19 @@ var Datasources = class {
   toTS() {
     const sources = this.internalDatasources;
     return `export type Datasources = {
-${(0, import_indent_string6.default)(sources.map((s) => `${s.name}?: Datasource`).join("\n"), 2)}
+${(0, import_indent_string5.default)(sources.map((s) => `${s.name}?: Datasource`).join("\n"), 2)}
 }`;
   }
 };
 
 // src/TSClient/globalOmit.ts
-var import_client_common11 = require("@prisma/client-common");
+var import_client_common13 = require("@prisma/client-common");
 var ts10 = __toESM(require("@prisma/ts-builders"));
 function globalOmitConfig(dmmf) {
   const objectType9 = ts10.objectType().addMultiple(
     dmmf.datamodel.models.map((model) => {
       const type = ts10.namedType(getOmitName(model.name));
-      return ts10.property((0, import_client_common11.lowerCase)(model.name), type).optional();
+      return ts10.property((0, import_client_common13.lowerCase)(model.name), type).optional();
     })
   );
   return ts10.moduleExport(ts10.typeDeclaration("GlobalOmitConfig", objectType9));
@@ -5139,7 +4987,7 @@ function clientTypeMapModelsDefinition(context) {
   if (modelNames.length === 0) {
     meta.add(ts11.property("modelProps", ts11.neverType));
   } else {
-    meta.add(ts11.property("modelProps", ts11.unionType(modelNames.map((name) => ts11.stringLiteral((0, import_client_common12.lowerCase)(name))))));
+    meta.add(ts11.property("modelProps", ts11.unionType(modelNames.map((name) => ts11.stringLiteral((0, import_client_common14.lowerCase)(name))))));
   }
   const isolationLevel = context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma") ? ts11.namedType("Prisma.TransactionIsolationLevel") : ts11.neverType;
   meta.add(ts11.property("txIsolationLevel", isolationLevel));
@@ -5170,9 +5018,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");
@@ -5189,10 +5037,10 @@ function clientTypeMapModelsResultDefinition(modelName, action) {
   if (action === "update") return payloadToResult(modelName);
   if (action === "upsert") return payloadToResult(modelName);
   if (action === "delete") return payloadToResult(modelName);
-  (0, import_internals6.assertNever)(action, `Unknown action: ${action}`);
+  (0, import_internals5.assertNever)(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) => {
@@ -5230,25 +5078,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 });
 }
@@ -5267,7 +5116,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());
@@ -5280,7 +5129,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);
@@ -5366,7 +5215,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) {
@@ -5391,7 +5240,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
       \`\`\`
@@ -5410,25 +5259,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;
@@ -5442,44 +5290,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)}
- * const ${(0, import_client_common12.lowerCase)(example.plural)} = await prisma.${(0, import_client_common12.lowerCase)(example.model)}.findMany()
+ * // Fetch zero or more ${capitalize3(example.plural)}
+ * const ${(0, import_client_common14.lowerCase)(example.plural)} = await prisma.${(0, import_client_common14.lowerCase)(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 {
+  ${(0, import_indent_string6.default)(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'] }
 
-  ${(0, import_indent_string7.default)(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
@@ -5500,9 +5353,9 @@ ${[
       extendsPropertyDefinition()
     ].filter((d) => d !== null).join("\n").trim()}
 
-    ${(0, import_indent_string7.default)(
+    ${(0, import_indent_string6.default)(
       dmmf.mappings.modelOperations.filter((m) => m.findMany).map((m) => {
-        let methodName = (0, import_client_common12.lowerCase)(m.model);
+        let methodName = (0, import_client_common14.lowerCase)(m.model);
         if (methodName === "constructor") {
           methodName = '["constructor"]';
         }
@@ -5511,15 +5364,17 @@ ${[
  * \`prisma.${methodName}\`: Exposes CRUD operations for the **${m.model}** model.
   * Example usage:
   * \`\`\`ts
-  * // Fetch zero or more ${capitalize2(m.plural)}
-  * const ${(0, import_client_common12.lowerCase)(m.plural)} = await prisma.${methodName}.findMany()
+  * // Fetch zero or more ${capitalize3(m.plural)}
+  * const ${(0, import_client_common14.lowerCase)(m.plural)} = await prisma.${methodName}.findMany()
   * \`\`\`
   */
 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();
@@ -5597,11 +5452,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.
@@ -5681,10 +5533,9 @@ var TSClient = class {
   }
   dmmf;
   genericsInfo;
-  toJS() {
+  toTS() {
     const {
       edge,
-      wasm,
       binaryPaths,
       generator,
       outputDir,
@@ -5692,23 +5543,19 @@ var TSClient = class {
       runtimeBase,
       runtimeName,
       datasources,
-      deno,
       copyEngine = true,
-      envPaths
+      target,
+      activeProvider,
+      moduleFormat
     } = this.options;
-    const relativeEnvPaths = {
-      rootEnvPath: envPaths.rootEnvPath && (0, import_internals7.pathToPosix)(import_path2.default.relative(outputDir, envPaths.rootEnvPath)),
-      schemaEnvPath: envPaths.schemaEnvPath && (0, import_internals7.pathToPosix)(import_path2.default.relative(outputDir, envPaths.schemaEnvPath))
-    };
-    const clientEngineType = (0, import_internals7.getClientEngineType)(generator);
+    const clientEngineType = (0, import_internals6.getClientEngineType)(generator);
     generator.config.engineType = clientEngineType;
-    const binaryTargets = clientEngineType === import_internals7.ClientEngineType.Library ? Object.keys(binaryPaths.libqueryEngine ?? {}) : Object.keys(binaryPaths.queryEngine ?? {});
-    const inlineSchemaHash = import_crypto.default.createHash("sha256").update(Buffer.from(inlineSchema, "utf8").toString("base64")).digest("hex");
+    const binaryTargets = clientEngineType === import_internals6.ClientEngineType.Library ? Object.keys(binaryPaths.libqueryEngine ?? {}) : Object.keys(binaryPaths.queryEngine ?? {});
+    const inlineSchemaHash = import_node_crypto.default.createHash("sha256").update(Buffer.from(inlineSchema, "utf8").toString("base64")).digest("hex");
     const datasourceFilePath = datasources[0].sourceFilePath;
     const config = {
       generator,
-      relativeEnvPaths,
-      relativePath: (0, import_internals7.pathToPosix)(import_path2.default.relative(outputDir, import_path2.default.dirname(datasourceFilePath))),
+      relativePath: (0, import_internals6.pathToPosix)(import_node_path.default.relative(outputDir, import_node_path.default.dirname(datasourceFilePath))),
       clientVersion: this.options.clientVersion,
       engineVersion: this.options.engineVersion,
       datasourceNames: datasources.map((d) => d.name),
@@ -5720,44 +5567,24 @@ var TSClient = class {
       }, {}),
       inlineSchema,
       inlineSchemaHash,
-      copyEngine
+      copyEngine,
+      runtimeDataModel: { models: {}, enums: {}, types: {} },
+      dirname: ""
     };
-    const relativeOutdir = import_path2.default.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((0, import_dmmf.datamodelEnumToSchemaEnum)(datamodelEnum), false).toJS()).join("\n\n")}
-
-${new Enum(
-      {
-        name: "ModelName",
-        values: this.dmmf.mappings.modelOperations.map((m) => m.model)
-      },
-      true
-    ).toJS()}
+    const relativeOutdir = import_node_path.default.relative(process.cwd(), outputDir);
+    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,
@@ -5767,8 +5594,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) => {
@@ -5787,7 +5613,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}`))
+          )
         )
       );
     }
@@ -5796,7 +5624,7 @@ ${buildNFTAnnotations(edge || !copyEngine, clientEngineType, binaryTargets, rela
     const code = `
 /**
  * Client
-**/
+ */
 
 ${commonCode.tsWithoutNamespace()}
 
@@ -5811,10 +5639,13 @@ export namespace $Enums {
 
 ${modelEnumsAliases.join("\n\n")}
 ` : ""}
+
+${clientConfig}
+
 ${prismaClientClass.toTSWithoutNamespace()}
 
 export namespace Prisma {
-${(0, import_indent_string8.default)(
+${(0, import_indent_string7.default)(
       `${commonCode.ts()}
 ${new Enum(
         {
@@ -5883,74 +5714,15 @@ ${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
-var import_internals8 = require("@prisma/internals");
+var import_internals7 = require("@prisma/internals");
 var ts13 = __toESM(require("@prisma/ts-builders"));
 var DbEnumsList = class {
   enums;
@@ -5968,14 +5740,14 @@ var DbEnumsList = class {
   }
   *validJsIdentifiers() {
     for (const dbEnum of this.enums) {
-      if ((0, import_internals8.isValidJsIdentifier)(dbEnum.name)) {
+      if ((0, import_internals7.isValidJsIdentifier)(dbEnum.name)) {
         yield dbEnum;
       }
     }
   }
   *invalidJsIdentifiers() {
     for (const dbEnum of this.enums) {
-      if (!(0, import_internals8.isValidJsIdentifier)(dbEnum.name)) {
+      if (!(0, import_internals7.isValidJsIdentifier)(dbEnum.name)) {
         yield dbEnum;
       }
     }
@@ -5983,23 +5755,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));
@@ -6013,41 +5774,21 @@ function queryUsesEnums(query, enums) {
 
 // src/typedSql/buildIndex.ts
 var ts14 = __toESM(require("@prisma/ts-builders"));
-var import_ts_builders = require("@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 import_ts_builders.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 import_ts_builders.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
 var ts16 = __toESM(require("@prisma/ts-builders"));
-var import_ts_builders2 = require("@prisma/ts-builders");
 
 // src/typedSql/mapTypes.ts
-var import_internals9 = require("@prisma/internals");
 var ts15 = __toESM(require("@prisma/ts-builders"));
 var decimal = ts15.namedType("$runtime.Decimal");
 var uint8Array = ts15.namedType("Uint8Array");
@@ -6141,18 +5882,15 @@ function getMappingConfig(introspectionType, enums) {
   return config;
 }
 function getEnumType(name) {
-  if ((0, import_internals9.isValidJsIdentifier)(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();
@@ -6170,11 +5908,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) {
@@ -6183,47 +5927,28 @@ function buildResultType(query, enums) {
   );
   return ts16.moduleExport(ts16.typeDeclaration("Result", type));
 }
-function buildTypedQueryCjs({ query, runtimeBase, runtimeName }) {
-  const writer = new import_ts_builders2.Writer(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 import_ts_builders2.Writer(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;
 }
 
@@ -6234,7 +5959,7 @@ var DenylistError = class extends Error {
     this.stack = void 0;
   }
 };
-(0, import_internals10.setClassName)(DenylistError, "DenylistError");
+(0, import_internals8.setClassName)(DenylistError, "DenylistError");
 function buildClient({
   schemaPath,
   runtimeBase,
@@ -6250,10 +5975,17 @@ function buildClient({
   postinstall,
   copyEngine,
   envPaths,
-  typedSql
+  typedSql,
+  target,
+  generatedFileExtension,
+  importFileExtension,
+  moduleFormat
 }) {
-  const clientEngineType = (0, import_internals10.getClientEngineType)(generator);
-  const baseClientOptions = {
+  const clientEngineType = (0, import_internals8.getClientEngineType)(generator);
+  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,
@@ -6268,89 +6000,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 === import_internals10.ClientEngineType.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,
@@ -6382,9 +6057,13 @@ async function generateClient(options) {
     postinstall,
     envPaths,
     copyEngine = true,
-    typedSql
+    typedSql,
+    target,
+    generatedFileExtension,
+    importFileExtension,
+    moduleFormat
   } = options;
-  const clientEngineType = (0, import_internals10.getClientEngineType)(generator);
+  const clientEngineType = (0, import_internals8.getClientEngineType)(generator);
   const { runtimeBase, outputDir } = await getGenerationDirs(options);
   const { prismaClientDmmf, fileMap } = buildClient({
     datamodel,
@@ -6401,7 +6080,11 @@ async function generateClient(options) {
     postinstall,
     copyEngine,
     envPaths,
-    typedSql
+    typedSql,
+    target,
+    generatedFileExtension,
+    importFileExtension,
+    moduleFormat
   });
   const denylistsErrors = validateDmmfAgainstDenylists(prismaClientDmmf);
   if (denylistsErrors) {
@@ -6418,45 +6101,28 @@ 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)(import_node_path.default.join(outputDir, "deno"));
-  }
   await writeFileMap(outputDir, fileMap);
-  const enginePath = clientEngineType === import_internals10.ClientEngineType.Library ? binaryPaths.libqueryEngine : binaryPaths.queryEngine;
-  if (!enginePath) {
-    throw new Error(
-      `Prisma Client needs \`${clientEngineType === import_internals10.ClientEngineType.Library ? "libqueryEngine" : "queryEngine"}\` in the \`binaryPaths\` object.`
-    );
-  }
-  if (copyEngine) {
+  const enginePath = clientEngineType === import_internals8.ClientEngineType.Library ? binaryPaths.libqueryEngine : binaryPaths.queryEngine;
+  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 = import_node_path.default.basename(filePath);
-      let target;
+      const fileName = import_node_path2.default.basename(filePath);
+      let target2;
       if (process.env.NETLIFY && !["rhel-openssl-1.0.x", "rhel-openssl-3.0.x"].includes(binaryTarget)) {
-        target = import_node_path.default.join("/tmp/prisma-engines", fileName);
+        target2 = import_node_path2.default.join("/tmp/prisma-engines", fileName);
       } else {
-        target = import_node_path.default.join(outputDir, fileName);
+        target2 = import_node_path2.default.join(outputDir, fileName);
       }
-      await (0, import_fetch_engine.overwriteFile)(filePath, target);
+      await (0, import_fetch_engine.overwriteFile)(filePath, target2);
     }
   }
-  const schemaTargetPath = import_node_path.default.join(outputDir, "schema.prisma");
-  await import_promises.default.writeFile(schemaTargetPath, datamodel, { encoding: "utf-8" });
-  try {
-    const prismaCache = (0, import_env_paths.default)("prisma").cache;
-    const signalsPath = import_node_path.default.join(prismaCache, "last-generate");
-    await import_promises.default.mkdir(prismaCache, { recursive: true });
-    await import_promises.default.writeFile(signalsPath, Date.now().toString());
-  } catch {
-  }
 }
 function writeFileMap(outputDir, fileMap) {
   return Promise.all(
     Object.entries(fileMap).map(async ([fileName, content]) => {
-      const absolutePath = import_node_path.default.join(outputDir, fileName);
+      const absolutePath = import_node_path2.default.join(outputDir, fileName);
       await import_promises.default.rm(absolutePath, { recursive: true, force: true });
       if (typeof content === "string") {
         await import_promises.default.writeFile(absolutePath, content);
@@ -6545,24 +6211,44 @@ function validateDmmfAgainstDenylists(prismaClientDmmf) {
   return errorArray.length > 0 ? errorArray : null;
 }
 async function getGenerationDirs({ runtimeBase, outputDir }) {
-  const normalizedOutputDir = import_node_path.default.normalize(outputDir);
-  const normalizedRuntimeBase = (0, import_internals10.pathToPosix)(runtimeBase);
-  const userPackageRoot = await (0, import_pkg_up.default)({ cwd: import_node_path.default.dirname(normalizedOutputDir) });
-  const userProjectRoot = userPackageRoot ? import_node_path.default.dirname(userPackageRoot) : process.cwd();
+  const normalizedOutputDir = import_node_path2.default.normalize(outputDir);
+  const normalizedRuntimeBase = (0, import_internals8.pathToPosix)(runtimeBase);
+  const userPackageRoot = await (0, import_pkg_up.default)({ cwd: import_node_path2.default.dirname(normalizedOutputDir) });
+  const userProjectRoot = userPackageRoot ? import_node_path2.default.dirname(userPackageRoot) : process.cwd();
   return {
     runtimeBase: normalizedRuntimeBase,
     outputDir: normalizedOutputDir,
     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:
+      (0, import_internals8.assertNever)(target, "Unknown runtime target");
+  }
+}
 function getNodeRuntimeName(engineType) {
-  if (engineType === import_internals10.ClientEngineType.Binary) {
+  if (engineType === import_internals8.ClientEngineType.Binary) {
     return "binary";
   }
-  if (engineType === import_internals10.ClientEngineType.Library) {
+  if (engineType === import_internals8.ClientEngineType.Library) {
     return "library";
   }
-  if (engineType === import_internals10.ClientEngineType.Client) {
+  if (engineType === import_internals8.ClientEngineType.Client) {
     if (!process.env.PRISMA_UNSTABLE_CLIENT_ENGINE_TYPE) {
       throw new Error(
         'Unstable Feature: engineType="client" is in a proof of concept phase and not ready to be used publicly yet!'
@@ -6570,7 +6256,7 @@ function getNodeRuntimeName(engineType) {
     }
     return "client";
   }
-  (0, import_internals10.assertNever)(engineType, "Unknown engine type");
+  (0, import_internals8.assertNever)(engineType, "Unknown engine type");
 }
 async function deleteOutputDir(outputDir) {
   try {
@@ -6578,15 +6264,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 (0, import_fast_glob.glob)(`${outputDir}/**/*.ts`, {
-        globstar: true,
-        onlyFiles: true,
+      (await (0, import_fast_glob.glob)([`${outputDir}/**/*.{ts,mts,cts}`, `${outputDir}/*.node`, `${outputDir}/{query,schema}-engine-*`], {
         followSymbolicLinks: false
       })).map(import_promises.default.unlink)
     );
@@ -6598,16 +6282,91 @@ async function deleteOutputDir(outputDir) {
 }
 
 // src/generator.ts
-var import_debug = __toESM(require("@prisma/debug"));
+var import_debug = require("@prisma/debug");
 var import_engines_version = require("@prisma/engines-version");
-var import_internals11 = require("@prisma/internals");
-var import_ts_pattern = require("ts-pattern");
+var import_internals9 = require("@prisma/internals");
+var import_get_tsconfig = require("get-tsconfig");
+var import_ts_pattern2 = require("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(module2) {
+  const normalizedModule = module2.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 = (0, import_debug.default)("prisma:client:generator");
+var debug = (0, import_debug.Debug)("prisma:client:generator");
 var missingOutputErrorMessage = `An output path is required for the \`prisma-client-ts\` generator. Please provide an output path in your schema file:
 
 ${dim(`generator client {
@@ -6621,12 +6380,12 @@ function getOutputPath(config) {
   if (!config.output) {
     throw new Error(missingOutputErrorMessage);
   }
-  return (0, import_internals11.parseEnvValue)(config.output);
+  return (0, import_internals9.parseEnvValue)(config.output);
 }
 var PrismaClientTsGenerator = class {
   name = "prisma-client-ts";
   getManifest(config) {
-    const requiresEngines = (0, import_ts_pattern.match)((0, import_internals11.getClientEngineType)(config)).with(import_internals11.ClientEngineType.Library, () => ["libqueryEngine"]).with(import_internals11.ClientEngineType.Binary, () => ["queryEngine"]).with(import_internals11.ClientEngineType.Client, () => []).exhaustive();
+    const requiresEngines = (0, import_ts_pattern2.match)((0, import_internals9.getClientEngineType)(config)).with(import_internals9.ClientEngineType.Library, () => ["libqueryEngine"]).with(import_internals9.ClientEngineType.Binary, () => ["queryEngine"]).with(import_internals9.ClientEngineType.Client, () => []).exhaustive();
     debug("requiresEngines", requiresEngines);
     return Promise.resolve({
       defaultOutput: getOutputPath(config),
@@ -6637,13 +6396,27 @@ var PrismaClientTsGenerator = class {
     });
   }
   async generate(options) {
+    const { config } = options.generator;
+    const outputDir = getOutputPath(options.generator);
+    const tsconfig = (0, import_get_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,
@@ -6652,49 +6425,17 @@ 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();
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PrismaClientTsGenerator,
-  dmmfToTypes,
   externalToInternalDmmf,
   generateClient,
   getDMMF