@vibeorm/generator 1.3.1 → 2.0.0-alpha.2

package/dist/index.js

@@ -0,0 +1,1521 @@
+// @bun
+// packages/generator/src/generate.ts
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { buildComputedManifest, validateComputedConfig } from "@vibeorm/schema";
+
+// packages/generator/src/emit-dts.ts
+import { VibeError as VibeError3 } from "@vibeorm/schema";
+
+// packages/generator/src/extension-bake.ts
+import {
+  VibeError,
+  buildExtensionRegistry,
+  extensionDeclarations,
+  extensionManifestEntry,
+  providerToDialect
+} from "@vibeorm/schema";
+var EMPTY_BAKED_EXTENSIONS = {
+  jsImports: [],
+  mounts: [],
+  manifest: [],
+  dtsImports: [],
+  delegateDts: new Map,
+  moduleDts: [],
+  clientDts: [],
+  empty: true
+};
+
+class ImportCollector {
+  byModule = new Map;
+  add(specs) {
+    for (const spec of specs ?? []) {
+      const names = this.byModule.get(spec.from) ?? new Set;
+      for (const name of spec.names)
+        names.add(name);
+      this.byModule.set(spec.from, names);
+    }
+  }
+  lines(params) {
+    return [...this.byModule.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([from, names]) => `import ${params.typeOnly ? "type " : ""}{ ${[...names].sort().join(", ")} } from ${JSON.stringify(from)};`);
+  }
+}
+function indent(lines) {
+  return lines.map((line) => line.length === 0 ? line : `  ${line}`);
+}
+function bakeExtensions(params) {
+  const { schema } = params;
+  if (params.extensions.length === 0)
+    return EMPTY_BAKED_EXTENSIONS;
+  buildExtensionRegistry({ extensions: params.extensions });
+  const dialect = providerToDialect({ provider: schema.datasource.provider });
+  const provider = schema.datasource.provider;
+  const sorted = [...params.extensions].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  const jsImports = new ImportCollector;
+  const dtsImports = new ImportCollector;
+  const mounts = [];
+  const delegateDts = new Map;
+  const moduleDts = [];
+  const clientDts = [];
+  const useContribution = (paramsInner) => {
+    const { extension, contribution, scope, model } = paramsInner;
+    const property = scope === "model" ? extension.name : `$${extension.name}`;
+    jsImports.add(contribution.imports);
+    dtsImports.add(contribution.dtsImports);
+    moduleDts.push(...contribution.dtsTypes ?? []);
+    mounts.push(`{ extension: ${JSON.stringify(extension.name)}, scope: ${JSON.stringify(scope)}, ${model === undefined ? "" : `model: ${JSON.stringify(model)}, `}property: ${JSON.stringify(property)}, create: ${contribution.runtimeGlue} }`);
+    if (scope === "model" && model !== undefined) {
+      const lines = delegateDts.get(model) ?? [];
+      lines.push(...indent(contribution.dts));
+      delegateDts.set(model, lines);
+    } else {
+      clientDts.push(...indent(contribution.dts));
+    }
+  };
+  for (const extension of sorted) {
+    const declarations = extensionDeclarations({ schema, name: extension.name });
+    const modelHook = extension.client?.model;
+    if (modelHook !== undefined) {
+      for (const model of schema.models) {
+        const declaration = declarations[model.name];
+        if (declaration === undefined)
+          continue;
+        const contribution = modelHook({
+          model,
+          schema,
+          dialect,
+          provider,
+          options: extension.options,
+          declaration,
+          typeNames: { payload: model.name, whereInput: `${model.name}WhereInput` }
+        });
+        if (contribution === null)
+          continue;
+        const clash = model.fields.some((field) => field.name === extension.name) || model.relations.some((relation) => relation.name === extension.name);
+        if (clash) {
+          throw new VibeError({
+            code: "VIBE_CONFIG",
+            message: `extension "${extension.name}" collides with a field/relation named "${extension.name}" on model "${model.name}" \u2014 rename one of them`,
+            meta: { extension: extension.name, model: model.name }
+          });
+        }
+        useContribution({ extension, contribution, scope: "model", model: model.name });
+      }
+    }
+    const rootHook = extension.client?.root;
+    if (rootHook !== undefined) {
+      const contribution = rootHook({
+        schema,
+        dialect,
+        provider,
+        options: extension.options,
+        declarations
+      });
+      if (contribution !== null) {
+        useContribution({ extension, contribution, scope: "client" });
+      }
+    }
+  }
+  return {
+    jsImports: jsImports.lines({ typeOnly: false }),
+    mounts,
+    manifest: sorted.map((extension) => extensionManifestEntry({ extension })),
+    dtsImports: dtsImports.lines({ typeOnly: true }),
+    delegateDts,
+    moduleDts,
+    clientDts,
+    empty: false
+  };
+}
+
+// packages/generator/src/type-names.ts
+var PAYLOAD_TYPES = {
+  String: "string",
+  Boolean: "boolean",
+  Int: "number",
+  BigInt: "bigint",
+  Float: "number",
+  Decimal: "string",
+  DateTime: "Date",
+  Json: "JsonValue",
+  Bytes: "Uint8Array"
+};
+var INPUT_TYPES = {
+  String: "string",
+  Boolean: "boolean",
+  Int: "number",
+  BigInt: "bigint | number",
+  Float: "number",
+  Decimal: "string | number",
+  DateTime: "Date | string",
+  Json: "InputJsonValue",
+  Bytes: "Uint8Array"
+};
+var FILTER_PREFIX = {
+  String: "String",
+  Boolean: "Bool",
+  Int: "Int",
+  BigInt: "BigInt",
+  Float: "Float",
+  Decimal: "Decimal",
+  DateTime: "DateTime",
+  Json: "Json",
+  Bytes: "Bytes"
+};
+var NUMERIC_SCALARS = new Set(["Int", "BigInt", "Float", "Decimal"]);
+var MINMAX_SCALARS = new Set([
+  "String",
+  "Int",
+  "BigInt",
+  "Float",
+  "Decimal",
+  "DateTime"
+]);
+function payloadBaseType(params) {
+  const { field } = params;
+  return field.enumName ?? PAYLOAD_TYPES[field.scalar];
+}
+function inputBaseType(params) {
+  const { field } = params;
+  return field.enumName ?? INPUT_TYPES[field.scalar];
+}
+function filterName(params) {
+  const { field } = params;
+  const prefix = field.enumName ?? FILTER_PREFIX[field.scalar];
+  if (field.isList)
+    return `${prefix}ListFilter`;
+  return field.isOptional ? `${prefix}NullableFilter` : `${prefix}Filter`;
+}
+function updateOpsName(params) {
+  const { field } = params;
+  if (field.isList || field.scalar === null || !NUMERIC_SCALARS.has(field.scalar))
+    return null;
+  const prefix = FILTER_PREFIX[field.scalar];
+  return field.isOptional ? `Nullable${prefix}FieldUpdateOperationsInput` : `${prefix}FieldUpdateOperationsInput`;
+}
+
+// packages/generator/src/util.ts
+import { VibeError as VibeError2 } from "@vibeorm/schema";
+function pascal(params) {
+  const { name } = params;
+  if (name.length === 0)
+    return name;
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function clientNameOf(params) {
+  const { name } = params;
+  if (name.length === 0)
+    return name;
+  return name.charAt(0).toLowerCase() + name.slice(1);
+}
+var IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function propKey(params) {
+  const { name } = params;
+  return IDENTIFIER_RE.test(name) ? name : JSON.stringify(name);
+}
+function tsString(params) {
+  return JSON.stringify(params.value);
+}
+function maybeParens(params) {
+  const { type } = params;
+  return type.includes("|") ? `(${type})` : type;
+}
+function stableStringify(params) {
+  return renderValue({ value: params.value, indent: "" });
+}
+function renderValue(params) {
+  const { value, indent: indent2 } = params;
+  if (value === null)
+    return "null";
+  const kind = typeof value;
+  if (kind === "string" || kind === "number" || kind === "boolean")
+    return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return "[]";
+    const inner = `${indent2}  `;
+    const items = value.map((item) => inner + renderValue({ value: item, indent: inner }));
+    return `[
+${items.join(`,
+`)}
+${indent2}]`;
+  }
+  if (kind === "object") {
+    const record = value;
+    const keys = Object.keys(record).filter((key) => record[key] !== undefined).sort();
+    if (keys.length === 0)
+      return "{}";
+    const inner = `${indent2}  `;
+    const items = keys.map((key) => `${inner}${JSON.stringify(key)}: ${renderValue({ value: record[key], indent: inner })}`);
+    return `{
+${items.join(`,
+`)}
+${indent2}}`;
+  }
+  throw new VibeError2({
+    code: "VIBE_INTERNAL",
+    message: `internal: cannot serialize a ${kind} value into the generated client`,
+    meta: { kind }
+  });
+}
+
+// packages/generator/src/emit-dts.ts
+function banner(params) {
+  return `// \u2500\u2500\u2500 ${params.title} \u2500\u2500\u2500`;
+}
+function objectAlias(params) {
+  const { name, lines } = params;
+  if (lines.length === 0)
+    return `export type ${name} = Record<string, never>;`;
+  return `export type ${name} = {
+${lines.join(`
+`)}
+};`;
+}
+function orMany(params) {
+  const { type } = params;
+  return `${type} | readonly ${maybeParens({ type })}[]`;
+}
+function payloadFieldType(params) {
+  const { field } = params;
+  const base = payloadBaseType({ field });
+  if (field.isList)
+    return `${maybeParens({ type: base })}[]`;
+  return field.isOptional ? `${base} | null` : base;
+}
+function relationPayloadType(params) {
+  const { relation } = params;
+  if (relation.isList)
+    return `${relation.target}[]`;
+  return relation.isOptional ? `${relation.target} | null` : relation.target;
+}
+var PREAMBLE = `${banner({ title: "Shared scalar & helper types" })}
+
+/** JSON as stored/returned by Json columns (decoded payload shape). */
+export type JsonValue = string | number | boolean | null | { [key: string]: JsonValue } | JsonValue[];
+
+/** Object form accepted as Json INPUT \u2014 readonly, and undefined-valued keys are dropped on serialize. */
+export type InputJsonObject = { readonly [key: string]: InputJsonValue | null | undefined };
+
+/** Array form accepted as Json INPUT \u2014 readonly arrays are welcome (v1 lesson, LEARNINGS bug 7). */
+export type InputJsonArray = ReadonlyArray<InputJsonValue | null>;
+
+/**
+ * JSON as ACCEPTED for Json input positions \u2014 deliberately wider than
+ * JsonValue: readonly containers and toJSON-bearing values (Date) serialize
+ * fine, the runtime stringifies with JSON.stringify (v1 lessons, bugs 7+8).
+ */
+export type InputJsonValue = string | number | boolean | InputJsonObject | InputJsonArray | { toJSON(): unknown };
+
+/** \`strict\` (board #20) forces case-SENSITIVE matching where the engine folds (sqlite/mysql); a no-op on postgres. */
+export type QueryMode = "default" | "insensitive" | "strict";
+
+export type SortOrder = "asc" | "desc";
+
+export type SortOrderWithNulls = SortOrder | { readonly sort: SortOrder; readonly nulls?: "first" | "last" };
+
+/** How relations are loaded: batched WHERE-IN queries, or a single JOIN (pg/pglite). */
+export type RelationStrategy = "query" | "join";
+
+/** Result of createMany/updateMany/deleteMany. */
+export type BatchPayload = { readonly count: number };
+
+/** Keys of an omit object whose value is exactly true \u2014 the scalars the result drops. */
+type OmittedKeys<O> = keyof { [K in keyof O as O[K] extends true ? K : never]: 0 };`;
+var SCALAR_FILTER_CONFIGS = [
+  { prefix: "String", value: "string", comparable: true, text: true },
+  { prefix: "Int", value: "number", comparable: true, text: false },
+  { prefix: "Float", value: "number", comparable: true, text: false },
+  { prefix: "BigInt", value: "bigint | number", comparable: true, text: false },
+  { prefix: "Decimal", value: "string | number", comparable: true, text: false },
+  { prefix: "DateTime", value: "Date | string", comparable: true, text: false },
+  { prefix: "Bool", value: "boolean", comparable: false, text: false },
+  { prefix: "Bytes", value: "Uint8Array", comparable: false, text: false }
+];
+function scalarFilterAlias(params) {
+  const { config, nullable } = params;
+  const name = nullable ? `${config.prefix}NullableFilter` : `${config.prefix}Filter`;
+  const value = config.value;
+  const valueOrNull = nullable ? `${value} | null` : value;
+  const array = `readonly ${maybeParens({ type: value })}[]`;
+  const lines = [];
+  lines.push(`  readonly equals?: ${valueOrNull};`);
+  lines.push(`  readonly in?: ${array};`);
+  lines.push(`  readonly notIn?: ${array};`);
+  if (config.comparable) {
+    lines.push(`  readonly lt?: ${value};`);
+    lines.push(`  readonly lte?: ${value};`);
+    lines.push(`  readonly gt?: ${value};`);
+    lines.push(`  readonly gte?: ${value};`);
+  }
+  if (config.text) {
+    lines.push(`  readonly contains?: ${value};`);
+    lines.push(`  readonly startsWith?: ${value};`);
+    lines.push(`  readonly endsWith?: ${value};`);
+    lines.push(`  readonly mode?: QueryMode;`);
+  }
+  lines.push(`  readonly not?: ${value} | ${name}${nullable ? " | null" : ""};`);
+  return objectAlias({ name, lines });
+}
+function scalarListFilterAlias(params) {
+  const { config } = params;
+  const value = config.value;
+  const array = `readonly ${maybeParens({ type: value })}[]`;
+  return objectAlias({
+    name: `${config.prefix}ListFilter`,
+    lines: [
+      `  readonly equals?: ${array} | null;`,
+      `  readonly has?: ${value} | null;`,
+      `  readonly hasEvery?: ${array};`,
+      `  readonly hasSome?: ${array};`,
+      `  readonly isEmpty?: boolean;`
+    ]
+  });
+}
+var UPDATE_OPS_CONFIGS = [
+  { prefix: "Int", value: "number" },
+  { prefix: "Float", value: "number" },
+  { prefix: "BigInt", value: "bigint | number" },
+  { prefix: "Decimal", value: "string | number" }
+];
+function updateOpsAlias(params) {
+  const { prefix, value, nullable } = params;
+  const name = nullable ? `Nullable${prefix}FieldUpdateOperationsInput` : `${prefix}FieldUpdateOperationsInput`;
+  return objectAlias({
+    name,
+    lines: [
+      `  readonly set?: ${nullable ? `${value} | null` : value};`,
+      `  readonly increment?: ${value};`,
+      `  readonly decrement?: ${value};`,
+      `  readonly multiply?: ${value};`,
+      `  readonly divide?: ${value};`
+    ]
+  });
+}
+function filterSection() {
+  const parts = [banner({ title: "Scalar filters" })];
+  for (const config of SCALAR_FILTER_CONFIGS) {
+    parts.push(scalarFilterAlias({ config, nullable: false }));
+    parts.push(scalarFilterAlias({ config, nullable: true }));
+    parts.push(scalarListFilterAlias({ config }));
+  }
+  parts.push(objectAlias({
+    name: "JsonFilter",
+    lines: [`  readonly equals?: InputJsonValue;`, `  readonly not?: InputJsonValue;`]
+  }));
+  parts.push(objectAlias({
+    name: "JsonNullableFilter",
+    lines: [`  readonly equals?: InputJsonValue | null;`, `  readonly not?: InputJsonValue | null;`]
+  }));
+  parts.push(objectAlias({
+    name: "JsonListFilter",
+    lines: [
+      `  readonly equals?: readonly InputJsonValue[] | null;`,
+      `  readonly has?: InputJsonValue | null;`,
+      `  readonly hasEvery?: readonly InputJsonValue[];`,
+      `  readonly hasSome?: readonly InputJsonValue[];`,
+      `  readonly isEmpty?: boolean;`
+    ]
+  }));
+  parts.push(banner({ title: "Atomic update operations" }));
+  for (const config of UPDATE_OPS_CONFIGS) {
+    parts.push(updateOpsAlias({ ...config, nullable: false }));
+    parts.push(updateOpsAlias({ ...config, nullable: true }));
+  }
+  return parts;
+}
+function emitEnum(params) {
+  const { declared } = params;
+  const name = declared.name;
+  const parts = [banner({ title: `Enum ${name}` })];
+  const valueLines = declared.values.map((value) => `  readonly ${propKey({ name: value })}: ${tsString({ value })};`);
+  parts.push(`export declare const ${name}: {
+${valueLines.join(`
+`)}
+};`);
+  parts.push(`export type ${name} = ${declared.values.map((value) => tsString({ value })).join(" | ")};`);
+  const array = `readonly ${name}[]`;
+  parts.push(objectAlias({
+    name: `${name}Filter`,
+    lines: [
+      `  readonly equals?: ${name};`,
+      `  readonly in?: ${array};`,
+      `  readonly notIn?: ${array};`,
+      `  readonly not?: ${name} | ${name}Filter;`
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${name}NullableFilter`,
+    lines: [
+      `  readonly equals?: ${name} | null;`,
+      `  readonly in?: ${array};`,
+      `  readonly notIn?: ${array};`,
+      `  readonly not?: ${name} | ${name}NullableFilter | null;`
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${name}ListFilter`,
+    lines: [
+      `  readonly equals?: ${array} | null;`,
+      `  readonly has?: ${name} | null;`,
+      `  readonly hasEvery?: ${array};`,
+      `  readonly hasSome?: ${array};`,
+      `  readonly isEmpty?: boolean;`
+    ]
+  }));
+  return parts.join(`
+
+`);
+}
+function createFieldProp(params) {
+  const { field } = params;
+  const optional = field.isOptional || field.hasDefault || field.isUpdatedAt || field.isList;
+  const base = inputBaseType({ field });
+  const value = field.isList ? `readonly ${maybeParens({ type: base })}[]` : field.isOptional ? `${base} | null` : base;
+  return `  readonly ${propKey({ name: field.name })}${optional ? "?" : ""}: ${value};`;
+}
+function updateFieldProp(params) {
+  const { field } = params;
+  const base = inputBaseType({ field });
+  const key = propKey({ name: field.name });
+  if (field.isList) {
+    const element = maybeParens({ type: base });
+    return `  readonly ${key}?: readonly ${element}[] | { readonly set?: readonly ${element}[]; readonly push?: ${base} | readonly ${element}[] };`;
+  }
+  const ops = updateOpsName({ field });
+  const withNull = field.isOptional ? `${base} | null` : base;
+  if (ops !== null)
+    return `  readonly ${key}?: ${withNull} | ${ops};`;
+  return `  readonly ${key}?: ${withNull} | { readonly set: ${withNull} };`;
+}
+function nestedRefName(params) {
+  const { relation, verb } = params;
+  const suffix = relation.inverseName === null ? "" : `Without${pascal({ name: relation.inverseName })}`;
+  return `${relation.target}${verb}Nested${relation.isList ? "Many" : "One"}${suffix}Input`;
+}
+function checkedCreateLines(params) {
+  const { model, omitRelation } = params;
+  const lines = [];
+  for (const field of model.fields) {
+    if (model.fkFieldNames.has(field.name))
+      continue;
+    lines.push(createFieldProp({ field }));
+  }
+  for (const relation of model.relations) {
+    if (relation.name === omitRelation)
+      continue;
+    const required = !relation.isList && !relation.isOptional;
+    lines.push(`  readonly ${propKey({ name: relation.name })}${required ? "" : "?"}: ${nestedRefName({ relation, verb: "Create" })};`);
+  }
+  return lines;
+}
+function uncheckedCreateLines(params) {
+  const { model, omitRelation } = params;
+  const omitted = new Set(omitRelation === undefined ? [] : model.relations.find((relation) => relation.name === omitRelation)?.fkFields ?? []);
+  return model.fields.filter((field) => !omitted.has(field.name)).map((field) => createFieldProp({ field }));
+}
+function checkedUpdateLines(params) {
+  const { model, omitRelation } = params;
+  const lines = [];
+  for (const field of model.fields) {
+    if (model.fkFieldNames.has(field.name))
+      continue;
+    lines.push(updateFieldProp({ field }));
+  }
+  for (const relation of model.relations) {
+    if (relation.name === omitRelation)
+      continue;
+    lines.push(`  readonly ${propKey({ name: relation.name })}?: ${nestedRefName({ relation, verb: "Update" })};`);
+  }
+  return lines;
+}
+function uncheckedUpdateLines(params) {
+  const { model, omitRelation } = params;
+  const omitted = new Set(omitRelation === undefined ? [] : model.relations.find((relation) => relation.name === omitRelation)?.fkFields ?? []);
+  return model.fields.filter((field) => !omitted.has(field.name)).map((field) => updateFieldProp({ field }));
+}
+function register(params) {
+  const { registry, name, text } = params;
+  const existing = registry.get(name);
+  if (existing !== undefined) {
+    if (existing !== text) {
+      throw new VibeError3({
+        code: "VIBE_INTERNAL",
+        message: `internal: nested input type "${name}" generated with two different bodies`,
+        meta: { name }
+      });
+    }
+    return;
+  }
+  registry.set(name, text);
+}
+function registerNestedContext(params) {
+  const { registry, view, relation } = params;
+  const target = view.modelByName.get(relation.target);
+  if (target === undefined)
+    return;
+  const t = target.name;
+  const inverse = relation.inverseName;
+  const suffix = inverse === null ? "" : `Without${pascal({ name: inverse })}`;
+  const many = relation.isList;
+  const m2m = relation.type === "manyToMany";
+  let createUnion;
+  let updateUnion;
+  if (inverse === null) {
+    createUnion = `${t}CreateInput | ${t}UncheckedCreateInput`;
+    updateUnion = `${t}UpdateInput | ${t}UncheckedUpdateInput`;
+  } else {
+    createUnion = `${t}Create${suffix}Input | ${t}UncheckedCreate${suffix}Input`;
+    updateUnion = `${t}Update${suffix}Input | ${t}UncheckedUpdate${suffix}Input`;
+    register({
+      registry,
+      name: `${t}Create${suffix}Input`,
+      text: objectAlias({
+        name: `${t}Create${suffix}Input`,
+        lines: checkedCreateLines({ model: target, omitRelation: inverse })
+      })
+    });
+    register({
+      registry,
+      name: `${t}UncheckedCreate${suffix}Input`,
+      text: objectAlias({
+        name: `${t}UncheckedCreate${suffix}Input`,
+        lines: uncheckedCreateLines({ model: target, omitRelation: inverse })
+      })
+    });
+    register({
+      registry,
+      name: `${t}Update${suffix}Input`,
+      text: objectAlias({
+        name: `${t}Update${suffix}Input`,
+        lines: checkedUpdateLines({ model: target, omitRelation: inverse })
+      })
+    });
+    register({
+      registry,
+      name: `${t}UncheckedUpdate${suffix}Input`,
+      text: objectAlias({
+        name: `${t}UncheckedUpdate${suffix}Input`,
+        lines: uncheckedUpdateLines({ model: target, omitRelation: inverse })
+      })
+    });
+  }
+  const connectOrCreateName = `${t}ConnectOrCreate${suffix}Input`;
+  register({
+    registry,
+    name: connectOrCreateName,
+    text: objectAlias({
+      name: connectOrCreateName,
+      lines: [`  readonly where: ${t}WhereUniqueInput;`, `  readonly create: ${createUnion};`]
+    })
+  });
+  const createManyData = inverse === null ? `readonly ${t}CreateManyInput[]` : `readonly ${t}UncheckedCreate${suffix}Input[]`;
+  if (many) {
+    register({
+      registry,
+      name: `${t}CreateNestedMany${suffix}Input`,
+      text: objectAlias({
+        name: `${t}CreateNestedMany${suffix}Input`,
+        lines: [
+          `  readonly create?: ${orMany({ type: createUnion })};`,
+          `  readonly connect?: ${orMany({ type: `${t}WhereUniqueInput` })};`,
+          `  readonly connectOrCreate?: ${orMany({ type: connectOrCreateName })};`,
+          ...m2m ? [] : [`  readonly createMany?: { readonly data: ${createManyData}; readonly skipDuplicates?: boolean };`]
+        ]
+      })
+    });
+    const updateWithWhere = `${t}UpdateWithWhereUnique${suffix}Input`;
+    register({
+      registry,
+      name: updateWithWhere,
+      text: objectAlias({
+        name: updateWithWhere,
+        lines: [`  readonly where: ${t}WhereUniqueInput;`, `  readonly data: ${updateUnion};`]
+      })
+    });
+    const updateManyWithWhere = `${t}UpdateManyWithWhere${suffix}Input`;
+    register({
+      registry,
+      name: updateManyWithWhere,
+      text: objectAlias({
+        name: updateManyWithWhere,
+        lines: [`  readonly where: ${t}WhereInput;`, `  readonly data: ${t}UpdateManyInput;`]
+      })
+    });
+    const upsertWithWhere = `${t}UpsertWithWhereUnique${suffix}Input`;
+    register({
+      registry,
+      name: upsertWithWhere,
+      text: objectAlias({
+        name: upsertWithWhere,
+        lines: [
+          `  readonly where: ${t}WhereUniqueInput;`,
+          `  readonly create: ${createUnion};`,
+          `  readonly update: ${updateUnion};`
+        ]
+      })
+    });
+    register({
+      registry,
+      name: `${t}UpdateNestedMany${suffix}Input`,
+      text: objectAlias({
+        name: `${t}UpdateNestedMany${suffix}Input`,
+        lines: [
+          `  readonly create?: ${orMany({ type: createUnion })};`,
+          `  readonly connect?: ${orMany({ type: `${t}WhereUniqueInput` })};`,
+          `  readonly connectOrCreate?: ${orMany({ type: connectOrCreateName })};`,
+          ...m2m ? [] : [`  readonly createMany?: { readonly data: ${createManyData}; readonly skipDuplicates?: boolean };`],
+          `  readonly set?: ${orMany({ type: `${t}WhereUniqueInput` })};`,
+          `  readonly disconnect?: ${orMany({ type: `${t}WhereUniqueInput` })};`,
+          `  readonly delete?: ${orMany({ type: `${t}WhereUniqueInput` })};`,
+          `  readonly update?: ${orMany({ type: updateWithWhere })};`,
+          `  readonly updateMany?: ${orMany({ type: updateManyWithWhere })};`,
+          `  readonly deleteMany?: ${orMany({ type: `${t}WhereInput` })};`,
+          `  readonly upsert?: ${orMany({ type: upsertWithWhere })};`
+        ]
+      })
+    });
+  } else {
+    const allowDetach = inverse === null || relation.isOptional;
+    register({
+      registry,
+      name: `${t}CreateNestedOne${suffix}Input`,
+      text: objectAlias({
+        name: `${t}CreateNestedOne${suffix}Input`,
+        lines: [
+          `  readonly create?: ${createUnion};`,
+          `  readonly connect?: ${t}WhereUniqueInput;`,
+          `  readonly connectOrCreate?: ${connectOrCreateName};`
+        ]
+      })
+    });
+    register({
+      registry,
+      name: `${t}UpdateNestedOne${suffix}Input`,
+      text: objectAlias({
+        name: `${t}UpdateNestedOne${suffix}Input`,
+        lines: [
+          `  readonly create?: ${createUnion};`,
+          `  readonly connect?: ${t}WhereUniqueInput;`,
+          `  readonly connectOrCreate?: ${connectOrCreateName};`,
+          `  readonly update?: ${updateUnion};`,
+          `  readonly upsert?: { readonly create: ${createUnion}; readonly update: ${updateUnion} };`,
+          ...allowDetach ? [`  readonly disconnect?: boolean;`, `  readonly delete?: boolean;`] : []
+        ]
+      })
+    });
+  }
+}
+var AGGREGATE_OPS_UNION = `"_count" | "_avg" | "_sum" | "_min" | "_max"`;
+function emitModel(params) {
+  const { model, view, registry } = params;
+  const computedEntries = params.computed ?? [];
+  const n = model.name;
+  const hasRelations = model.relations.length > 0;
+  const parts = [banner({ title: `Model ${n}` })];
+  for (const relation of model.relations) {
+    registerNestedContext({ registry, view, relation });
+  }
+  parts.push(`export type ${n} = {
+${[
+    ...model.fields.map((field) => `  ${propKey({ name: field.name })}: ${payloadFieldType({ field })};`),
+    ...computedEntries.map((entry) => `  ${propKey({ name: entry.field })}: ${entry.type};`)
+  ].join(`
+`)}
+};`);
+  parts.push(`export type ${n}ScalarFieldEnum = ${model.fields.map((field) => tsString({ value: field.name })).join(" | ")};`);
+  if (computedEntries.length > 0) {
+    parts.push(`export type ${n}SelectableFieldEnum = ${n}ScalarFieldEnum | ${computedEntries.map((entry) => tsString({ value: entry.field })).join(" | ")};`);
+  }
+  const selectableEnum = computedEntries.length > 0 ? `${n}SelectableFieldEnum` : `${n}ScalarFieldEnum`;
+  if (hasRelations) {
+    parts.push(`export type ${n}Relations = {
+${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${relationPayloadType({ relation })};`).join(`
+`)}
+};`);
+  }
+  const listRelations = model.relations.filter((relation) => relation.isList);
+  const hasCounts = listRelations.length > 0;
+  const countLine = `  readonly _count?: boolean | { readonly select: ${n}CountSelect };`;
+  const relationSelectValue = (relation) => `boolean | ${relation.target}${relation.isList ? "FindManyArgs" : "Args"}`;
+  if (hasCounts) {
+    parts.push(objectAlias({
+      name: `${n}CountSelect`,
+      lines: listRelations.map((relation) => `  readonly ${propKey({ name: relation.name })}?: boolean;`)
+    }));
+  }
+  parts.push(objectAlias({
+    name: `${n}Select`,
+    lines: [
+      ...model.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: boolean;`),
+      ...computedEntries.map((entry) => `  readonly ${propKey({ name: entry.field })}?: boolean;`),
+      ...model.relations.map((relation) => `  readonly ${propKey({ name: relation.name })}?: ${relationSelectValue(relation)};`),
+      ...hasCounts ? [countLine] : []
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}Include`,
+    lines: [
+      ...model.relations.map((relation) => `  readonly ${propKey({ name: relation.name })}?: ${relationSelectValue(relation)};`),
+      ...hasCounts ? [countLine] : []
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}OmitInput`,
+    lines: [
+      ...model.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: boolean;`),
+      ...computedEntries.map((entry) => `  readonly ${propKey({ name: entry.field })}?: boolean;`)
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}Args`,
+    lines: [
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`,
+      `  readonly relationStrategy?: RelationStrategy;`
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}ListRelationFilter`,
+    lines: [
+      `  readonly some?: ${n}WhereInput;`,
+      `  readonly every?: ${n}WhereInput;`,
+      `  readonly none?: ${n}WhereInput;`
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}RelationFilter`,
+    lines: [`  readonly is?: ${n}WhereInput | null;`, `  readonly isNot?: ${n}WhereInput | null;`]
+  }));
+  const whereLines = [
+    `  readonly AND?: ${orMany({ type: `${n}WhereInput` })};`,
+    `  readonly OR?: readonly ${n}WhereInput[];`,
+    `  readonly NOT?: ${orMany({ type: `${n}WhereInput` })};`
+  ];
+  for (const field of model.fields) {
+    const key = propKey({ name: field.name });
+    if (field.isList || field.scalar === "Json") {
+      whereLines.push(`  readonly ${key}?: ${filterName({ field })};`);
+      continue;
+    }
+    const nullable = field.isOptional ? " | null" : "";
+    whereLines.push(`  readonly ${key}?: ${inputBaseType({ field })} | ${filterName({ field })}${nullable};`);
+  }
+  for (const relation of model.relations) {
+    const key = propKey({ name: relation.name });
+    if (relation.isList) {
+      whereLines.push(`  readonly ${key}?: ${relation.target}ListRelationFilter;`);
+    } else {
+      whereLines.push(`  readonly ${key}?: ${relation.target}RelationFilter | ${relation.target}WhereInput${relation.isOptional ? " | null" : ""};`);
+    }
+  }
+  parts.push(objectAlias({ name: `${n}WhereInput`, lines: whereLines }));
+  if (model.uniques.length === 0) {
+    parts.push(`export type ${n}WhereUniqueInput = never;`);
+  } else {
+    const members = model.uniques.map((member) => {
+      const first = member.fields[0];
+      if (member.fields.length === 1 && first !== undefined) {
+        return `{ readonly ${propKey({ name: first.name })}: ${inputBaseType({ field: first })} }`;
+      }
+      const inner = member.fields.map((field) => `readonly ${propKey({ name: field.name })}: ${inputBaseType({ field })}`).join("; ");
+      return `{ readonly ${propKey({ name: member.key })}: { ${inner} } }`;
+    });
+    parts.push(`export type ${n}WhereUniqueInput =
+  | ${members.join(`
+  | `)};`);
+  }
+  parts.push(objectAlias({
+    name: `${n}OrderByInput`,
+    lines: model.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: ${field.isOptional ? "SortOrderWithNulls" : "SortOrder"};`)
+  }));
+  parts.push(objectAlias({ name: `${n}CreateInput`, lines: checkedCreateLines({ model }) }));
+  parts.push(objectAlias({ name: `${n}UncheckedCreateInput`, lines: uncheckedCreateLines({ model }) }));
+  parts.push(`export type ${n}CreateManyInput = ${n}UncheckedCreateInput;`);
+  parts.push(objectAlias({ name: `${n}UpdateInput`, lines: checkedUpdateLines({ model }) }));
+  parts.push(objectAlias({ name: `${n}UncheckedUpdateInput`, lines: uncheckedUpdateLines({ model }) }));
+  parts.push(`export type ${n}UpdateManyInput = ${n}UncheckedUpdateInput;`);
+  const numericFields = model.fields.filter((field) => !field.isList && field.scalar !== null && NUMERIC_SCALARS.has(field.scalar));
+  const minmaxFields = model.fields.filter((field) => !field.isList && field.scalar !== null && MINMAX_SCALARS.has(field.scalar));
+  parts.push(objectAlias({
+    name: `${n}CountAggregateInput`,
+    lines: [
+      ...model.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: true;`),
+      `  readonly _all?: true;`
+    ]
+  }));
+  const aggregateOpProps = [`  readonly _count?: true | ${n}CountAggregateInput;`];
+  if (numericFields.length > 0) {
+    parts.push(objectAlias({
+      name: `${n}AvgAggregateInput`,
+      lines: numericFields.map((field) => `  readonly ${propKey({ name: field.name })}?: true;`)
+    }));
+    parts.push(`export type ${n}SumAggregateInput = ${n}AvgAggregateInput;`);
+    aggregateOpProps.push(`  readonly _avg?: ${n}AvgAggregateInput;`);
+    aggregateOpProps.push(`  readonly _sum?: ${n}SumAggregateInput;`);
+  }
+  if (minmaxFields.length > 0) {
+    parts.push(objectAlias({
+      name: `${n}MinAggregateInput`,
+      lines: minmaxFields.map((field) => `  readonly ${propKey({ name: field.name })}?: true;`)
+    }));
+    parts.push(`export type ${n}MaxAggregateInput = ${n}MinAggregateInput;`);
+    aggregateOpProps.push(`  readonly _min?: ${n}MinAggregateInput;`);
+    aggregateOpProps.push(`  readonly _max?: ${n}MaxAggregateInput;`);
+  }
+  parts.push(objectAlias({
+    name: `${n}FindManyArgs`,
+    lines: [
+      `  readonly where?: ${n}WhereInput;`,
+      `  readonly orderBy?: ${orMany({ type: `${n}OrderByInput` })};`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`,
+      `  readonly cursor?: ${n}WhereUniqueInput;`,
+      `  readonly take?: number;`,
+      `  readonly skip?: number;`,
+      `  readonly distinct?: ${orMany({ type: `${n}ScalarFieldEnum` })};`,
+      `  readonly relationStrategy?: RelationStrategy;`
+    ]
+  }));
+  parts.push(`export type ${n}FindFirstArgs = ${n}FindManyArgs;`);
+  parts.push(objectAlias({
+    name: `${n}FindUniqueArgs`,
+    lines: [
+      `  readonly where: ${n}WhereUniqueInput;`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`,
+      `  readonly relationStrategy?: RelationStrategy;`
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}CreateArgs`,
+    lines: [
+      `  readonly data: ${n}CreateInput | ${n}UncheckedCreateInput;`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}CreateManyArgs`,
+    lines: [
+      `  readonly data: ${orMany({ type: `${n}CreateManyInput` })};`,
+      `  readonly skipDuplicates?: boolean;`
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}CreateManyAndReturnArgs`,
+    lines: [
+      `  readonly data: ${orMany({ type: `${n}CreateManyInput` })};`,
+      `  readonly skipDuplicates?: boolean;`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly omit?: ${n}OmitInput;`
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}UpdateArgs`,
+    lines: [
+      `  readonly where: ${n}WhereUniqueInput;`,
+      `  readonly data: ${n}UpdateInput | ${n}UncheckedUpdateInput;`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}UpdateManyArgs`,
+    lines: [`  readonly where?: ${n}WhereInput;`, `  readonly data: ${n}UpdateManyInput;`]
+  }));
+  parts.push(objectAlias({
+    name: `${n}UpsertArgs`,
+    lines: [
+      `  readonly where: ${n}WhereUniqueInput;`,
+      `  readonly create: ${n}CreateInput | ${n}UncheckedCreateInput;`,
+      `  readonly update: ${n}UpdateInput | ${n}UncheckedUpdateInput;`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}DeleteArgs`,
+    lines: [
+      `  readonly where: ${n}WhereUniqueInput;`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`
+    ]
+  }));
+  parts.push(objectAlias({ name: `${n}DeleteManyArgs`, lines: [`  readonly where?: ${n}WhereInput;`] }));
+  parts.push(objectAlias({
+    name: `${n}CountArgs`,
+    lines: [
+      `  readonly where?: ${n}WhereInput;`,
+      `  readonly orderBy?: ${orMany({ type: `${n}OrderByInput` })};`,
+      `  readonly cursor?: ${n}WhereUniqueInput;`,
+      `  readonly take?: number;`,
+      `  readonly skip?: number;`
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}AggregateArgs`,
+    lines: [
+      `  readonly where?: ${n}WhereInput;`,
+      `  readonly orderBy?: ${orMany({ type: `${n}OrderByInput` })};`,
+      `  readonly cursor?: ${n}WhereUniqueInput;`,
+      `  readonly take?: number;`,
+      `  readonly skip?: number;`,
+      ...aggregateOpProps
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}GroupByArgs`,
+    lines: [
+      `  readonly by: readonly ${n}ScalarFieldEnum[];`,
+      `  readonly where?: ${n}WhereInput;`,
+      `  readonly orderBy?: ${orMany({ type: `${n}OrderByInput` })};`,
+      `  readonly having?: ${n}WhereInput;`,
+      `  readonly take?: number;`,
+      `  readonly skip?: number;`,
+      ...aggregateOpProps
+    ]
+  }));
+  const falseFilter = (source) => `${source}[K] extends false | undefined ? never : K`;
+  parts.push(`type ${n}OmitBase<A> = A extends { readonly omit: infer O extends object } ? Omit<${n}, OmittedKeys<O>> : ${n};`);
+  if (hasCounts) {
+    const listUnion = listRelations.map((relation) => tsString({ value: relation.name })).join(" | ");
+    const allCounts = listRelations.map((relation) => `${propKey({ name: relation.name })}: number`).join("; ");
+    parts.push(`type ${n}CountResult<C> = C extends { readonly select: infer CS extends object }
+` + `  ? { [K in keyof CS & (${listUnion}) as ${falseFilter("CS")}]: number }
+` + `  : { ${allCounts} };`);
+    parts.push(`type ${n}CountPayload<S> = S extends { readonly _count: infer C extends true | object } ? { _count: ${n}CountResult<C> } : unknown;`);
+  }
+  if (hasRelations) {
+    const relationCases = model.relations.map((relation) => {
+      const nested = `${relation.target}GetPayload<A>`;
+      const guard = `A extends { readonly select: unknown } | { readonly include: unknown } | { readonly omit: unknown }`;
+      let expression;
+      if (relation.isList) {
+        expression = `${guard} ? ${nested}[] : ${relation.target}[]`;
+      } else if (relation.isOptional) {
+        expression = `(${guard} ? ${nested} : ${relation.target}) | null`;
+      } else {
+        expression = `${guard} ? ${nested} : ${relation.target}`;
+      }
+      return `  ${propKey({ name: relation.name })}: ${expression};`;
+    }).join(`
+`);
+    parts.push(`type ${n}RelationPayload<K extends keyof ${n}Relations, A> = {
+${relationCases}
+}[K];`);
+    parts.push(`type ${n}IncludePayload<A> = A extends { readonly include: infer I extends object }
+` + `  ? { [K in keyof I & keyof ${n}Relations as ${falseFilter("I")}]: ${n}RelationPayload<K, I[K]> }${hasCounts ? ` & ${n}CountPayload<I>` : ""}
+` + `  : unknown;`);
+    parts.push(`export type ${n}GetPayload<A> = A extends { readonly select: infer S extends object }
+` + `  ? { [K in keyof S & ${selectableEnum} as ${falseFilter("S")}]: ${n}[K & keyof ${n}] } &
+` + `    { [K in keyof S & keyof ${n}Relations as ${falseFilter("S")}]: ${n}RelationPayload<K, S[K]> }${hasCounts ? ` &
+    ${n}CountPayload<S>` : ""}
+` + `  : ${n}OmitBase<A> & ${n}IncludePayload<A>;`);
+  } else {
+    parts.push(`export type ${n}GetPayload<A> = A extends { readonly select: infer S extends object }
+` + `  ? { [K in keyof S & ${selectableEnum} as ${falseFilter("S")}]: ${n}[K & keyof ${n}] }
+` + `  : ${n}OmitBase<A>;`);
+  }
+  parts.push(`export type ${n}AggregateResult<A> = {
+` + `  [K in keyof A & (${AGGREGATE_OPS_UNION})]:
+` + `    K extends "_count" ? (A[K] extends true ? number : { [F in keyof A[K]]: number })
+` + `    : K extends "_avg" ? { [F in keyof A[K]]: number | null }
+` + `    : { [F in keyof A[K] & keyof ${n}]: ${n}[F & keyof ${n}] | null };
+` + `};`);
+  parts.push(`export type ${n}GroupByResult<A extends ${n}GroupByArgs> =
+` + `  { [K in A["by"][number]]: ${n}[K & keyof ${n}] } & ${n}AggregateResult<A>;`);
+  const readMethods = [
+    `  findMany<A extends ${n}FindManyArgs = ${n}FindManyArgs>(args?: A): Promise<${n}GetPayload<A>[]>;`,
+    `  findFirst<A extends ${n}FindFirstArgs = ${n}FindFirstArgs>(args?: A): Promise<${n}GetPayload<A> | null>;`,
+    `  findFirstOrThrow<A extends ${n}FindFirstArgs = ${n}FindFirstArgs>(args?: A): Promise<${n}GetPayload<A>>;`,
+    `  findUnique<A extends ${n}FindUniqueArgs>(args: A): Promise<${n}GetPayload<A> | null>;`,
+    `  findUniqueOrThrow<A extends ${n}FindUniqueArgs>(args: A): Promise<${n}GetPayload<A>>;`
+  ];
+  const writeMethods = [
+    `  create<A extends ${n}CreateArgs>(args: A): Promise<${n}GetPayload<A>>;`,
+    `  createMany(args: ${n}CreateManyArgs): Promise<BatchPayload>;`,
+    `  createManyAndReturn<A extends ${n}CreateManyAndReturnArgs>(args: A): Promise<${n}GetPayload<A>[]>;`,
+    `  update<A extends ${n}UpdateArgs>(args: A): Promise<${n}GetPayload<A>>;`,
+    `  updateMany(args: ${n}UpdateManyArgs): Promise<BatchPayload>;`,
+    `  upsert<A extends ${n}UpsertArgs>(args: A): Promise<${n}GetPayload<A>>;`,
+    `  delete<A extends ${n}DeleteArgs>(args: A): Promise<${n}GetPayload<A>>;`,
+    `  deleteMany(args?: ${n}DeleteManyArgs): Promise<BatchPayload>;`
+  ];
+  const aggregateMethods = [
+    `  count(args?: ${n}CountArgs): Promise<number>;`,
+    `  aggregate<A extends ${n}AggregateArgs>(args: A): Promise<${n}AggregateResult<A>>;`,
+    `  groupBy<A extends ${n}GroupByArgs>(args: A): Promise<${n}GroupByResult<A>[]>;`
+  ];
+  const delegateMethods = model.isView ? [...readMethods, ...aggregateMethods] : [...readMethods, ...writeMethods, ...aggregateMethods];
+  delegateMethods.push(...params.extensionLines ?? []);
+  parts.push(`export type ${n}Delegate = {
+${delegateMethods.join(`
+`)}
+};`);
+  return parts.join(`
+
+`);
+}
+function emitViewTypesForModel(params) {
+  const { model, view } = params;
+  const n = model.name;
+  const hasRelations = model.relations.length > 0;
+  const parts = [];
+  parts.push(objectAlias({
+    name: `${n}ViewFields`,
+    lines: model.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: true;`)
+  }));
+  parts.push(objectAlias({
+    name: `${n}ViewSelect`,
+    lines: model.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: boolean;`)
+  }));
+  parts.push(`type ${n}ViewScalars<F> = { [K in keyof F & ${n}ScalarFieldEnum]: ${n}[K & keyof ${n}] };`);
+  if (hasRelations) {
+    parts.push(objectAlias({
+      name: `${n}ViewInclude`,
+      lines: model.relations.map((relation) => `  readonly ${propKey({ name: relation.name })}?: boolean | ${relation.target}ViewNestedArgs;`)
+    }));
+  }
+  parts.push(objectAlias({
+    name: `${n}ViewNestedArgs`,
+    lines: [
+      `  readonly where?: ${n}WhereInput;`,
+      `  readonly orderBy?: ${orMany({ type: `${n}OrderByInput` })};`,
+      `  readonly take?: number;`,
+      `  readonly skip?: number;`,
+      `  readonly select?: ${n}ViewSelect;`,
+      `  readonly reveal?: ${n}ViewSelect;`,
+      ...hasRelations ? [`  readonly include?: ${n}ViewInclude;`] : []
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}ViewFindManyArgs`,
+    lines: [
+      `  readonly where?: ${n}WhereInput;`,
+      `  readonly orderBy?: ${orMany({ type: `${n}OrderByInput` })};`,
+      `  readonly select?: ${n}ViewSelect;`,
+      `  readonly reveal?: ${n}ViewSelect;`,
+      ...hasRelations ? [`  readonly include?: ${n}ViewInclude;`] : [],
+      `  readonly cursor?: ${n}WhereUniqueInput;`,
+      `  readonly take?: number;`,
+      `  readonly skip?: number;`,
+      `  readonly distinct?: ${orMany({ type: `${n}ScalarFieldEnum` })};`,
+      `  readonly relationStrategy?: RelationStrategy;`
+    ]
+  }));
+  parts.push(objectAlias({
+    name: `${n}ViewFindUniqueArgs`,
+    lines: [
+      `  readonly where: ${n}WhereUniqueInput;`,
+      `  readonly select?: ${n}ViewSelect;`,
+      `  readonly reveal?: ${n}ViewSelect;`,
+      ...hasRelations ? [`  readonly include?: ${n}ViewInclude;`] : [],
+      `  readonly relationStrategy?: RelationStrategy;`
+    ]
+  }));
+  const falseFilter = (source) => `${source}[K] extends false | undefined ? never : K`;
+  parts.push(`type ${n}ViewSelectScalars<F, A> = A extends { readonly select: infer S extends object }
+` + `  ? { [K in keyof S & keyof F & ${n}ScalarFieldEnum as ${falseFilter("S")}]: ${n}[K & keyof ${n}] }
+` + `  : ${n}ViewScalars<F>;`);
+  parts.push(`type ${n}ViewReveal<A> = A extends { readonly reveal: infer R extends object }
+` + `  ? { [K in keyof R & ${n}ScalarFieldEnum as ${falseFilter("R")}]: ${n}[K & keyof ${n}] }
+` + `  : unknown;`);
+  if (hasRelations) {
+    const relationCases = model.relations.map((relation) => {
+      const target = relation.target;
+      const targetClientKey = view.modelByName.get(target)?.clientName ?? target;
+      const guard = `D extends { readonly ${propKey({ name: targetClientKey })}: infer RF extends object }`;
+      const masked = `ViewRow<${target}ViewScalars<RF>>`;
+      let expression;
+      if (relation.isList) {
+        expression = `${guard} ? ${masked}[] : ${target}[]`;
+      } else if (relation.isOptional) {
+        expression = `(${guard} ? ${masked} : ${target}) | null`;
+      } else {
+        expression = `${guard} ? ${masked} : ${target}`;
+      }
+      return `  ${propKey({ name: relation.name })}: ${expression};`;
+    }).join(`
+`);
+    parts.push(`type ${n}ViewRelationResult<K extends keyof ${n}Relations, D> = {
+${relationCases}
+}[K];`);
+    parts.push(`type ${n}ViewIncludeResult<A, D> = A extends { readonly include: infer I extends object }
+` + `  ? { [K in keyof I & keyof ${n}Relations as ${falseFilter("I")}]: ${n}ViewRelationResult<K, D> }
+` + `  : unknown;`);
+    parts.push(`export type ${n}ViewResult<F, A, D> = ViewRow<${n}ViewSelectScalars<F, A> & ${n}ViewReveal<A> & ${n}ViewIncludeResult<A, D>>;`);
+  } else {
+    parts.push(`export type ${n}ViewResult<F, A, D> = ViewRow<${n}ViewSelectScalars<F, A> & ${n}ViewReveal<A>>;`);
+  }
+  parts.push(`export type ${n}ViewDelegate<F, D extends ViewDefinitionInput = ViewDefinitionInput> = {
+` + `  findMany<A extends ${n}ViewFindManyArgs = ${n}ViewFindManyArgs>(args?: A): Promise<${n}ViewResult<F, A, D>[]>;
+` + `  findFirst<A extends ${n}ViewFindManyArgs = ${n}ViewFindManyArgs>(args?: A): Promise<${n}ViewResult<F, A, D> | null>;
+` + `  findFirstOrThrow<A extends ${n}ViewFindManyArgs = ${n}ViewFindManyArgs>(args?: A): Promise<${n}ViewResult<F, A, D>>;
+` + `  findUnique<A extends ${n}ViewFindUniqueArgs>(args: A): Promise<${n}ViewResult<F, A, D> | null>;
+` + `  findUniqueOrThrow<A extends ${n}ViewFindUniqueArgs>(args: A): Promise<${n}ViewResult<F, A, D>>;
+` + `  count(args?: ${n}CountArgs): Promise<number>;
+` + `  aggregate<A extends ${n}AggregateArgs>(args: A): Promise<${n}AggregateResult<A>>;
+` + `  groupBy<A extends ${n}GroupByArgs>(args: A): Promise<${n}GroupByResult<A>[]>;
+` + `};`);
+  return parts.join(`
+
+`);
+}
+function emitViewSection(params) {
+  const { view } = params;
+  const parts = [banner({ title: "Field-masking views ($defineView)" })];
+  parts.push(`/**
+` + ` * A masked row: definition fields are properties, JSON.stringify drops
+` + ` * revealed fields (toJSON), $unsafe() returns everything as a plain object.
+` + ` */
+` + `export type ViewRow<T> = T & {
+` + `  toJSON(): Partial<T>;
+` + `  $unsafe(): Record<string, unknown>;
+` + `};`);
+  parts.push(objectAlias({
+    name: "ViewDefinitionInput",
+    lines: view.models.map((model) => `  readonly ${propKey({ name: model.clientName })}?: ${model.name}ViewFields;`)
+  }));
+  parts.push(`type ViewDelegateMap<D extends ViewDefinitionInput> = {
+${view.models.map((model) => `  ${propKey({ name: model.clientName })}: ${model.name}ViewDelegate<NonNullable<D[${tsString({ value: model.clientName })}]>, D>;`).join(`
+`)}
+};`);
+  parts.push(`/** A read-only scoped client over the definition's models \u2014 what $defineView returns. */
+` + `export type ViewClient<D extends ViewDefinitionInput> = {
+` + `  readonly [K in keyof D & keyof ViewDelegateMap<D>]: ViewDelegateMap<D>[K];
+` + `};`);
+  for (const model of view.models) {
+    parts.push(emitViewTypesForModel({ model, view }));
+  }
+  return parts;
+}
+function emitClient(params) {
+  const { view, baked, hasComputed } = params;
+  const parts = [banner({ title: "Client" })];
+  parts.push(objectAlias({
+    name: "VibeClientOptions",
+    lines: [
+      `  readonly adapter: DatabaseAdapter;`,
+      `  readonly onQuery?: (event: QueryEvent) => void;`,
+      `  readonly relationStrategy?: RelationStrategy;`,
+      ...baked.empty ? [] : [
+        `  /** The live extension instances \u2014 verified against the baked manifest. */`,
+        `  readonly extensions?: readonly VibeExtension[];`
+      ],
+      ...hasComputed ? [
+        `  /** The live computed-field config \u2014 verified against the baked manifest (VIBE_STALE_CLIENT). */`,
+        `  readonly computed: ComputedConfig;`
+      ] : []
+    ]
+  }));
+  const delegateProps = view.models.map((model) => `  readonly ${propKey({ name: model.clientName })}: ${model.name}Delegate;`);
+  const clientExtensionLines = baked.clientDts.length === 0 ? "" : `${baked.clientDts.join(`
+`)}
+`;
+  parts.push(`export type VibeClientInstance = {
+` + `${delegateProps.join(`
+`)}
+` + `  readonly $transaction: <T>(fn: (tx: VibeClientInstance) => Promise<T>, options?: TransactionOptions) => Promise<T>;
+` + `  readonly $queryRaw: <T = Record<string, unknown>>(strings: TemplateStringsArray, ...values: unknown[]) => Promise<T[]>;
+` + `  readonly $executeRaw: (strings: TemplateStringsArray, ...values: unknown[]) => Promise<number>;
+` + `  readonly $queryRawUnsafe: <T = Record<string, unknown>>(text: string, ...values: unknown[]) => Promise<T[]>;
+` + `  readonly $executeRawUnsafe: (text: string, ...values: unknown[]) => Promise<number>;
+` + `  readonly $connect: () => Promise<void>;
+` + `  readonly $disconnect: () => Promise<void>;
+` + `  /** Field-masking views (v1 defineView parity): a read-only masked projection of models. */
+` + `  readonly $defineView: <D extends ViewDefinitionInput>(options: { readonly name: string; readonly definition: D }) => ViewClient<D>;
+` + clientExtensionLines + `};`);
+  parts.push(`/** Build a typed client over a database adapter. */
+export declare function VibeClient(options: VibeClientOptions): VibeClientInstance;`);
+  parts.push(`/** The normalized Schema IR this client was generated from (plain data). */
+export declare const schema: SchemaIR;`);
+  return parts.join(`
+
+`);
+}
+function emitDts(params) {
+  const { view } = params;
+  const baked = params.baked ?? EMPTY_BAKED_EXTENSIONS;
+  const computed = params.computed ?? [];
+  const hasComputed = computed.length > 0;
+  const computedByModel = new Map;
+  for (const entry of computed) {
+    const list = computedByModel.get(entry.model) ?? [];
+    list.push(entry);
+    computedByModel.set(entry.model, list);
+  }
+  const parts = [];
+  parts.push(`// Generated by VibeORM (@vibeorm/generator) \u2014 DO NOT EDIT.
+// Regenerate with \`vibeorm generate\` after every schema change.`);
+  const schemaTypeImports = [
+    "SchemaIR",
+    ...baked.empty ? [] : ["VibeExtension"],
+    ...hasComputed ? ["ComputedConfig"] : []
+  ].sort();
+  const importLines = [
+    `import type { DatabaseAdapter, QueryEvent, TransactionOptions } from "@vibeorm/runtime";`,
+    `import type { ${schemaTypeImports.join(", ")} } from "@vibeorm/schema";`,
+    ...baked.dtsImports
+  ];
+  parts.push(`${importLines.join(`
+`)}
+
+` + `export { VibeError } from "@vibeorm/schema";
+export type { VibeErrorCode } from "@vibeorm/schema";`);
+  parts.push(PREAMBLE);
+  parts.push(...filterSection());
+  for (const declared of view.enums)
+    parts.push(emitEnum({ declared }));
+  const registry = new Map;
+  const modelParts = [];
+  for (const model of view.models) {
+    const extensionLines = baked.delegateDts.get(model.name);
+    const modelComputed = computedByModel.get(model.name);
+    modelParts.push(emitModel({
+      model,
+      view,
+      registry,
+      ...extensionLines === undefined ? {} : { extensionLines },
+      ...modelComputed === undefined ? {} : { computed: modelComputed }
+    }));
+  }
+  parts.push(...modelParts);
+  if (registry.size > 0) {
+    parts.push(banner({ title: "Nested write inputs" }));
+    for (const name of [...registry.keys()].sort()) {
+      parts.push(registry.get(name));
+    }
+  }
+  if (baked.moduleDts.length > 0) {
+    parts.push(banner({ title: "Extensions" }));
+    parts.push(...baked.moduleDts);
+  }
+  parts.push(...emitViewSection({ view }));
+  parts.push(emitClient({ view, baked, hasComputed }));
+  return `${parts.join(`
+
+`)}
+`;
+}
+
+// packages/generator/src/emit-js.ts
+function emitJs(params) {
+  const { view } = params;
+  const baked = params.baked ?? EMPTY_BAKED_EXTENSIONS;
+  const computed = params.computed ?? [];
+  const hasComputed = computed.length > 0;
+  const parts = [];
+  parts.push(`// Generated by VibeORM (@vibeorm/generator) \u2014 DO NOT EDIT.
+// Regenerate with \`vibeorm generate\` after every schema change.`);
+  parts.push(`import { createClient } from "@vibeorm/runtime";`);
+  if (baked.jsImports.length > 0)
+    parts.push(baked.jsImports.join(`
+`));
+  parts.push(`export { VibeError } from "@vibeorm/schema";`);
+  parts.push(`/** The normalized Schema IR this client was generated from (plain data). */
+export const schema = ${stableStringify({ value: view.schema })};`);
+  for (const declared of view.enums) {
+    const entries = declared.values.map((value) => `  ${tsString({ value })}: ${tsString({ value })},`).join(`
+`);
+    parts.push(`export const ${declared.name} = Object.freeze({
+${entries}
+});`);
+  }
+  if (baked.empty && !hasComputed) {
+    parts.push(`/** Build a typed client over a database adapter. */
+` + `export function VibeClient(options) {
+` + `  const { adapter, ...clientOptions } = options;
+` + `  return createClient({ schema, adapter, options: clientOptions });
+` + `}`);
+    return `${parts.join(`
+
+`)}
+`;
+  }
+  if (!baked.empty) {
+    parts.push(`/** Extension manifest \u2014 verified against the live extension list (VIBE_STALE_CLIENT). */
+` + `const extensionManifest = ${stableStringify({ value: baked.manifest })};`);
+    parts.push(`/** Baked extension surfaces (extensions.md D9). */
+` + `const extensionMounts = [
+${baked.mounts.map((mount) => `  ${mount},`).join(`
+`)}
+];`);
+  }
+  if (hasComputed) {
+    parts.push(`/** Computed-field manifest \u2014 verified against the live computed config (VIBE_STALE_CLIENT). */
+` + `const computedManifest = ${stableStringify({ value: computed })};`);
+  }
+  const destructured = [
+    "adapter",
+    ...baked.empty ? [] : ["extensions"],
+    ...hasComputed ? ["computed"] : [],
+    "...clientOptions"
+  ].join(", ");
+  const createLines = [
+    `    schema,`,
+    `    adapter,`,
+    `    options: clientOptions,`,
+    ...baked.empty ? [] : [`    extensions: { manifest: extensionManifest, mounts: extensionMounts, instances: extensions ?? [] },`],
+    ...hasComputed ? [`    computed: { manifest: computedManifest, specs: computed },`] : []
+  ];
+  parts.push(`/** Build a typed client over a database adapter. */
+` + `export function VibeClient(options) {
+` + `  const { ${destructured} } = options;
+` + `  return createClient({
+${createLines.join(`
+`)}
+  });
+` + `}`);
+  return `${parts.join(`
+
+`)}
+`;
+}
+
+// packages/generator/src/schema-view.ts
+import { assertValidSchemaIR, isEnumType } from "@vibeorm/schema";
+function byName(left, right) {
+  return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+}
+function buildFieldView(params) {
+  const { field } = params;
+  const enumRef = isEnumType(field.type);
+  return {
+    name: field.name,
+    scalar: enumRef ? null : field.type,
+    enumName: enumRef ? field.type.enum : null,
+    isList: field.isList,
+    isOptional: field.isOptional,
+    isId: field.isId,
+    isUnique: field.isUnique,
+    hasDefault: field.default !== undefined,
+    isUpdatedAt: field.isUpdatedAt
+  };
+}
+function resolveInverse(params) {
+  const { relation, target } = params;
+  const candidates = target.relations.filter((candidate) => candidate.targetModel === relation.model && (candidate.relationName ?? null) === (relation.relationName ?? null) && !(candidate.model === relation.model && candidate.name === relation.name));
+  const first = candidates[0];
+  return candidates.length === 1 && first !== undefined ? first.name : null;
+}
+function buildUniques(params) {
+  const { model, fields } = params;
+  const fieldByName = new Map(fields.map((field) => [field.name, field]));
+  const members = [];
+  const seen = new Set;
+  const add = (names) => {
+    const key = names.join("_");
+    if (seen.has(key))
+      return;
+    const resolved = [];
+    for (const name of names) {
+      const field = fieldByName.get(name);
+      if (field === undefined)
+        return;
+      resolved.push(field);
+    }
+    seen.add(key);
+    members.push({ key, fields: resolved });
+  };
+  for (const field of fields) {
+    if (field.isId || field.isUnique)
+      add([field.name]);
+  }
+  if (model.primaryKey !== undefined && model.primaryKey.fields.length > 1) {
+    add(model.primaryKey.fields);
+  }
+  for (const index of model.indexes) {
+    if (index.kind === "unique")
+      add(index.fields.map((field) => field.name));
+  }
+  return members;
+}
+function buildModelView(params) {
+  const { model, modelIRByName } = params;
+  const fields = model.fields.filter((field) => field.isUnsupported !== true).map((field) => buildFieldView({ field }));
+  const fkFieldNames = new Set;
+  const relations = model.relations.map((relation) => {
+    for (const fk of relation.fields ?? [])
+      fkFieldNames.add(fk);
+    const target = modelIRByName.get(relation.targetModel);
+    return {
+      name: relation.name,
+      target: relation.targetModel,
+      type: relation.type,
+      isList: relation.isList,
+      isOptional: relation.isOptional,
+      fkFields: relation.fields ?? [],
+      inverseName: target === undefined ? null : resolveInverse({ relation, target })
+    };
+  });
+  return {
+    name: model.name,
+    clientName: clientNameOf({ name: model.name }),
+    fields,
+    relations,
+    uniques: buildUniques({ model, fields }),
+    fkFieldNames,
+    isView: model.isView
+  };
+}
+function buildSchemaView(params) {
+  const { schema } = params;
+  assertValidSchemaIR({ schema });
+  const normalized = {
+    datasource: schema.datasource,
+    models: [...schema.models].sort(byName),
+    enums: [...schema.enums].sort(byName),
+    extensions: [...schema.extensions].sort(byName)
+  };
+  const modelIRByName = new Map(normalized.models.map((model) => [model.name, model]));
+  const models = normalized.models.map((model) => buildModelView({ model, modelIRByName }));
+  return {
+    schema: normalized,
+    enums: normalized.enums.map((declared) => ({ name: declared.name, values: declared.values })),
+    models,
+    modelByName: new Map(models.map((model) => [model.name, model]))
+  };
+}
+
+// packages/generator/src/generate.ts
+var README = `# Generated VibeORM client
+
+This directory was generated by \`@vibeorm/generator\` from your VibeORM schema \u2014 do not edit it by hand, any change is overwritten on the next generate. After every schema change, regenerate with \`vibeorm generate\` (or programmatically via \`generateClient({ schema, outDir })\` from \`@vibeorm/generator\`).
+`;
+async function generateClient(params) {
+  const { schema, outDir } = params;
+  const view = buildSchemaView({ schema });
+  const baked = bakeExtensions({ schema: view.schema, extensions: params.extensions ?? [] });
+  let computed = [];
+  if (params.computed !== undefined && Object.keys(params.computed).length > 0) {
+    validateComputedConfig({ schema, computed: params.computed });
+    computed = buildComputedManifest({ computed: params.computed });
+  }
+  const outputs = [
+    { name: "index.js", content: emitJs({ view, baked, computed }) },
+    { name: "index.d.ts", content: emitDts({ view, baked, computed }) },
+    { name: "README.md", content: README }
+  ];
+  await mkdir(outDir, { recursive: true });
+  const files = [];
+  for (const output of outputs) {
+    const path = join(outDir, output.name);
+    await writeFile(path, output.content, "utf-8");
+    files.push(path);
+  }
+  return { files };
+}
+export {
+  generateClient,
+  bakeExtensions
+};
+
+//# debugId=793CBF3FCF2EA78F64756E2164756E21