@vibeorm/generator 1.3.1 → 2.0.0-alpha.10

package/dist/index.js

@@ -0,0 +1,2154 @@
+// @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/emit-js.ts
+import { internalError } 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/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-js.ts
+var HEADER = `// Generated by VibeORM (@vibeorm/generator) \u2014 DO NOT EDIT.
+// Regenerate with \`vibeorm generate\` after every schema change.`;
+function enumEntryExports(params) {
+  return [...params.view.enums.map((declared) => declared.name), "enumValidators"];
+}
+function emitEnumsJs(params) {
+  const { view } = params;
+  const parts = [
+    `${HEADER}
+// Lightweight entry: enum constants + boundary parsers. No runtime client, no schema module.`
+  ];
+  if (view.enums.length === 0) {
+    parts.push(`/** Boundary parsers grouped by enum name \u2014 this schema declares no enums. */
+` + `export const enumValidators = Object.freeze({});`);
+    return `${parts.join(`
+
+`)}
+`;
+  }
+  parts.push(`import { VibeError } from "@vibeorm/schema";`);
+  for (const declared of view.enums) {
+    const entries = declared.values.map((value) => `  ${value === "__proto__" ? `[${tsString({ value })}]` : tsString({ value })}: ${tsString({ value })},`).join(`
+`);
+    parts.push(`export const ${declared.name} = Object.freeze({
+${entries}
+});`);
+  }
+  parts.push(`/** Membership validator for one enum: \`values\`, \`is\`, \`parse\` (VIBE_VALIDATION on a non-member). */
+` + `function enumValidator(params) {
+` + `  const { name, values } = params;
+` + `  const members = new Set(values);
+` + `  const is = (value) => typeof value === "string" && members.has(value);
+` + `  return Object.freeze({
+` + `    values: Object.freeze([...values]),
+` + `    is,
+` + `    parse(input) {
+` + `      const { value } = input;
+` + `      if (is(value)) return value;
+` + `      const received = typeof value === "string" ? value.slice(0, 80) : value === null ? "null" : typeof value;
+` + `      throw new VibeError({
+` + `        code: "VIBE_VALIDATION",
+` + `        message: \`Invalid \${name} value \${JSON.stringify(received)} \u2014 expected one of \${values.join(", ")}\`,
+` + `        meta: { enum: name, received },
+` + `      });
+` + `    },
+` + `  });
+` + `}`);
+  const validatorLines = view.enums.map((declared) => `  ${declared.name === "__proto__" ? `[${tsString({ value: declared.name })}]` : declared.name}: enumValidator({ name: ${tsString({ value: declared.name })}, values: [${declared.values.map((value) => tsString({ value })).join(", ")}] }),`).join(`
+`);
+  parts.push(`/** Boundary parsers grouped by enum name, so an enum member named \`parse\` cannot collide. */
+` + `export const enumValidators = Object.freeze({
+${validatorLines}
+});`);
+  return `${parts.join(`
+
+`)}
+`;
+}
+function serializeSchema(params) {
+  const { schema } = params;
+  if (schema.rls === undefined)
+    return stableStringify({ value: schema });
+  return renderIr({ value: schema, indent: "", ordered: false });
+}
+function renderIr(params) {
+  const { value, indent: indent2, ordered } = 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 inner2 = `${indent2}  `;
+    const items2 = value.map((item) => inner2 + renderIr({ value: item, indent: inner2, ordered }));
+    return `[
+${items2.join(`,
+`)}
+${indent2}]`;
+  }
+  if (kind !== "object") {
+    throw internalError({ message: `internal: cannot serialize a ${kind} value into the generated client`, meta: { kind } });
+  }
+  const record = value;
+  const defined = Object.keys(record).filter((key) => record[key] !== undefined);
+  const keys = ordered ? defined : defined.sort();
+  if (keys.length === 0)
+    return "{}";
+  const inner = `${indent2}  `;
+  const items = keys.map((key) => `${inner}${JSON.stringify(key)}: ${renderIr({ value: record[key], indent: inner, ordered: ordered || key === "rls" })}`);
+  return `{
+${items.join(`,
+`)}
+${indent2}}`;
+}
+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(HEADER);
+  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(`export { SKIP } from "@vibeorm/runtime";`);
+  parts.push(`export { ${enumEntryExports({ view }).join(", ")} } from "./enums.js";`);
+  parts.push(`/** The normalized Schema IR this client was generated from (plain data). */
+export const schema = ${serializeSchema({ schema: view.schema })};`);
+  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/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 | DbNow",
+  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;
+  if (field.jsonType !== undefined)
+    return field.jsonType.name;
+  return field.enumName ?? PAYLOAD_TYPES[field.scalar];
+}
+function inputBaseType(params) {
+  const { field } = params;
+  if (field.jsonType !== undefined)
+    return field.jsonType.name;
+  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/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(`
+`)}
+};`;
+}
+var OPTIONAL_MEMBER = /^(\s*(?:readonly\s+)?(?:[A-Za-z_$][\w$]*|"(?:[^"\\]|\\.)*")\?:\s*)(.+);$/;
+function skippableMembers(params) {
+  return params.block.split(`
+`).map((line) => {
+    const match = OPTIONAL_MEMBER.exec(line);
+    const head = match?.[1];
+    const type = match?.[2];
+    if (head === undefined || type === undefined)
+      return line;
+    return `${head}${type.includes("=>") ? `(${type})` : type} | Skip;`;
+  }).join(`
+`);
+}
+function inputAlias(params) {
+  const { name, lines } = params;
+  return objectAlias({ name, lines: lines.map((block) => skippableMembers({ block })) });
+}
+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";
+
+/**
+ * An opaque, versioned keyset position (\`after\`) \u2014 ordering values plus a
+ * unique tie-breaker, minted by a previous page. It is ENCODED, not encrypted:
+ * whoever holds it can read the ordering values inside. It is also NOT an
+ * authorization credential \u2014 it selects a position, never a row, and every
+ * query still applies its own where/scoped/policy/RLS filters.
+ */
+export type KeysetToken = string;
+
+/** Per-query keyset options. */
+export type KeysetOptions = {
+  /**
+   * Asserts that every DateTime ordering column in this query holds
+   * millisecond-exact values. Required on postgres and mysql, whose timestamps
+   * may be finer than a JavaScript Date; NOT safe for \`@default(now())\`
+   * columns on postgres, which are microsecond-precise.
+   */
+  readonly timestampPrecision?: "milliseconds";
+};
+
+/** Result of createMany/updateMany/deleteMany. */
+export type BatchPayload = { readonly count: number };
+
+/**
+ * What upsertMany reports. \`count\` is the rows submitted after duplicate-key
+ * validation \u2014 every one of them was inserted or updated, since the statement
+ * has no skip arm and the whole operation is atomic. \`affectedRows\` is the
+ * driver's own number, and only where that number IS a row count: it is null on
+ * mysql, whose ON DUPLICATE KEY scores an insert 1, a changed update 2 and an
+ * unchanged update 0.
+ */
+export type UpsertManyPayload = { readonly count: number; readonly affectedRows: number | null };
+
+/**
+ * An argument member as the RESULT machinery must read it. Absent and the
+ * \`SKIP\` sentinel both mean "not provided", so neither may narrow a payload:
+ * without this, \`{ omit?: UserOmitInput | Skip }\` would collapse the key
+ * helpers below to \`never\` and promise fields the query may still have dropped.
+ */
+type Provided<T> = Exclude<T, Skip | undefined>;
+
+/** 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 };
+
+/** Keys a selection has not RULED OUT \u2014 everything except a literal false/undefined. */
+type PossibleKeys<S> = keyof { [K in keyof S as S[K] extends false | undefined ? never : K]: 0 };
+
+/**
+ * Keys whose flag can STILL be false or missing when the query runs \u2014 a widened
+ * \`boolean\`, or an optional nested selection. They are emitted OPTIONAL: the
+ * result type must not promise a field a run-time flag can switch off.
+ */
+type UncertainKeys<S> = PossibleKeys<S> &
+  keyof { [K in keyof S as [false] extends [S[K]] ? K : [undefined] extends [S[K]] ? K : never]: 0 };
+
+/** Keys the selection definitely turns on: a literal \`true\`, or a nested selection object. */
+type ExactKeys<S> = Exclude<PossibleKeys<S>, UncertainKeys<S>>;
+
+/** An aggregate object is absent when none of its selectors is enabled. */
+type HasSelectedField<S> = [S] extends [true] ? true : [S] extends [object] ? ExactKeys<S> extends never ? false : true : false;`;
+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, clock: true },
+  { 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 point = config.clock === true ? `${value} | DbNow` : value;
+  const valueOrNull = nullable ? `${point} | null` : point;
+  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?: ${point};`);
+    lines.push(`  readonly lte?: ${point};`);
+    lines.push(`  readonly gt?: ${point};`);
+    lines.push(`  readonly gte?: ${point};`);
+  }
+  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 inputAlias({ name, lines });
+}
+function scalarListFilterAlias(params) {
+  const { config } = params;
+  const value = config.value;
+  const array = `readonly ${maybeParens({ type: value })}[]`;
+  return inputAlias({
+    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 inputAlias({
+    name,
+    lines: [
+      `  readonly set?: ${nullable ? `${value} | null` : value};`,
+      `  readonly increment?: ${value};`,
+      `  readonly decrement?: ${value};`,
+      `  readonly multiply?: ${value};`,
+      `  readonly divide?: ${value};`
+    ]
+  });
+}
+function jsonFilterAlias(params) {
+  const { nullable } = params;
+  const document = nullable ? "InputJsonValue | null" : "InputJsonValue";
+  return inputAlias({
+    name: nullable ? "JsonNullableFilter" : "JsonFilter",
+    lines: [
+      `  readonly path?: readonly (string | number)[];`,
+      `  readonly mode?: "default" | "insensitive";`,
+      `  readonly equals?: ${document};`,
+      `  readonly not?: ${document};`,
+      `  readonly string_contains?: string;`,
+      `  readonly string_starts_with?: string;`,
+      `  readonly string_ends_with?: string;`,
+      `  readonly array_contains?: InputJsonValue;`,
+      `  readonly array_starts_with?: InputJsonValue;`,
+      `  readonly array_ends_with?: InputJsonValue;`
+    ]
+  });
+}
+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(jsonFilterAlias({ nullable: false }));
+  parts.push(jsonFilterAlias({ nullable: true }));
+  parts.push(inputAlias({
+    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;
+}
+var GENERATED_HEADER = `// Generated by VibeORM (@vibeorm/generator) \u2014 DO NOT EDIT.
+// Regenerate with \`vibeorm generate\` after every schema change.`;
+function emitEnumDeclaration(params) {
+  const { declared } = params;
+  const name = declared.name;
+  const valueLines = declared.values.map((value) => `  readonly ${propKey({ name: value })}: ${tsString({ value })};`);
+  return [
+    banner({ title: `Enum ${name}` }),
+    `export declare const ${name}: {
+${valueLines.join(`
+`)}
+};`,
+    `export type ${name} = ${declared.values.map((value) => tsString({ value })).join(" | ")};`,
+    `/** Boundary validator for ${name}: \`values\`, \`is\`, \`parse\` (throws VIBE_VALIDATION on a non-member). */
+` + `export type ${name}Validator = {
+` + `  readonly values: readonly ${name}[];
+` + `  is(value: unknown): value is ${name};
+` + `  parse(params: { readonly value: unknown }): ${name};
+` + `};`
+  ].join(`
+
+`);
+}
+function emitEnumsDts(params) {
+  const { view } = params;
+  const parts = [
+    `${GENERATED_HEADER}
+// Lightweight entry: enum constants + boundary parsers. No runtime client, no schema module.`
+  ];
+  for (const declared of view.enums)
+    parts.push(emitEnumDeclaration({ declared }));
+  parts.push(banner({ title: "Enum validators" }));
+  const validatorLines = view.enums.map((declared) => `  readonly ${declared.name}: ${declared.name}Validator;`);
+  parts.push(`/** Boundary parsers grouped by enum name, so an enum member named \`parse\` cannot collide. */
+` + (validatorLines.length === 0 ? `export declare const enumValidators: Record<string, never>;` : `export declare const enumValidators: {
+${validatorLines.join(`
+`)}
+};`));
+  return `${parts.join(`
+
+`)}
+`;
+}
+function emitEnum(params) {
+  const { declared } = params;
+  const name = declared.name;
+  const parts = [banner({ title: `Enum ${name} filters` })];
+  const array = `readonly ${name}[]`;
+  parts.push(inputAlias({
+    name: `${name}Filter`,
+    lines: [
+      `  readonly equals?: ${name};`,
+      `  readonly in?: ${array};`,
+      `  readonly notIn?: ${array};`,
+      `  readonly not?: ${name} | ${name}Filter;`
+    ]
+  }));
+  parts.push(inputAlias({
+    name: `${name}NullableFilter`,
+    lines: [
+      `  readonly equals?: ${name} | null;`,
+      `  readonly in?: ${array};`,
+      `  readonly notIn?: ${array};`,
+      `  readonly not?: ${name} | ${name}NullableFilter | null;`
+    ]
+  }));
+  parts.push(inputAlias({
+    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: inputAlias({
+        name: `${t}Create${suffix}Input`,
+        lines: checkedCreateLines({ model: target, omitRelation: inverse })
+      })
+    });
+    register({
+      registry,
+      name: `${t}UncheckedCreate${suffix}Input`,
+      text: inputAlias({
+        name: `${t}UncheckedCreate${suffix}Input`,
+        lines: uncheckedCreateLines({ model: target, omitRelation: inverse })
+      })
+    });
+    register({
+      registry,
+      name: `${t}Update${suffix}Input`,
+      text: inputAlias({
+        name: `${t}Update${suffix}Input`,
+        lines: checkedUpdateLines({ model: target, omitRelation: inverse })
+      })
+    });
+    register({
+      registry,
+      name: `${t}UncheckedUpdate${suffix}Input`,
+      text: inputAlias({
+        name: `${t}UncheckedUpdate${suffix}Input`,
+        lines: uncheckedUpdateLines({ model: target, omitRelation: inverse })
+      })
+    });
+  }
+  const connectOrCreateName = `${t}ConnectOrCreate${suffix}Input`;
+  register({
+    registry,
+    name: connectOrCreateName,
+    text: inputAlias({
+      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: inputAlias({
+        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: inputAlias({
+        name: updateWithWhere,
+        lines: [`  readonly where: ${t}WhereUniqueInput;`, `  readonly data: ${updateUnion};`]
+      })
+    });
+    const updateManyWithWhere = `${t}UpdateManyWithWhere${suffix}Input`;
+    register({
+      registry,
+      name: updateManyWithWhere,
+      text: inputAlias({
+        name: updateManyWithWhere,
+        lines: [`  readonly where: ${t}WhereInput;`, `  readonly data: ${t}UpdateManyInput;`]
+      })
+    });
+    const upsertWithWhere = `${t}UpsertWithWhereUnique${suffix}Input`;
+    register({
+      registry,
+      name: upsertWithWhere,
+      text: inputAlias({
+        name: upsertWithWhere,
+        lines: [
+          `  readonly where: ${t}WhereUniqueInput;`,
+          `  readonly create: ${createUnion};`,
+          `  readonly update: ${updateUnion};`
+        ]
+      })
+    });
+    register({
+      registry,
+      name: `${t}UpdateNestedMany${suffix}Input`,
+      text: inputAlias({
+        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: inputAlias({
+        name: `${t}CreateNestedOne${suffix}Input`,
+        lines: [
+          `  readonly create?: ${createUnion};`,
+          `  readonly connect?: ${t}WhereUniqueInput;`,
+          `  readonly connectOrCreate?: ${connectOrCreateName};`
+        ]
+      })
+    });
+    register({
+      registry,
+      name: `${t}UpdateNestedOne${suffix}Input`,
+      text: inputAlias({
+        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;`] : []
+        ]
+      })
+    });
+  }
+}
+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(inputAlias({
+      name: `${n}CountSelect`,
+      lines: listRelations.map((relation) => `  readonly ${propKey({ name: relation.name })}?: boolean | { readonly where?: ${relation.target}WhereInput };`)
+    }));
+  }
+  parts.push(inputAlias({
+    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(inputAlias({
+    name: `${n}Include`,
+    lines: [
+      ...model.relations.map((relation) => `  readonly ${propKey({ name: relation.name })}?: ${relationSelectValue(relation)};`),
+      ...hasCounts ? [countLine] : []
+    ]
+  }));
+  parts.push(inputAlias({
+    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(inputAlias({
+    name: `${n}Args`,
+    lines: [
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`,
+      `  readonly relationStrategy?: RelationStrategy;`
+    ]
+  }));
+  parts.push(inputAlias({
+    name: `${n}ListRelationFilter`,
+    lines: [
+      `  readonly some?: ${n}WhereInput;`,
+      `  readonly every?: ${n}WhereInput;`,
+      `  readonly none?: ${n}WhereInput;`
+    ]
+  }));
+  parts.push(inputAlias({
+    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(inputAlias({ 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 })}${member.nullsNotDistinct && first.isOptional ? " | null" : ""} }`;
+      }
+      const inner = member.fields.map((field) => `readonly ${propKey({ name: field.name })}: ${inputBaseType({ field })}${member.nullsNotDistinct && field.isOptional ? " | null" : ""}`).join("; ");
+      return `{ readonly ${propKey({ name: member.key })}: { ${inner} } }`;
+    });
+    parts.push(`export type ${n}WhereUniqueInput =
+  | ${members.join(`
+  | `)};`);
+  }
+  parts.push(inputAlias({
+    name: `${n}OrderByInput`,
+    lines: model.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: ${field.isOptional ? "SortOrderWithNulls" : "SortOrder"};`)
+  }));
+  parts.push(inputAlias({ name: `${n}CreateInput`, lines: checkedCreateLines({ model }) }));
+  parts.push(inputAlias({ name: `${n}UncheckedCreateInput`, lines: uncheckedCreateLines({ model }) }));
+  parts.push(`export type ${n}CreateManyInput = ${n}UncheckedCreateInput;`);
+  parts.push(inputAlias({ name: `${n}UpdateInput`, lines: checkedUpdateLines({ model }) }));
+  parts.push(inputAlias({ 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(inputAlias({
+    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(inputAlias({
+      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(inputAlias({
+      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(inputAlias({
+    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 after?: KeysetToken;`,
+      `  readonly keyset?: KeysetOptions;`,
+      `  readonly take?: number;`,
+      `  readonly skip?: number;`,
+      `  readonly distinct?: ${orMany({ type: `${n}ScalarFieldEnum` })};`,
+      `  readonly relationStrategy?: RelationStrategy;`,
+      `  readonly lock?: "update";`
+    ]
+  }));
+  parts.push(`export type ${n}FindFirstArgs = ${n}FindManyArgs;`);
+  parts.push(inputAlias({
+    name: `${n}FindUniqueArgs`,
+    lines: [
+      `  readonly where: ${n}WhereUniqueInput;`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`,
+      `  readonly relationStrategy?: RelationStrategy;`,
+      `  readonly lock?: "update";`
+    ]
+  }));
+  parts.push(inputAlias({
+    name: `${n}CreateArgs`,
+    lines: [
+      `  readonly data: ${n}CreateInput | ${n}UncheckedCreateInput;`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`
+    ]
+  }));
+  parts.push(`export type ${n}ConflictTarget = readonly ${n}ScalarFieldEnum[] | { readonly constraint: string };`);
+  parts.push(inputAlias({
+    name: `${n}CreateOnConflictInput`,
+    lines: [
+      `  readonly action: "nothing";`,
+      `  readonly target?: ${n}ConflictTarget;`,
+      `  readonly where?: string;`
+    ]
+  }));
+  parts.push(inputAlias({
+    name: `${n}CreateOrSkipArgs`,
+    lines: [
+      `  readonly data: ${n}CreateInput | ${n}UncheckedCreateInput;`,
+      `  readonly onConflict: ${n}CreateOnConflictInput;`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`
+    ]
+  }));
+  parts.push(inputAlias({
+    name: `${n}CreateManyArgs`,
+    lines: [
+      `  readonly data: ${orMany({ type: `${n}CreateManyInput` })};`,
+      `  readonly skipDuplicates?: boolean | { readonly target?: ${n}ConflictTarget; readonly where?: string };`
+    ]
+  }));
+  parts.push(inputAlias({
+    name: `${n}CreateManyAndReturnArgs`,
+    lines: [
+      `  readonly data: ${orMany({ type: `${n}CreateManyInput` })};`,
+      `  readonly skipDuplicates?: boolean | { readonly target?: ${n}ConflictTarget; readonly where?: string };`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly omit?: ${n}OmitInput;`
+    ]
+  }));
+  parts.push(inputAlias({
+    name: `${n}UpsertManyArgs`,
+    lines: [
+      `  readonly data: readonly ${n}CreateManyInput[];`,
+      `  readonly conflictTarget: ${n}ConflictTarget;`,
+      `  readonly conflictWhere?: string;`,
+      `  readonly update: readonly ${n}ScalarFieldEnum[];`,
+      `  readonly skipUpdatedAt?: boolean;`,
+      `  readonly allowAnyUniqueConflict?: boolean;`
+    ]
+  }));
+  parts.push(inputAlias({
+    name: `${n}UpdateArgs`,
+    lines: [
+      `  readonly where: ${n}UpdateWhereInput;`,
+      `  readonly data: ${n}UpdateInput | ${n}UncheckedUpdateInput;`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`,
+      `  readonly skipUpdatedAt?: boolean;`
+    ]
+  }));
+  parts.push(`/** update()'s where: a concrete unique selector AND any additional predicates (optimistic-concurrency guards such as \`{ id, version }\`). */
+export type ${n}UpdateWhereInput = ${n}WhereUniqueInput & ${n}WhereInput;`);
+  parts.push(inputAlias({
+    name: `${n}UpdateManyArgs`,
+    lines: [
+      `  readonly where?: ${n}WhereInput;`,
+      `  readonly data: ${n}UpdateManyInput;`,
+      `  readonly skipUpdatedAt?: boolean;`
+    ]
+  }));
+  parts.push(inputAlias({
+    name: `${n}UpdateManyAndReturnArgs`,
+    lines: [
+      `  readonly include?: never;`,
+      `  readonly where?: ${n}WhereInput;`,
+      `  readonly data: ${n}UpdateManyInput;`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly omit?: ${n}OmitInput;`,
+      `  readonly skipUpdatedAt?: boolean;`
+    ]
+  }));
+  parts.push(inputAlias({
+    name: `${n}UpsertArgs`,
+    lines: [
+      `  readonly where: ${n}WhereUniqueInput;`,
+      `  readonly create: ${n}CreateInput | ${n}UncheckedCreateInput;`,
+      `  readonly update: ${n}UpdateInput | ${n}UncheckedUpdateInput;`,
+      `  readonly onConflict?: { readonly constraint: string };`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`
+    ]
+  }));
+  parts.push(inputAlias({
+    name: `${n}DeleteArgs`,
+    lines: [
+      `  readonly where: ${n}WhereUniqueInput;`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`
+    ]
+  }));
+  parts.push(inputAlias({ name: `${n}DeleteManyArgs`, lines: [`  readonly where?: ${n}WhereInput;`] }));
+  parts.push(inputAlias({
+    name: `${n}CountArgs`,
+    lines: [
+      `  readonly select?: ${n}CountAggregateInput;`,
+      `  readonly where?: ${n}WhereInput;`,
+      `  readonly orderBy?: ${orMany({ type: `${n}OrderByInput` })};`,
+      `  readonly cursor?: ${n}WhereUniqueInput;`,
+      `  readonly take?: number;`,
+      `  readonly skip?: number;`
+    ]
+  }));
+  parts.push(inputAlias({
+    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(inputAlias({
+    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 exactPart = (source) => `${source}[K] extends false | undefined ? never : false extends ${source}[K] ? never : undefined extends ${source}[K] ? never : K`;
+  const uncertainPart = (source) => `${source}[K] extends false | undefined ? never : false extends ${source}[K] ? K : undefined extends ${source}[K] ? K : never`;
+  parts.push(`type ${n}OmitBase<A> = A extends { readonly omit: infer O extends object }
+` + `  ? Omit<${n}, PossibleKeys<O> & keyof ${n}> & { [K in UncertainKeys<O> & keyof ${n}]?: ${n}[K] }
+` + `  : "omit" extends keyof A ? Omit<${n}, PossibleKeys<Provided<A["omit"]>> & keyof ${n}> & Partial<Pick<${n}, PossibleKeys<Provided<A["omit"]>> & keyof ${n}>> : ${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 ${exactPart("CS")}]: number } &
+` + `    { [K in keyof CS & (${listUnion}) as ${uncertainPart("CS")}]?: number }
+` + `  : { ${allCounts} };`);
+    parts.push(`type ${n}CountPayload<S> = S extends { readonly _count: infer C extends true | object } ? { _count: ${n}CountResult<C> }
+` + `  : S extends { readonly _count: false | undefined } ? unknown
+` + `  : S extends { readonly _count?: infer C extends boolean | object } ? { _count?: ${n}CountResult<C> } : unknown;`);
+  }
+  if (hasRelations) {
+    const relationCases = model.relations.map((relation) => {
+      const nested = `${relation.target}GetPayload<A>`;
+      const guard = `A extends object`;
+      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 ${exactPart("I")}]: ${n}RelationPayload<K, I[K]> } &
+` + `    { [K in keyof I & keyof ${n}Relations as ${uncertainPart("I")}]?: ${n}RelationPayload<K, I[K]> }${hasCounts ? ` &
+    ${n}CountPayload<I>` : ""}
+` + `  : "include" extends keyof A ? Partial<${n}IncludePayload<{ include: Provided<A["include"]> }>> : unknown;`);
+    parts.push(`export type ${n}GetPayload<A> = A extends { readonly select: infer S extends object }
+` + `  ? { [K in keyof S & ${selectableEnum} as ${exactPart("S")}]: ${n}[K & keyof ${n}] } &
+` + `    { [K in keyof S & ${selectableEnum} as ${uncertainPart("S")}]?: ${n}[K & keyof ${n}] } &
+` + `    { [K in keyof S & keyof ${n}Relations as ${exactPart("S")}]: ${n}RelationPayload<K, S[K]> } &
+` + `    { [K in keyof S & keyof ${n}Relations as ${uncertainPart("S")}]?: ${n}RelationPayload<K, S[K]> }${hasCounts ? ` &
+    ${n}CountPayload<S>` : ""}
+` + `  : "select" extends keyof A ? Partial<${n}>
+` + `  : ${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 ${exactPart("S")}]: ${n}[K & keyof ${n}] } &
+` + `    { [K in keyof S & ${selectableEnum} as ${uncertainPart("S")}]?: ${n}[K & keyof ${n}] }
+` + `  : "select" extends keyof A ? Partial<${n}> : ${n}OmitBase<A>;`);
+  }
+  const aggregateFields = (fields, value) => `{ ${fields.map((field) => `${propKey({ name: field.name })}: ${value(field)}`).join("; ")} }`;
+  const countValues = aggregateFields(model.fields, () => "number").replace(" }", "; _all: number }");
+  parts.push(`type ${n}AggregateValues = {
+` + `  _count: ${countValues};
+` + `  _avg: ${aggregateFields(numericFields, () => "number | null")};
+` + `  _sum: ${aggregateFields(numericFields, (field) => `${n}[${tsString({ value: field.name })}] | null`)};
+` + `  _min: ${aggregateFields(minmaxFields, (field) => `${n}[${tsString({ value: field.name })}] | null`)};
+` + `  _max: ${aggregateFields(minmaxFields, (field) => `${n}[${tsString({ value: field.name })}] | null`)};
+};`);
+  parts.push(`type ${n}AggregateSelection<V, S> = S extends true ? number : S extends object
+` + `  ? { [K in keyof S & keyof V as ${exactPart("S")}]: V[K] } &
+` + `    { [K in keyof S & keyof V as ${uncertainPart("S")}]?: V[K] } : never;`);
+  parts.push(`type ${n}CountOutput<A> = A extends { readonly select: infer S extends object }
+` + `  ? ${n}AggregateSelection<${n}AggregateValues["_count"], S>
+` + `  : "select" extends keyof A ? number | ${n}AggregateSelection<${n}AggregateValues["_count"], Provided<A["select"]>> : number;`);
+  parts.push(`export type ${n}AggregateResult<A> =
+` + `  { [K in keyof A & keyof ${n}AggregateValues as HasSelectedField<A[K]> extends true ? K : never]: ${n}AggregateSelection<${n}AggregateValues[K], A[K]> } &
+` + `  { [K in keyof A & keyof ${n}AggregateValues as HasSelectedField<A[K]> extends true ? never : K]?: ${n}AggregateSelection<${n}AggregateValues[K], Provided<A[K]>> };`);
+  parts.push(`export type ${n}GroupByResult<A extends ${n}GroupByArgs> =
+` + `  (number extends A["by"]["length"] ? Partial<Pick<${n}, A["by"][number]>> : Pick<${n}, A["by"][number]>) & ${n}AggregateResult<A>;`);
+  const readMethods = [
+    `  findMany<A extends ${n}FindManyArgs = {}>(args?: A): Promise<${n}GetPayload<A>[]>;`,
+    `  findFirst<A extends ${n}FindFirstArgs = {}>(args?: A): Promise<${n}GetPayload<A> | null>;`,
+    `  findFirstOrThrow<A extends ${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}CreateOrSkipArgs>(args: A): Promise<${n}GetPayload<A> | null>;`,
+    `  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>;`,
+    `  updateManyAndReturn<A extends ${n}UpdateManyAndReturnArgs>(args: A): Promise<${n}GetPayload<A>[]>;`,
+    `  upsert<A extends ${n}UpsertArgs>(args: A): Promise<${n}GetPayload<A>>;`,
+    `  upsertMany(args: ${n}UpsertManyArgs): Promise<UpsertManyPayload>;`,
+    `  delete<A extends ${n}DeleteArgs>(args: A): Promise<${n}GetPayload<A>>;`,
+    `  deleteMany(args?: ${n}DeleteManyArgs): Promise<BatchPayload>;`
+  ];
+  const aggregateMethods = [
+    `  count<A extends ${n}CountArgs = {}>(args?: A): Promise<${n}CountOutput<A>>;`,
+    `  aggregate<A extends ${n}AggregateArgs>(args: A): Promise<${n}AggregateResult<A>>;`,
+    `  groupBy<const 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 exactPart = (source) => `${source}[K] extends false | undefined ? never : false extends ${source}[K] ? never : undefined extends ${source}[K] ? never : K`;
+  const uncertainPart = (source) => `${source}[K] extends false | undefined ? never : false extends ${source}[K] ? K : undefined extends ${source}[K] ? K : never`;
+  parts.push(`type ${n}ViewSelectScalars<F, A> = A extends { readonly select: infer S extends object }
+` + `  ? { [K in keyof S & keyof F & ${n}ScalarFieldEnum as ${exactPart("S")}]: ${n}[K & keyof ${n}] } &
+` + `    { [K in keyof S & keyof F & ${n}ScalarFieldEnum as ${uncertainPart("S")}]?: ${n}[K & keyof ${n}] }
+` + `  : "select" extends keyof A ? Partial<${n}ViewScalars<F>> : ${n}ViewScalars<F>;`);
+  parts.push(`type ${n}ViewReveal<A> = A extends { readonly reveal: infer R extends object }
+` + `  ? { [K in keyof R & ${n}ScalarFieldEnum as ${exactPart("R")}]: ${n}[K & keyof ${n}] } &
+` + `    { [K in keyof R & ${n}ScalarFieldEnum as ${uncertainPart("R")}]?: ${n}[K & keyof ${n}] }
+` + `  : "reveal" extends keyof A ? Partial<${n}ViewReveal<{ reveal: NonNullable<A["reveal"]> }>> : 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}ViewSelectScalars<RF, A> & ${target}ViewReveal<A>>`;
+      const unmasked = `(A extends object ? ${target}GetPayload<A> : ${target})`;
+      let expression;
+      if (relation.isList) {
+        expression = `${guard} ? ${masked}[] : ${unmasked}[]`;
+      } else if (relation.isOptional) {
+        expression = `(${guard} ? ${masked} : ${unmasked}) | null`;
+      } else {
+        expression = `${guard} ? ${masked} : ${unmasked}`;
+      }
+      return `  ${propKey({ name: relation.name })}: ${expression};`;
+    }).join(`
+`);
+    parts.push(`type ${n}ViewRelationResult<K extends keyof ${n}Relations, D, A> = {
+${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 ${exactPart("I")}]: ${n}ViewRelationResult<K, D, I[K]> } &
+` + `    { [K in keyof I & keyof ${n}Relations as ${uncertainPart("I")}]?: ${n}ViewRelationResult<K, D, I[K]> }
+` + `  : "include" extends keyof A ? Partial<${n}ViewIncludeResult<{ include: NonNullable<A["include"]> }, 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 = {}>(args?: A): Promise<${n}ViewResult<F, A, D>[]>;
+` + `  findFirst<A extends ${n}ViewFindManyArgs = {}>(args?: A): Promise<${n}ViewResult<F, A, D> | null>;
+` + `  findFirstOrThrow<A extends ${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<A extends ${n}CountArgs = {}>(args?: A): Promise<${n}CountOutput<A>>;
+` + `  aggregate<A extends ${n}AggregateArgs>(args: A): Promise<${n}AggregateResult<A>>;
+` + `  groupBy<const 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 jsonTypeImportLines(params) {
+  const bySpecifier = new Map;
+  for (const model of params.view.models) {
+    for (const field of model.fields) {
+      if (field.jsonType === undefined)
+        continue;
+      const names = bySpecifier.get(field.jsonType.from) ?? new Set;
+      names.add(field.jsonType.name);
+      bySpecifier.set(field.jsonType.from, names);
+    }
+  }
+  return [...bySpecifier.keys()].sort().map((from) => `import type { ${[...bySpecifier.get(from)].sort().join(", ")} } from ${tsString({ value: from })};`);
+}
+function hasNativeRls(params) {
+  return params.view.schema.rls !== undefined;
+}
+var RLS_CONTEXT_TYPES = {
+  String: "string",
+  Boolean: "boolean",
+  Int: "number",
+  BigInt: "bigint",
+  Float: "number",
+  Decimal: "string",
+  DateTime: "Date"
+};
+function emitRlsSection(params) {
+  const rls = params.view.schema.rls;
+  if (rls === undefined)
+    return [];
+  const lines = Object.entries(rls.context).map(([key, slot]) => `  readonly ${propKey({ name: key })}: ${RLS_CONTEXT_TYPES[slot.type]}${slot.nullable ? " | null" : ""};`);
+  const doc = `/** The identity context every query on this schema must be bound to \u2014 all slots required, an explicit null included. */`;
+  return [
+    banner({ title: "Native row-level security" }),
+    lines.length === 0 ? `${doc}
+export type RlsContext = Record<string, never>;` : `${doc}
+export type RlsContext = {
+${lines.join(`
+`)}
+};`
+  ];
+}
+function instanceSurfaceLines(params) {
+  const { view, selfType } = params;
+  const delegateProps = view.models.map((model) => `  readonly ${propKey({ name: model.clientName })}: ${model.name}Delegate;`);
+  const modelsProps = view.models.flatMap((model) => {
+    const byClientName = `    readonly ${propKey({ name: model.clientName })}: ${model.name}Delegate;`;
+    return model.name === model.clientName ? [byClientName] : [byClientName, `    readonly ${propKey({ name: model.name })}: ${model.name}Delegate;`];
+  });
+  return `${delegateProps.join(`
+`)}
+` + `  /** Delegates keyed by BOTH camelCase client name and model name \u2014 the same objects as the top-level properties (dynamic access). */
+` + `  readonly $models: {
+${modelsProps.join(`
+`)}
+  };
+` + `  /** Subscribe to client events ("query" fires after every statement, with the same payload as onQuery \u2014 both fire). Returns an unsubscribe function. */
+` + `  readonly $on: (event: "query", listener: (event: QueryEvent) => void) => () => void;
+` + `  /** ONE transaction. Callback form: everything on \`tx\` rides the same BEGIN/COMMIT; a throw rolls back. Array form (Prisma parity): UN-AWAITED delegate calls run sequentially in one transaction, results returned positionally. */
+` + `  readonly $transaction: {
+` + `    <T>(fn: (tx: ${selfType}) => Promise<T>, options?: TransactionOptions): Promise<T>;
+` + `    <T extends readonly unknown[]>(operations: readonly [...T], options?: TransactionOptions): Promise<{ -readonly [K in keyof T]: Awaited<T[K]> }>;
+` + `  };
+` + `  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>;
+`;
+}
+function telemetryDeclarations() {
+  return [
+    `/** One SQL execution inside an operation. Parameter values are redacted; \`sql\` and \`parameters\` appear only with the matching capture option. */`,
+    `export type VibeTelemetryStatementEvent = {`,
+    `  readonly operationId: string;`,
+    `  readonly index: number;`,
+    `  readonly kind: "rows" | "affected" | "raw" | "extension";`,
+    `  readonly model: string | null;`,
+    `  readonly method: string;`,
+    `  readonly dialect: string;`,
+    `  readonly provider: string;`,
+    `  /** Stable normalized grouping key \u2014 bounded and literal-free, safe as a metric label. */`,
+    `  readonly fingerprint: string;`,
+    `  readonly outcome: "success" | "failure";`,
+    `  /** Adapter-call elapsed time: networking and possibly pool wait included \u2014 not pure server execution time. */`,
+    `  readonly durationMs: number;`,
+    `  readonly parameterCount: number;`,
+    `  readonly inTransaction: boolean;`,
+    `  readonly rowCount?: number;`,
+    `  readonly errorCode?: string;`,
+    `  readonly slow?: boolean;`,
+    `  readonly sql?: string;`,
+    `  readonly parameters?: readonly unknown[];`,
+    `};`,
+    ``,
+    `/** One public ORM call, start to terminal outcome. Emitted exactly once. Unknown values are ABSENT, never zero. */`,
+    `export type VibeTelemetryOperationEvent = {`,
+    `  readonly operationId: string;`,
+    `  readonly parentOperationId?: string;`,
+    `  readonly context?: unknown;`,
+    `  readonly kind: "model" | "raw" | "transaction" | "extension";`,
+    `  readonly model: string | null;`,
+    `  readonly method: string;`,
+    `  readonly dialect: string;`,
+    `  readonly provider: string;`,
+    `  readonly outcome: "success" | "failure";`,
+    `  readonly stage: "refused" | "validation" | "statement" | "decode" | "transaction" | "completed" | "unknown";`,
+    `  readonly dispatched: boolean;`,
+    `  readonly startedAt?: number;`,
+    `  readonly durationMs?: number;`,
+    `  /** Creation to dispatch \u2014 labelled separately, never folded into durationMs. */`,
+    `  readonly queueWaitMs?: number;`,
+    `  readonly statementCount: number;`,
+    `  readonly statementDurationMs?: number;`,
+    `  readonly rowCount?: number;`,
+    `  readonly errorCode?: string;`,
+    `  readonly detail?: { readonly renderMs?: number; readonly adapterMs?: number; readonly processingMs?: number };`,
+    `  readonly statements: readonly VibeTelemetryStatementEvent[];`,
+    `  readonly droppedStatements?: number;`,
+    `  readonly slow?: boolean;`,
+    `  readonly sampled: true;`,
+    `};`,
+    ``,
+    `/** Where events go. A throw from any callback is contained: it can never change a database outcome. */`,
+    `export type VibeTelemetryExporter = {`,
+    `  readonly onOperation?: (event: VibeTelemetryOperationEvent) => void;`,
+    `  readonly onStatement?: (event: VibeTelemetryStatementEvent) => void;`,
+    `  readonly onDrop?: (event: { readonly reason: "buffer_full" | "statement_limit"; readonly count: number }) => void;`,
+    `  readonly flush?: () => void | Promise<void>;`,
+    `  /** NEVER called by the client \u2014 \`$disconnect()\` flushes only, because the provider is yours. */`,
+    `  readonly shutdown?: () => void | Promise<void>;`,
+    `};`,
+    ``,
+    `/** Complete counters (spans may be sampled, these are not) and explicit lifecycle. */`,
+    `export type VibeTelemetryHandle = {`,
+    `  readonly metrics: () => {`,
+    `    readonly countsRepresent: "all";`,
+    `    readonly sampleRate: number;`,
+    `    readonly sampledOperations: number;`,
+    `    readonly operations: { readonly total: number; readonly failed: number; readonly refused: number };`,
+    `    readonly statements: { readonly total: number; readonly failed: number };`,
+    `    readonly rows: { readonly known: number; readonly total: number };`,
+    `    readonly operationLatencyMs: { readonly bounds: readonly number[]; readonly counts: readonly number[]; readonly sum: number; readonly count: number };`,
+    `    readonly statementLatencyMs: { readonly bounds: readonly number[]; readonly counts: readonly number[]; readonly sum: number; readonly count: number };`,
+    `    readonly dropped: { readonly operations: number; readonly statements: number };`,
+    `  };`,
+    `  readonly flush: () => Promise<void>;`,
+    `  readonly shutdown: () => Promise<void>;`,
+    `};`,
+    ``,
+    `/** Opt-in operation telemetry. Defaults are conservative: no SQL text, no parameter values, no sampling. */`,
+    `export type VibeTelemetryOptions = {`,
+    `  readonly exporter: VibeTelemetryExporter;`,
+    `  /** Attach rendered SQL text (default false \u2014 raw text can embed secrets). */`,
+    `  readonly captureSql?: boolean;`,
+    `  /** Attach parameter VALUES (default false \u2014 only the count is reported). */`,
+    `  readonly captureParameterValues?: boolean;`,
+    `  /** Split render / adapter / processing time on the operation event (default false). */`,
+    `  readonly detailedTimings?: boolean;`,
+    `  /** Span sampling probability, 0..1 (default 1). Counters still count every execution. */`,
+    `  readonly sampleRate?: number;`,
+    `  readonly sampler?: (input: { readonly kind: "model" | "raw" | "transaction" | "extension"; readonly model: string | null; readonly method: string; readonly context?: unknown }) => boolean;`,
+    `  /** Read your current parent context SYNCHRONOUSLY at call time, so an application span survives the async boundary. */`,
+    `  readonly context?: () => unknown;`,
+    `  readonly delivery?: "immediate" | "buffered";`,
+    `  readonly maxBufferedOperations?: number;`,
+    `  readonly maxStatementsPerOperation?: number;`,
+    `  readonly slowStatementMs?: number;`,
+    `  readonly slowOperationMs?: number;`,
+    `  readonly onExporterError?: (params: { readonly error: unknown; readonly phase: "operation" | "statement" | "drop" | "flush" | "shutdown" | "sampler" | "context" }) => void;`,
+    `  /** Called once while the client is built, with the handle that owns metrics and lifecycle. */`,
+    `  readonly onReady?: (handle: VibeTelemetryHandle) => void;`,
+    `};`
+  ].join(`
+`);
+}
+function emitClient(params) {
+  const { view, baked, hasComputed } = params;
+  const nativeRls = hasNativeRls({ view });
+  const parts = [banner({ title: "Client" })];
+  parts.push(telemetryDeclarations());
+  parts.push(objectAlias({
+    name: "VibeClientOptions",
+    lines: [
+      `  readonly adapter: DatabaseAdapter;`,
+      `  readonly onQuery?: (event: QueryEvent) => void;`,
+      `  readonly relationStrategy?: RelationStrategy;`,
+      `  /** Append the primary key to ORDER BY when a find has no explicit orderBy (default false) \u2014 deterministic row order. */`,
+      `  readonly defaultOrderByPk?: boolean;`,
+      `  /** Append the primary key as a tie-breaker to \`distinct\` ordering (default true) \u2014 pins WHICH row represents each distinct key. */`,
+      `  readonly distinctOrderByPk?: boolean;`,
+      `  /** Opt-in write-boundary validators, per model \xD7 field: \`{ User: { email: zodSchema } }\`. Any Standard Schema validator (zod, valibot, arktype) works; they run on every write path before encoding. */`,
+      `  readonly validate?: WriteValidators;`,
+      `  /** Opt-in operation telemetry: one event per public ORM call, with the statements it ran. Parameter values are redacted by default and the exporter can never change a database outcome. */`,
+      `  readonly telemetry?: VibeTelemetryOptions;`,
+      ...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;`
+      ] : [],
+      ...nativeRls ? [
+        `  /** Native row-level security: the non-bypassing database role the runtime binds each transaction to (required on PGlite; server connections log in as it). */`,
+        `  readonly nativeRls?: { readonly runtimeRole?: string };`
+      ] : []
+    ]
+  }));
+  const clientExtensionLines = baked.clientDts.length === 0 ? "" : `${baked.clientDts.join(`
+`)}
+`;
+  if (nativeRls) {
+    parts.push(`export type BoundVibeClientInstance = {
+` + instanceSurfaceLines({ view, selfType: "BoundVibeClientInstance" }) + clientExtensionLines + `};`);
+    parts.push(`export type VibeClientInstance = {
+` + `  /** Bind the request's identity context \u2014 ALL of it, every declared slot \u2014 and get the client that can actually query. */
+` + `  readonly $withContext: (context: RlsContext) => BoundVibeClientInstance;
+` + `  /** Subscribe to client events ("query" fires after every statement, with the same payload as onQuery \u2014 both fire). Returns an unsubscribe function. */
+` + `  readonly $on: (event: "query", listener: (event: QueryEvent) => void) => () => void;
+` + `  readonly $connect: () => Promise<void>;
+` + `  readonly $disconnect: () => Promise<void>;
+` + `  // Deliberately ABSENT: model delegates, $models, $transaction, $queryRaw / $executeRaw / $queryRawUnsafe / $executeRawUnsafe, $defineView and every extension mount \u2014 an unbound client has no identity, so it cannot read or write a row. Bind one with $withContext.
+` + `};`);
+  } else {
+    parts.push(`export type VibeClientInstance = {
+` + instanceSurfaceLines({ view, selfType: "VibeClientInstance" }) + policyClientLines({ view }) + scopedClientLines({ view }) + 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 scopedColumnCandidates(params) {
+  return params.model.fields.filter((field) => !field.isList && (field.scalar === "String" || field.scalar === "Int" || field.scalar === "BigInt")).map((field) => field.name);
+}
+function emitScopedSection(params) {
+  const { view } = params;
+  if (hasNativeRls({ view }))
+    return [];
+  if (view.models.some((model) => model.policy !== undefined))
+    return [];
+  const entries = view.models.map((model) => {
+    const arms = [`"none"`];
+    const columns = scopedColumnCandidates({ model });
+    if (columns.length > 0) {
+      const union = columns.map((name) => `"${name}"`).join(" | ");
+      arms.push(`{ readonly column: ${union}; readonly nested?: ScopedNestedMode }`);
+    }
+    const throughs = model.relations.filter((relation) => !relation.isList).map((relation) => relation.name);
+    if (throughs.length > 0) {
+      const union = throughs.map((name) => `"${name}"`).join(" | ");
+      arms.push(`{ readonly through: ${union}; readonly nested?: ScopedNestedMode }`);
+    }
+    return `  readonly ${propKey({ name: model.name })}: ${arms.join(" | ")};`;
+  });
+  const scopedDelegateType = (model) => `${model.name}Delegate`;
+  const delegateProps = view.models.map((model) => `  readonly ${propKey({ name: model.clientName })}: ${scopedDelegateType(model)};`);
+  const modelsProps = view.models.flatMap((model) => {
+    const byClientName = `    readonly ${propKey({ name: model.clientName })}: ${scopedDelegateType(model)};`;
+    return model.name === model.clientName ? [byClientName] : [byClientName, `    readonly ${propKey({ name: model.name })}: ${scopedDelegateType(model)};`];
+  });
+  return [
+    banner({ title: "Tenant scoping ($scoped)" }),
+    `/** What a scoped handle does when this model appears INSIDE another model's nested write: "verify" (default) rewrites reference verbs into tenant-verified lookups; "refuse" rejects them. */
+export type ScopedNestedMode = "verify" | "refuse";`,
+    `/** Per-model tenancy classification \u2014 TOTAL: every model must be named ("none" = global, passes through untouched). */
+export type ScopedModelsConfig = {
+${entries.join(`
+`)}
+};`,
+    `export type ScopedClientInstance = {
+` + `${delegateProps.join(`
+`)}
+` + `  /** Delegates keyed by BOTH camelCase client name and model name \u2014 the same objects as the top-level properties (dynamic access). */
+` + `  readonly $models: {
+${modelsProps.join(`
+`)}
+  };
+` + `  /** Subscribe to client events \u2014 shared with the base client. */
+` + `  readonly $on: (event: "query", listener: (event: QueryEvent) => void) => () => void;
+` + `  /** ONE transaction; the callback receives a handle that INHERITS the scope. The array form takes un-awaited scoped delegate calls. */
+` + `  readonly $transaction: {
+` + `    <T>(fn: (tx: ScopedClientInstance) => Promise<T>, options?: TransactionOptions): Promise<T>;
+` + `    <T extends readonly unknown[]>(operations: readonly [...T], options?: TransactionOptions): Promise<{ -readonly [K in keyof T]: Awaited<T[K]> }>;
+` + `  };
+` + `  readonly $connect: () => Promise<void>;
+` + `  readonly $disconnect: () => Promise<void>;
+` + `  /** Field-masking views compose over the scoped handle (columns \xD7 rows). */
+` + `  readonly $defineView: <D extends ViewDefinitionInput>(options: { readonly name: string; readonly definition: D }) => ViewClient<D>;
+` + `  // Deliberately ABSENT: $queryRaw / $executeRaw / $queryRawUnsafe / $executeRawUnsafe (raw SQL cannot be tenant-verified \u2014 use the base client) and $scoped (scope once, from the base client).
+` + `};`
+  ];
+}
+function scopedClientLines(params) {
+  if (hasNativeRls(params))
+    return "";
+  if (params.view.models.some((model) => model.policy !== undefined))
+    return "";
+  return `  /** Tenant scoping: a total per-model tenancy map + a scope value \u2192 a NEW handle whose every call is confined to that tenant. scope: null builds the handle but refuses calls on scoped models. */
+` + `  readonly $scoped: (config: { readonly scope: string | number | bigint | null; readonly models: ScopedModelsConfig }) => ScopedClientInstance;
+`;
+}
+function policyClientLines(params) {
+  const policied = params.view.models.filter((model) => model.policy !== undefined);
+  if (policied.length === 0)
+    return "";
+  const CONTEXT_SCALAR_TYPES = { String: "string", Int: "number", BigInt: "bigint" };
+  const contextKeys = new Map;
+  for (const model of policied) {
+    const policy = model.policy;
+    const field = model.fields.find((entry) => entry.name === policy.field);
+    contextKeys.set(policy.context, field?.scalar == null ? "string" : CONTEXT_SCALAR_TYPES[field.scalar] ?? "string");
+  }
+  const contextType = `{ ${[...contextKeys.entries()].map(([key, type]) => `readonly ${propKey({ name: key })}: ${type};`).join(" ")} }`;
+  return `  /** Row scoping (@@policy): bind a per-request context; policied models fail closed without one. */
+` + `  readonly $withPolicy: (context: ${contextType}) => VibeClientInstance;
+` + `  /** Deliberate, greppable full-access escape from policy scoping. */
+` + `  readonly $bypassPolicy: () => VibeClientInstance;
+`;
+}
+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_HEADER);
+  const schemaTypeImports = [
+    "SchemaIR",
+    ...baked.empty ? [] : ["VibeExtension"],
+    ...hasComputed ? ["ComputedConfig"] : []
+  ].sort();
+  const importLines = [
+    `import type { DatabaseAdapter, DbNow, QueryEvent, Skip, TransactionOptions, WriteValidators } from "@vibeorm/runtime";`,
+    `import type { ${schemaTypeImports.join(", ")} } from "@vibeorm/schema";`,
+    ...jsonTypeImportLines({ view }),
+    ...baked.dtsImports,
+    `import { ${enumEntryExports({ view }).join(", ")} } from "./enums.js";`
+  ];
+  parts.push(`${importLines.join(`
+`)}
+
+` + `export { VibeError } from "@vibeorm/schema";
+export type { VibeErrorCode } from "@vibeorm/schema";
+` + `export { SKIP } from "@vibeorm/runtime";
+export type { Skip } from "@vibeorm/runtime";
+` + `export { ${enumEntryExports({ view }).join(", ")} };`);
+  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(...emitScopedSection({ view }));
+  parts.push(...emitRlsSection({ view }));
+  parts.push(emitClient({ view, baked, hasComputed }));
+  return `${parts.join(`
+
+`)}
+`;
+}
+
+// packages/generator/src/schema-view.ts
+import { VibeError as VibeError4, assertValidSchemaIR, enumStorageOf, isEnumType } from "@vibeorm/schema";
+import { postgresDialect, renderRlsPolicy } from "@vibeorm/sql";
+var JSON_TYPE_RE = /@type\(\s*([A-Za-z_$][A-Za-z0-9_$]*)\s+from\s+"([^"]+)"\s*\)/;
+function parseJsonTypeAnnotation(params) {
+  if (params.comment === undefined)
+    return null;
+  const match = JSON_TYPE_RE.exec(params.comment);
+  if (match === null)
+    return null;
+  return { name: match[1], from: match[2] };
+}
+function byName(left, right) {
+  return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+}
+function buildFieldView(params) {
+  const { field, model } = params;
+  const enumRef = isEnumType(field.type);
+  const annotation = parseJsonTypeAnnotation({ comment: field.documentation });
+  if (annotation !== null && (enumRef || field.type !== "Json")) {
+    throw new VibeError4({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `@type(...) annotation on ${model}.${field.name} \u2014 typed JSON is only valid on Json fields`,
+      meta: { model, field: field.name }
+    });
+  }
+  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,
+    ...annotation === null ? {} : { jsonType: annotation }
+  };
+}
+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, nullsNotDistinct, clientName) => {
+    const key = clientName ?? 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, nullsNotDistinct });
+  };
+  for (const field of fields) {
+    if (field.isId || field.isUnique)
+      add([field.name], false);
+  }
+  if (model.primaryKey !== undefined) {
+    if (model.primaryKey.fields.length === 1)
+      add(model.primaryKey.fields, false);
+    else
+      add(model.primaryKey.fields, false, model.primaryKey.clientName);
+  }
+  for (const index of model.indexes) {
+    if (index.kind === "unique" && index.where === undefined) {
+      add(index.fields.map((field) => field.name), index.nullsNotDistinct === true, index.clientName);
+    }
+  }
+  return members;
+}
+function buildModelView(params) {
+  const { model, modelIRByName } = params;
+  const fields = model.fields.filter((field) => field.isUnsupported !== true).map((field) => buildFieldView({ field, model: model.name }));
+  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,
+    ...model.policy === undefined ? {} : { policy: model.policy }
+  };
+}
+function assertRlsRenderable(params) {
+  for (const model of params.schema.models) {
+    if (model.rls === undefined || model.rls === "unprotected")
+      continue;
+    renderRlsPolicy({ dialect: postgresDialect, schema: params.schema, model: model.name });
+  }
+}
+function buildSchemaView(params) {
+  const { schema } = params;
+  assertValidSchemaIR({ schema });
+  if (schema.rls !== undefined)
+    assertRlsRenderable({ schema });
+  const normalized = {
+    datasource: schema.datasource,
+    models: [...schema.models].sort(byName),
+    enums: [...schema.enums].sort(byName),
+    extensions: [...schema.extensions].sort(byName),
+    ...schema.rls === undefined ? {} : { rls: schema.rls }
+  };
+  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,
+      storage: enumStorageOf({ enumDef: declared })
+    })),
+    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: "enums.js", content: emitEnumsJs({ view }) },
+    { name: "enums.d.ts", content: emitEnumsDts({ view }) },
+    { 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=AC114FAAB4DBE66364756E2164756E21