@vibeorm/generator 2.0.0-alpha.1 → 2.0.0-alpha.10

package/dist/index.js

@@ -2,10 +2,14 @@
 // 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,
@@ -127,72 +131,6 @@ function bakeExtensions(params) {
   };
 }
 
-// packages/generator/src/type-names.ts
-var PAYLOAD_TYPES = {
-  String: "string",
-  Boolean: "boolean",
-  Int: "number",
-  BigInt: "bigint",
-  Float: "number",
-  Decimal: "string",
-  DateTime: "Date",
-  Json: "JsonValue",
-  Bytes: "Uint8Array"
-};
-var INPUT_TYPES = {
-  String: "string",
-  Boolean: "boolean",
-  Int: "number",
-  BigInt: "bigint | number",
-  Float: "number",
-  Decimal: "string | number",
-  DateTime: "Date | string",
-  Json: "InputJsonValue",
-  Bytes: "Uint8Array"
-};
-var FILTER_PREFIX = {
-  String: "String",
-  Boolean: "Bool",
-  Int: "Int",
-  BigInt: "BigInt",
-  Float: "Float",
-  Decimal: "Decimal",
-  DateTime: "DateTime",
-  Json: "Json",
-  Bytes: "Bytes"
-};
-var NUMERIC_SCALARS = new Set(["Int", "BigInt", "Float", "Decimal"]);
-var MINMAX_SCALARS = new Set([
-  "String",
-  "Int",
-  "BigInt",
-  "Float",
-  "Decimal",
-  "DateTime"
-]);
-function payloadBaseType(params) {
-  const { field } = params;
-  return field.enumName ?? PAYLOAD_TYPES[field.scalar];
-}
-function inputBaseType(params) {
-  const { field } = params;
-  return field.enumName ?? INPUT_TYPES[field.scalar];
-}
-function filterName(params) {
-  const { field } = params;
-  const prefix = field.enumName ?? FILTER_PREFIX[field.scalar];
-  if (field.isList)
-    return `${prefix}ListFilter`;
-  return field.isOptional ? `${prefix}NullableFilter` : `${prefix}Filter`;
-}
-function updateOpsName(params) {
-  const { field } = params;
-  if (field.isList || field.scalar === null || !NUMERIC_SCALARS.has(field.scalar))
-    return null;
-  const prefix = FILTER_PREFIX[field.scalar];
-  return field.isOptional ? `Nullable${prefix}FieldUpdateOperationsInput` : `${prefix}FieldUpdateOperationsInput`;
-}
-
 // packages/generator/src/util.ts
 import { VibeError as VibeError2 } from "@vibeorm/schema";
 function pascal(params) {
@@ -258,6 +196,240 @@ ${indent2}}`;
   });
 }
 
+// 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`;
@@ -271,6 +443,23 @@ ${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 })}[]`;
@@ -316,18 +505,73 @@ export type SortOrderWithNulls = SortOrder | { readonly sort: SortOrder; readonl
 /** 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 };`;
+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 },
+  { 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 }
 ];
@@ -335,17 +579,18 @@ function scalarFilterAlias(params) {
   const { config, nullable } = params;
   const name = nullable ? `${config.prefix}NullableFilter` : `${config.prefix}Filter`;
   const value = config.value;
-  const valueOrNull = nullable ? `${value} | null` : value;
+  const 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?: ${value};`);
-    lines.push(`  readonly lte?: ${value};`);
-    lines.push(`  readonly gt?: ${value};`);
-    lines.push(`  readonly gte?: ${value};`);
+    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};`);
@@ -354,13 +599,13 @@ function scalarFilterAlias(params) {
     lines.push(`  readonly mode?: QueryMode;`);
   }
   lines.push(`  readonly not?: ${value} | ${name}${nullable ? " | null" : ""};`);
-  return objectAlias({ name, lines });
+  return inputAlias({ name, lines });
 }
 function scalarListFilterAlias(params) {
   const { config } = params;
   const value = config.value;
   const array = `readonly ${maybeParens({ type: value })}[]`;
-  return objectAlias({
+  return inputAlias({
     name: `${config.prefix}ListFilter`,
     lines: [
       `  readonly equals?: ${array} | null;`,
@@ -380,7 +625,7 @@ var UPDATE_OPS_CONFIGS = [
 function updateOpsAlias(params) {
   const { prefix, value, nullable } = params;
   const name = nullable ? `Nullable${prefix}FieldUpdateOperationsInput` : `${prefix}FieldUpdateOperationsInput`;
-  return objectAlias({
+  return inputAlias({
     name,
     lines: [
       `  readonly set?: ${nullable ? `${value} | null` : value};`,
@@ -391,6 +636,25 @@ function updateOpsAlias(params) {
     ]
   });
 }
+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) {
@@ -398,15 +662,9 @@ function filterSection() {
     parts.push(scalarFilterAlias({ config, nullable: true }));
     parts.push(scalarListFilterAlias({ config }));
   }
-  parts.push(objectAlias({
-    name: "JsonFilter",
-    lines: [`  readonly equals?: InputJsonValue;`, `  readonly not?: InputJsonValue;`]
-  }));
-  parts.push(objectAlias({
-    name: "JsonNullableFilter",
-    lines: [`  readonly equals?: InputJsonValue | null;`, `  readonly not?: InputJsonValue | null;`]
-  }));
-  parts.push(objectAlias({
+  parts.push(jsonFilterAlias({ nullable: false }));
+  parts.push(jsonFilterAlias({ nullable: true }));
+  parts.push(inputAlias({
     name: "JsonListFilter",
     lines: [
       `  readonly equals?: readonly InputJsonValue[] | null;`,
@@ -423,18 +681,55 @@ function filterSection() {
   }
   return parts;
 }
-function emitEnum(params) {
+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 parts = [banner({ title: `Enum ${name}` })];
   const valueLines = declared.values.map((value) => `  readonly ${propKey({ name: value })}: ${tsString({ value })};`);
-  parts.push(`export declare const ${name}: {
+  return [
+    banner({ title: `Enum ${name}` }),
+    `export declare const ${name}: {
 ${valueLines.join(`
 `)}
-};`);
-  parts.push(`export type ${name} = ${declared.values.map((value) => tsString({ value })).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(objectAlias({
+  parts.push(inputAlias({
     name: `${name}Filter`,
     lines: [
       `  readonly equals?: ${name};`,
@@ -443,7 +738,7 @@ ${valueLines.join(`
       `  readonly not?: ${name} | ${name}Filter;`
     ]
   }));
-  parts.push(objectAlias({
+  parts.push(inputAlias({
     name: `${name}NullableFilter`,
     lines: [
       `  readonly equals?: ${name} | null;`,
@@ -452,7 +747,7 @@ ${valueLines.join(`
       `  readonly not?: ${name} | ${name}NullableFilter | null;`
     ]
   }));
-  parts.push(objectAlias({
+  parts.push(inputAlias({
     name: `${name}ListFilter`,
     lines: [
       `  readonly equals?: ${array} | null;`,
@@ -569,7 +864,7 @@ function registerNestedContext(params) {
     register({
       registry,
       name: `${t}Create${suffix}Input`,
-      text: objectAlias({
+      text: inputAlias({
         name: `${t}Create${suffix}Input`,
         lines: checkedCreateLines({ model: target, omitRelation: inverse })
       })
@@ -577,7 +872,7 @@ function registerNestedContext(params) {
     register({
       registry,
       name: `${t}UncheckedCreate${suffix}Input`,
-      text: objectAlias({
+      text: inputAlias({
         name: `${t}UncheckedCreate${suffix}Input`,
         lines: uncheckedCreateLines({ model: target, omitRelation: inverse })
       })
@@ -585,7 +880,7 @@ function registerNestedContext(params) {
     register({
       registry,
       name: `${t}Update${suffix}Input`,
-      text: objectAlias({
+      text: inputAlias({
         name: `${t}Update${suffix}Input`,
         lines: checkedUpdateLines({ model: target, omitRelation: inverse })
       })
@@ -593,7 +888,7 @@ function registerNestedContext(params) {
     register({
       registry,
       name: `${t}UncheckedUpdate${suffix}Input`,
-      text: objectAlias({
+      text: inputAlias({
         name: `${t}UncheckedUpdate${suffix}Input`,
         lines: uncheckedUpdateLines({ model: target, omitRelation: inverse })
       })
@@ -603,7 +898,7 @@ function registerNestedContext(params) {
   register({
     registry,
     name: connectOrCreateName,
-    text: objectAlias({
+    text: inputAlias({
       name: connectOrCreateName,
       lines: [`  readonly where: ${t}WhereUniqueInput;`, `  readonly create: ${createUnion};`]
     })
@@ -613,7 +908,7 @@ function registerNestedContext(params) {
     register({
       registry,
       name: `${t}CreateNestedMany${suffix}Input`,
-      text: objectAlias({
+      text: inputAlias({
         name: `${t}CreateNestedMany${suffix}Input`,
         lines: [
           `  readonly create?: ${orMany({ type: createUnion })};`,
@@ -627,7 +922,7 @@ function registerNestedContext(params) {
     register({
       registry,
       name: updateWithWhere,
-      text: objectAlias({
+      text: inputAlias({
         name: updateWithWhere,
         lines: [`  readonly where: ${t}WhereUniqueInput;`, `  readonly data: ${updateUnion};`]
       })
@@ -636,7 +931,7 @@ function registerNestedContext(params) {
     register({
       registry,
       name: updateManyWithWhere,
-      text: objectAlias({
+      text: inputAlias({
         name: updateManyWithWhere,
         lines: [`  readonly where: ${t}WhereInput;`, `  readonly data: ${t}UpdateManyInput;`]
       })
@@ -645,7 +940,7 @@ function registerNestedContext(params) {
     register({
       registry,
       name: upsertWithWhere,
-      text: objectAlias({
+      text: inputAlias({
         name: upsertWithWhere,
         lines: [
           `  readonly where: ${t}WhereUniqueInput;`,
@@ -657,7 +952,7 @@ function registerNestedContext(params) {
     register({
       registry,
       name: `${t}UpdateNestedMany${suffix}Input`,
-      text: objectAlias({
+      text: inputAlias({
         name: `${t}UpdateNestedMany${suffix}Input`,
         lines: [
           `  readonly create?: ${orMany({ type: createUnion })};`,
@@ -679,7 +974,7 @@ function registerNestedContext(params) {
     register({
       registry,
       name: `${t}CreateNestedOne${suffix}Input`,
-      text: objectAlias({
+      text: inputAlias({
         name: `${t}CreateNestedOne${suffix}Input`,
         lines: [
           `  readonly create?: ${createUnion};`,
@@ -691,7 +986,7 @@ function registerNestedContext(params) {
     register({
       registry,
       name: `${t}UpdateNestedOne${suffix}Input`,
-      text: objectAlias({
+      text: inputAlias({
         name: `${t}UpdateNestedOne${suffix}Input`,
         lines: [
           `  readonly create?: ${createUnion};`,
@@ -705,9 +1000,9 @@ function registerNestedContext(params) {
     });
   }
 }
-var AGGREGATE_OPS_UNION = `"_count" | "_avg" | "_sum" | "_min" | "_max"`;
 function emitModel(params) {
   const { model, view, registry } = params;
+  const computedEntries = params.computed ?? [];
   const n = model.name;
   const hasRelations = model.relations.length > 0;
   const parts = [banner({ title: `Model ${n}` })];
@@ -715,10 +1010,17 @@ function emitModel(params) {
     registerNestedContext({ registry, view, relation });
   }
   parts.push(`export type ${n} = {
-${model.fields.map((field) => `  ${propKey({ name: field.name })}: ${payloadFieldType({ field })};`).join(`
+${[
+    ...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(`
@@ -730,31 +1032,35 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
   const countLine = `  readonly _count?: boolean | { readonly select: ${n}CountSelect };`;
   const relationSelectValue = (relation) => `boolean | ${relation.target}${relation.isList ? "FindManyArgs" : "Args"}`;
   if (hasCounts) {
-    parts.push(objectAlias({
+    parts.push(inputAlias({
       name: `${n}CountSelect`,
-      lines: listRelations.map((relation) => `  readonly ${propKey({ name: relation.name })}?: boolean;`)
+      lines: listRelations.map((relation) => `  readonly ${propKey({ name: relation.name })}?: boolean | { readonly where?: ${relation.target}WhereInput };`)
     }));
   }
-  parts.push(objectAlias({
+  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(objectAlias({
+  parts.push(inputAlias({
     name: `${n}Include`,
     lines: [
       ...model.relations.map((relation) => `  readonly ${propKey({ name: relation.name })}?: ${relationSelectValue(relation)};`),
       ...hasCounts ? [countLine] : []
     ]
   }));
-  parts.push(objectAlias({
+  parts.push(inputAlias({
     name: `${n}OmitInput`,
-    lines: model.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: boolean;`)
+    lines: [
+      ...model.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: boolean;`),
+      ...computedEntries.map((entry) => `  readonly ${propKey({ name: entry.field })}?: boolean;`)
+    ]
   }));
-  parts.push(objectAlias({
+  parts.push(inputAlias({
     name: `${n}Args`,
     lines: [
       `  readonly select?: ${n}Select;`,
@@ -763,7 +1069,7 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
       `  readonly relationStrategy?: RelationStrategy;`
     ]
   }));
-  parts.push(objectAlias({
+  parts.push(inputAlias({
     name: `${n}ListRelationFilter`,
     lines: [
       `  readonly some?: ${n}WhereInput;`,
@@ -771,7 +1077,7 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
       `  readonly none?: ${n}WhereInput;`
     ]
   }));
-  parts.push(objectAlias({
+  parts.push(inputAlias({
     name: `${n}RelationFilter`,
     lines: [`  readonly is?: ${n}WhereInput | null;`, `  readonly isNot?: ${n}WhereInput | null;`]
   }));
@@ -797,35 +1103,35 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
       whereLines.push(`  readonly ${key}?: ${relation.target}RelationFilter | ${relation.target}WhereInput${relation.isOptional ? " | null" : ""};`);
     }
   }
-  parts.push(objectAlias({ name: `${n}WhereInput`, lines: whereLines }));
+  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 })} }`;
+        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 })}`).join("; ");
+      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(objectAlias({
+  parts.push(inputAlias({
     name: `${n}OrderByInput`,
     lines: model.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: ${field.isOptional ? "SortOrderWithNulls" : "SortOrder"};`)
   }));
-  parts.push(objectAlias({ name: `${n}CreateInput`, lines: checkedCreateLines({ model }) }));
-  parts.push(objectAlias({ name: `${n}UncheckedCreateInput`, lines: uncheckedCreateLines({ model }) }));
+  parts.push(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(objectAlias({ name: `${n}UpdateInput`, lines: checkedUpdateLines({ model }) }));
-  parts.push(objectAlias({ name: `${n}UncheckedUpdateInput`, lines: uncheckedUpdateLines({ model }) }));
+  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(objectAlias({
+  parts.push(inputAlias({
     name: `${n}CountAggregateInput`,
     lines: [
       ...model.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: true;`),
@@ -834,7 +1140,7 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
   }));
   const aggregateOpProps = [`  readonly _count?: true | ${n}CountAggregateInput;`];
   if (numericFields.length > 0) {
-    parts.push(objectAlias({
+    parts.push(inputAlias({
       name: `${n}AvgAggregateInput`,
       lines: numericFields.map((field) => `  readonly ${propKey({ name: field.name })}?: true;`)
     }));
@@ -843,7 +1149,7 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
     aggregateOpProps.push(`  readonly _sum?: ${n}SumAggregateInput;`);
   }
   if (minmaxFields.length > 0) {
-    parts.push(objectAlias({
+    parts.push(inputAlias({
       name: `${n}MinAggregateInput`,
       lines: minmaxFields.map((field) => `  readonly ${propKey({ name: field.name })}?: true;`)
     }));
@@ -851,7 +1157,7 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
     aggregateOpProps.push(`  readonly _min?: ${n}MinAggregateInput;`);
     aggregateOpProps.push(`  readonly _max?: ${n}MaxAggregateInput;`);
   }
-  parts.push(objectAlias({
+  parts.push(inputAlias({
     name: `${n}FindManyArgs`,
     lines: [
       `  readonly where?: ${n}WhereInput;`,
@@ -860,24 +1166,28 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
       `  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 relationStrategy?: RelationStrategy;`,
+      `  readonly lock?: "update";`
     ]
   }));
   parts.push(`export type ${n}FindFirstArgs = ${n}FindManyArgs;`);
-  parts.push(objectAlias({
+  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 relationStrategy?: RelationStrategy;`,
+      `  readonly lock?: "update";`
     ]
   }));
-  parts.push(objectAlias({
+  parts.push(inputAlias({
     name: `${n}CreateArgs`,
     lines: [
       `  readonly data: ${n}CreateInput | ${n}UncheckedCreateInput;`,
@@ -886,48 +1196,97 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
       `  readonly omit?: ${n}OmitInput;`
     ]
   }));
-  parts.push(objectAlias({
+  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 skipDuplicates?: boolean | { readonly target?: ${n}ConflictTarget; readonly where?: string };`
     ]
   }));
-  parts.push(objectAlias({
+  parts.push(inputAlias({
     name: `${n}CreateManyAndReturnArgs`,
     lines: [
       `  readonly data: ${orMany({ type: `${n}CreateManyInput` })};`,
-      `  readonly skipDuplicates?: boolean;`,
+      `  readonly skipDuplicates?: boolean | { readonly target?: ${n}ConflictTarget; readonly where?: string };`,
       `  readonly select?: ${n}Select;`,
       `  readonly omit?: ${n}OmitInput;`
     ]
   }));
-  parts.push(objectAlias({
+  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}WhereUniqueInput;`,
+      `  readonly where: ${n}UpdateWhereInput;`,
       `  readonly data: ${n}UpdateInput | ${n}UncheckedUpdateInput;`,
       `  readonly select?: ${n}Select;`,
       `  readonly include?: ${n}Include;`,
-      `  readonly omit?: ${n}OmitInput;`
+      `  readonly omit?: ${n}OmitInput;`,
+      `  readonly skipUpdatedAt?: boolean;`
     ]
   }));
-  parts.push(objectAlias({
+  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;`]
+    lines: [
+      `  readonly where?: ${n}WhereInput;`,
+      `  readonly data: ${n}UpdateManyInput;`,
+      `  readonly skipUpdatedAt?: boolean;`
+    ]
   }));
-  parts.push(objectAlias({
+  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(objectAlias({
+  parts.push(inputAlias({
     name: `${n}DeleteArgs`,
     lines: [
       `  readonly where: ${n}WhereUniqueInput;`,
@@ -936,10 +1295,11 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
       `  readonly omit?: ${n}OmitInput;`
     ]
   }));
-  parts.push(objectAlias({ name: `${n}DeleteManyArgs`, lines: [`  readonly where?: ${n}WhereInput;`] }));
-  parts.push(objectAlias({
+  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;`,
@@ -947,7 +1307,7 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
       `  readonly skip?: number;`
     ]
   }));
-  parts.push(objectAlias({
+  parts.push(inputAlias({
     name: `${n}AggregateArgs`,
     lines: [
       `  readonly where?: ${n}WhereInput;`,
@@ -958,7 +1318,7 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
       ...aggregateOpProps
     ]
   }));
-  parts.push(objectAlias({
+  parts.push(inputAlias({
     name: `${n}GroupByArgs`,
     lines: [
       `  readonly by: readonly ${n}ScalarFieldEnum[];`,
@@ -970,20 +1330,26 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
       ...aggregateOpProps
     ]
   }));
-  const falseFilter = (source) => `${source}[K] extends false | undefined ? never : K`;
-  parts.push(`type ${n}OmitBase<A> = A extends { readonly omit: infer O extends object } ? Omit<${n}, OmittedKeys<O>> : ${n};`);
+  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 ${falseFilter("CS")}]: number }
+` + `  ? { [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> } : unknown;`);
+    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 { readonly select: unknown } | { readonly include: unknown } | { readonly omit: unknown }`;
+      const guard = `A extends object`;
       let expression;
       if (relation.isList) {
         expression = `${guard} ? ${nested}[] : ${relation.target}[]`;
@@ -999,47 +1365,68 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
 ${relationCases}
 }[K];`);
     parts.push(`type ${n}IncludePayload<A> = A extends { readonly include: infer I extends object }
-` + `  ? { [K in keyof I & keyof ${n}Relations as ${falseFilter("I")}]: ${n}RelationPayload<K, I[K]> }${hasCounts ? ` & ${n}CountPayload<I>` : ""}
-` + `  : unknown;`);
+` + `  ? { [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 & ${n}ScalarFieldEnum as ${falseFilter("S")}]: ${n}[K & keyof ${n}] } &
-` + `    { [K in keyof S & keyof ${n}Relations as ${falseFilter("S")}]: ${n}RelationPayload<K, S[K]> }${hasCounts ? ` &
+` + `  ? { [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 & ${n}ScalarFieldEnum as ${falseFilter("S")}]: ${n}[K & keyof ${n}] }
-` + `  : ${n}OmitBase<A>;`);
+` + `  ? { [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>;`);
   }
-  parts.push(`export type ${n}AggregateResult<A> = {
-` + `  [K in keyof A & (${AGGREGATE_OPS_UNION})]:
-` + `    K extends "_count" ? (A[K] extends true ? number : { [F in keyof A[K]]: number })
-` + `    : K extends "_avg" ? { [F in keyof A[K]]: number | null }
-` + `    : { [F in keyof A[K] & keyof ${n}]: ${n}[F & keyof ${n}] | null };
-` + `};`);
+  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> =
-` + `  { [K in A["by"][number]]: ${n}[K & keyof ${n}] } & ${n}AggregateResult<A>;`);
+` + `  (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 = ${n}FindManyArgs>(args?: A): Promise<${n}GetPayload<A>[]>;`,
-    `  findFirst<A extends ${n}FindFirstArgs = ${n}FindFirstArgs>(args?: A): Promise<${n}GetPayload<A> | null>;`,
-    `  findFirstOrThrow<A extends ${n}FindFirstArgs = ${n}FindFirstArgs>(args?: A): Promise<${n}GetPayload<A>>;`,
+    `  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(args?: ${n}CountArgs): Promise<number>;`,
+    `  count<A extends ${n}CountArgs = {}>(args?: A): Promise<${n}CountOutput<A>>;`,
     `  aggregate<A extends ${n}AggregateArgs>(args: A): Promise<${n}AggregateResult<A>>;`,
-    `  groupBy<A extends ${n}GroupByArgs>(args: A): Promise<${n}GroupByResult<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 ?? []);
@@ -1108,49 +1495,54 @@ function emitViewTypesForModel(params) {
       `  readonly relationStrategy?: RelationStrategy;`
     ]
   }));
-  const falseFilter = (source) => `${source}[K] extends false | undefined ? never : K`;
+  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 ${falseFilter("S")}]: ${n}[K & keyof ${n}] }
-` + `  : ${n}ViewScalars<F>;`);
+` + `  ? { [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 ${falseFilter("R")}]: ${n}[K & keyof ${n}] }
-` + `  : unknown;`);
+` + `  ? { [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}ViewScalars<RF>>`;
+      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}[] : ${target}[]`;
+        expression = `${guard} ? ${masked}[] : ${unmasked}[]`;
       } else if (relation.isOptional) {
-        expression = `(${guard} ? ${masked} : ${target}) | null`;
+        expression = `(${guard} ? ${masked} : ${unmasked}) | null`;
       } else {
-        expression = `${guard} ? ${masked} : ${target}`;
+        expression = `${guard} ? ${masked} : ${unmasked}`;
       }
       return `  ${propKey({ name: relation.name })}: ${expression};`;
     }).join(`
 `);
-    parts.push(`type ${n}ViewRelationResult<K extends keyof ${n}Relations, D> = {
+    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 ${falseFilter("I")}]: ${n}ViewRelationResult<K, D> }
-` + `  : unknown;`);
+` + `  ? { [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 = ${n}ViewFindManyArgs>(args?: A): Promise<${n}ViewResult<F, A, D>[]>;
-` + `  findFirst<A extends ${n}ViewFindManyArgs = ${n}ViewFindManyArgs>(args?: A): Promise<${n}ViewResult<F, A, D> | null>;
-` + `  findFirstOrThrow<A extends ${n}ViewFindManyArgs = ${n}ViewFindManyArgs>(args?: A): Promise<${n}ViewResult<F, A, D>>;
+` + `  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(args?: ${n}CountArgs): Promise<number>;
+` + `  count<A extends ${n}CountArgs = {}>(args?: A): Promise<${n}CountOutput<A>>;
 ` + `  aggregate<A extends ${n}AggregateArgs>(args: A): Promise<${n}AggregateResult<A>>;
-` + `  groupBy<A extends ${n}GroupByArgs>(args: A): Promise<${n}GroupByResult<A>[]>;
+` + `  groupBy<const A extends ${n}GroupByArgs>(args: A): Promise<${n}GroupByResult<A>[]>;
 ` + `};`);
   return parts.join(`
 
@@ -1184,38 +1576,236 @@ ${view.models.map((model) => `  ${propKey({ name: model.clientName })}: ${model.
   }
   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 } = 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 delegateProps = view.models.map((model) => `  readonly ${propKey({ name: model.clientName })}: ${model.name}Delegate;`);
   const clientExtensionLines = baked.clientDts.length === 0 ? "" : `${baked.clientDts.join(`
 `)}
 `;
-  parts.push(`export type VibeClientInstance = {
-` + `${delegateProps.join(`
-`)}
-` + `  readonly $transaction: <T>(fn: (tx: VibeClientInstance) => Promise<T>, options?: TransactionOptions) => Promise<T>;
-` + `  readonly $queryRaw: <T = Record<string, unknown>>(strings: TemplateStringsArray, ...values: unknown[]) => Promise<T[]>;
-` + `  readonly $executeRaw: (strings: TemplateStringsArray, ...values: unknown[]) => Promise<number>;
-` + `  readonly $queryRawUnsafe: <T = Record<string, unknown>>(text: string, ...values: unknown[]) => Promise<T[]>;
-` + `  readonly $executeRawUnsafe: (text: string, ...values: unknown[]) => Promise<number>;
+  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>;
-` + `  /** Field-masking views (v1 defineView parity): a read-only masked projection of models. */
-` + `  readonly $defineView: <D extends ViewDefinitionInput>(options: { readonly name: string; readonly definition: D }) => ViewClient<D>;
-` + clientExtensionLines + `};`);
+` + `  // 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). */
@@ -1224,22 +1814,127 @@ export declare const schema: SchemaIR;`);
 
 `);
 }
+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 by VibeORM (@vibeorm/generator) \u2014 DO NOT EDIT.
-// Regenerate with \`vibeorm generate\` after every schema change.`);
+  parts.push(GENERATED_HEADER);
+  const schemaTypeImports = [
+    "SchemaIR",
+    ...baked.empty ? [] : ["VibeExtension"],
+    ...hasComputed ? ["ComputedConfig"] : []
+  ].sort();
   const importLines = [
-    `import type { DatabaseAdapter, QueryEvent, TransactionOptions } from "@vibeorm/runtime";`,
-    `import type { SchemaIR${baked.empty ? "" : ", VibeExtension"} } from "@vibeorm/schema";`,
-    ...baked.dtsImports
+    `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 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)
@@ -1248,11 +1943,13 @@ export type { VibeErrorCode } from "@vibeorm/schema";`);
   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 }
+      ...extensionLines === undefined ? {} : { extensionLines },
+      ...modelComputed === undefined ? {} : { computed: modelComputed }
     }));
   }
   parts.push(...modelParts);
@@ -1267,62 +1964,9 @@ export type { VibeErrorCode } from "@vibeorm/schema";`);
     parts.push(...baked.moduleDts);
   }
   parts.push(...emitViewSection({ view }));
-  parts.push(emitClient({ view, baked }));
-  return `${parts.join(`
-
-`)}
-`;
-}
-
-// packages/generator/src/emit-js.ts
-function emitJs(params) {
-  const { view } = params;
-  const baked = params.baked ?? EMPTY_BAKED_EXTENSIONS;
-  const parts = [];
-  parts.push(`// Generated by VibeORM (@vibeorm/generator) \u2014 DO NOT EDIT.
-// Regenerate with \`vibeorm generate\` after every schema change.`);
-  parts.push(`import { createClient } from "@vibeorm/runtime";`);
-  if (baked.jsImports.length > 0)
-    parts.push(baked.jsImports.join(`
-`));
-  parts.push(`export { VibeError } from "@vibeorm/schema";`);
-  parts.push(`/** The normalized Schema IR this client was generated from (plain data). */
-export const schema = ${stableStringify({ value: view.schema })};`);
-  for (const declared of view.enums) {
-    const entries = declared.values.map((value) => `  ${tsString({ value })}: ${tsString({ value })},`).join(`
-`);
-    parts.push(`export const ${declared.name} = Object.freeze({
-${entries}
-});`);
-  }
-  if (baked.empty) {
-    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(`
-
-`)}
-`;
-  }
-  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(`
-`)}
-];`);
-  parts.push(`/** Build a typed client over a database adapter. */
-` + `export function VibeClient(options) {
-` + `  const { adapter, extensions, ...clientOptions } = options;
-` + `  return createClient({
-` + `    schema,
-` + `    adapter,
-` + `    options: clientOptions,
-` + `    extensions: { manifest: extensionManifest, mounts: extensionMounts, instances: extensions ?? [] },
-` + `  });
-` + `}`);
+  parts.push(...emitScopedSection({ view }));
+  parts.push(...emitRlsSection({ view }));
+  parts.push(emitClient({ view, baked, hasComputed }));
   return `${parts.join(`
 
 `)}
@@ -1330,13 +1974,31 @@ ${baked.mounts.map((mount) => `  ${mount},`).join(`
 }
 
 // packages/generator/src/schema-view.ts
-import { assertValidSchemaIR, isEnumType } from "@vibeorm/schema";
+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 } = 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,
@@ -1346,7 +2008,8 @@ function buildFieldView(params) {
     isId: field.isId,
     isUnique: field.isUnique,
     hasDefault: field.default !== undefined,
-    isUpdatedAt: field.isUpdatedAt
+    isUpdatedAt: field.isUpdatedAt,
+    ...annotation === null ? {} : { jsonType: annotation }
   };
 }
 function resolveInverse(params) {
@@ -1360,8 +2023,8 @@ function buildUniques(params) {
   const fieldByName = new Map(fields.map((field) => [field.name, field]));
   const members = [];
   const seen = new Set;
-  const add = (names) => {
-    const key = names.join("_");
+  const add = (names, nullsNotDistinct, clientName) => {
+    const key = clientName ?? names.join("_");
     if (seen.has(key))
       return;
     const resolved = [];
@@ -1372,24 +2035,28 @@ function buildUniques(params) {
       resolved.push(field);
     }
     seen.add(key);
-    members.push({ key, fields: resolved });
+    members.push({ key, fields: resolved, nullsNotDistinct });
   };
   for (const field of fields) {
     if (field.isId || field.isUnique)
-      add([field.name]);
+      add([field.name], false);
   }
-  if (model.primaryKey !== undefined && model.primaryKey.fields.length > 1) {
-    add(model.primaryKey.fields);
+  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")
-      add(index.fields.map((field) => field.name));
+    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 }));
+  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 ?? [])
@@ -1412,23 +2079,38 @@ function buildModelView(params) {
     relations,
     uniques: buildUniques({ model, fields }),
     fkFieldNames,
-    isView: model.isView
+    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)
+    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 })),
+    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]))
   };
@@ -1443,9 +2125,16 @@ 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 }) },
-    { name: "index.d.ts", content: emitDts({ view, baked }) },
+    { 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 });
@@ -1462,4 +2151,4 @@ export {
   bakeExtensions
 };
 
-//# debugId=8080967CFB1AC77464756E2164756E21
+//# debugId=AC114FAAB4DBE66364756E2164756E21