@vibeorm/dsl 4.2.0 → 5.0.0

package/dist/index.js

@@ -1,13 +1,13 @@
 // @bun
 // packages/dsl/src/column.ts
-import { VibeError, assertJsonSchemaRef, encodePrismaString } from "@vibeorm/schema";
+import { VibeError, assertJsonSchemaRef, assertValidatorRef, encodePrismaString, generatedColumnFromSql } from "@vibeorm/schema";
 function cloneColumnDef(params) {
   const { column } = params;
   return {
     __type: "column",
     __columnType: column.__columnType,
     __name: column.__name,
-    __config: { ...column.__config, ...column.__config.jsonSchema === undefined ? {} : { jsonSchema: assertJsonSchemaRef({ value: column.__config.jsonSchema }) } },
+    __config: { ...column.__config, ...column.__config.jsonSchema === undefined ? {} : { jsonSchema: assertJsonSchemaRef({ value: column.__config.jsonSchema }) }, ...column.__config.validator === undefined ? {} : { validator: assertValidatorRef({ value: column.__config.validator }) }, ..."generated" in column.__config ? { generated: Object.freeze({ sql: generatedColumnFromSql({ value: column.__config.generated }).expression }) } : {} },
     __enumValues: column.__enumValues,
     __enumName: column.__enumName,
     __enumStorage: column.__enumStorage
@@ -24,7 +24,7 @@ class ChainableColumn {
   __enumStorage;
   constructor(columnType, config = {}) {
     this.__columnType = columnType;
-    this.__config = { ...config };
+    this.__config = { ...config, ...config.validator === undefined ? {} : { validator: assertValidatorRef({ value: config.validator }) }, ..."generated" in config ? { generated: Object.freeze({ sql: generatedColumnFromSql({ value: config.generated }).expression }) } : {} };
   }
   optional() {
     this.__config.optional = true;
@@ -54,10 +54,62 @@ class ChainableColumn {
     this.__config.dbgenerated = expression;
     return this;
   }
+  generated(options) {
+    if ("generated" in this.__config)
+      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "A field may declare generation only once", meta: { issues: [{ rule: "generated-column-duplicate" }] } });
+    const generated = generatedColumnFromSql({ value: options });
+    this.__config.generated = Object.freeze({ sql: generated.expression });
+    return this;
+  }
+  validate(reference) {
+    if (this.__columnType === "json" || this.__columnType === "unsupported")
+      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Validators are only valid on queryable non-JSON scalar or enum columns; use .schema() for Json", meta: { issues: [{ rule: "validator-non-scalar" }] } });
+    if (this.__config.jsonSchema !== undefined)
+      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "A field cannot combine a scalar validator with a JSON schema", meta: { issues: [{ rule: "conflicting-validator-ref" }] } });
+    if (this.__config.validator !== undefined)
+      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "A field may declare only one validator reference", meta: { issues: [{ rule: "duplicate-validator-ref" }] } });
+    this.__config.validator = assertValidatorRef({ value: reference });
+    return this;
+  }
   comment(text) {
     this.__config.comment = text;
     return this;
   }
+  addCheckRule(params) {
+    const { options } = params;
+    const rule = Object.freeze({
+      rule: options?.rule ?? params.rule,
+      check: Object.freeze(params.check.kind === "oneOf" ? { ...params.check, values: Object.freeze([...params.check.values]) } : params.check),
+      ...options?.name === undefined ? {} : { name: options.name }
+    });
+    this.__config.checks = Object.freeze([...this.__config.checks ?? [], rule]);
+    return this;
+  }
+}
+function numericCarrier(value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+
+class ChainableNumericColumn extends ChainableColumn {
+  zero() {
+    return this.__columnType === "decimal" ? "0" : 0;
+  }
+  nonNegative(options) {
+    return this.addCheckRule({ rule: "nonNegative", check: { kind: "compare", op: "gte", value: this.zero() }, options });
+  }
+  positive(options) {
+    return this.addCheckRule({ rule: "positive", check: { kind: "compare", op: "gt", value: this.zero() }, options });
+  }
+  atLeast(value, options) {
+    return this.addCheckRule({ rule: "atLeast", check: { kind: "compare", op: "gte", value: numericCarrier(value) }, options });
+  }
+  atMost(value, options) {
+    return this.addCheckRule({ rule: "atMost", check: { kind: "compare", op: "lte", value: numericCarrier(value) }, options });
+  }
+  range(range) {
+    const { min, max, ...options } = range;
+    return this.addCheckRule({ rule: "range", check: { kind: "range", min: numericCarrier(min), max: numericCarrier(max) }, options });
+  }
 }
 
 class ChainableStringColumn extends ChainableColumn {
@@ -80,9 +132,15 @@ class ChainableStringColumn extends ChainableColumn {
     this.__config.collation = name;
     return this;
   }
+  oneOf(values, options) {
+    return this.addCheckRule({ rule: "allowed", check: { kind: "oneOf", values: [...values] }, options });
+  }
+  lengthAtMost(max, options) {
+    return this.addCheckRule({ rule: "length", check: { kind: "lengthAtMost", max }, options });
+  }
 }
 
-class ChainableDecimalColumn extends ChainableColumn {
+class ChainableDecimalColumn extends ChainableNumericColumn {
   constructor(config = {}) {
     super("decimal", config);
   }
@@ -145,22 +203,34 @@ class ChainableEnumColumn extends ChainableColumn {
     this.__config.default = value;
     return this;
   }
+  oneOf(values, options) {
+    return this.addCheckRule({ rule: "allowed", check: { kind: "oneOf", values: [...values] }, options });
+  }
 }
 function string(config = {}) {
   return new ChainableStringColumn(config);
 }
 
-class ChainableIntegerColumn extends ChainableColumn {
+class ChainableIntegerColumn extends ChainableNumericColumn {
   autoincrement() {
     this.__config.autoincrement = true;
     return this;
   }
 }
+function localDate({ ...config } = {}) {
+  return new ChainableColumn("localDate", config);
+}
 function int(config = {}) {
   return new ChainableIntegerColumn("int", config);
 }
+
+class ChainableFloatColumn extends ChainableNumericColumn {
+  constructor(config = {}) {
+    super("float", config);
+  }
+}
 function float(config = {}) {
-  return new ChainableColumn("float", config);
+  return new ChainableFloatColumn(config);
 }
 function decimal(config = {}) {
   return new ChainableDecimalColumn(config);
@@ -177,6 +247,8 @@ class ChainableJsonColumn extends ChainableColumn {
     super("json", { ...config, ...config.jsonSchema === undefined ? {} : { jsonSchema: assertJsonSchemaRef({ value: config.jsonSchema }) } });
   }
   schema(reference) {
+    if (this.__config.validator !== undefined)
+      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "A field cannot combine a scalar validator with a JSON schema", meta: { issues: [{ rule: "conflicting-validator-ref" }] } });
     if (this.__config.jsonSchema !== undefined)
       throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "A field may declare only one JSON schema reference", meta: { issues: [{ rule: "duplicate-json-schema-ref" }] } });
     this.__config.jsonSchema = assertJsonSchemaRef({ value: reference });
@@ -243,11 +315,66 @@ function createEnum(config) {
 }
 
 // packages/dsl/src/generator/prisma.ts
-import { VibeError as VibeError6, encodePrismaString as encodePrismaString2, internalError, normalizeJsonSchemaRef as normalizeJsonSchemaRef2, providerToDialect as providerToDialect2 } from "@vibeorm/schema";
+import { VibeError as VibeError7, assertGeneratedColumns, assertRowRuleReferentialActions, encodePrismaString as encodePrismaString2, generatedColumnFromSql as generatedColumnFromSql3, internalError, normalizeJsonSchemaRef as normalizeJsonSchemaRef2, normalizeValidatorRef as normalizeValidatorRef2, providerToDialect as providerToDialect2, rowRulePrismaAttribute, indexKeyPrisma, indexKeyTerms } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect2 } from "@vibeorm/sql";
 
+// packages/dsl/src/row-rules.ts
+import { VibeError as VibeError2, normalizeRowRules } from "@vibeorm/schema";
+function assertOptions(params) {
+  const { value } = params;
+  if (value === null || typeof value !== "object" || Array.isArray(value) || Reflect.ownKeys(value).some((key) => typeof key !== "string" || !params.allowed.includes(key))) {
+    throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: `Row-rule options accept only ${params.allowed.join(", ")}` });
+  }
+}
+function fieldArray(params) {
+  if (!Array.isArray(params.value) || params.value.some((entry) => typeof entry !== "string"))
+    throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: "Row-rule fields must be an array of logical names" });
+  return Object.freeze([...params.value]);
+}
+function createRowRuleBuilder() {
+  return Object.freeze({
+    appendOnly(options = {}) {
+      assertOptions({ value: options, allowed: ["name"] });
+      return Object.freeze({ kind: "appendOnly", ...options });
+    },
+    fixed(options) {
+      assertOptions({ value: options, allowed: ["columns", "when", "name"] });
+      assertOptions({ value: options.when, allowed: ["fromCreation", "onceSet"] });
+      return Object.freeze({ kind: "fixed", ...options, columns: fieldArray({ value: options.columns }), when: Object.freeze({ ...options.when }) });
+    },
+    rowFixed(options) {
+      assertOptions({ value: options, allowed: ["except", "name"] });
+      return Object.freeze({ kind: "rowFixed", ...options, except: fieldArray({ value: options.except }) });
+    },
+    frozen(options) {
+      assertOptions({ value: options, allowed: ["from", "mutable", "name"] });
+      return Object.freeze({ kind: "frozen", ...options, mutable: fieldArray({ value: options.mutable }) });
+    }
+  });
+}
+function compileRowRules(params) {
+  if (params.model.__rowRules === undefined)
+    return [];
+  if (typeof params.model.__rowRules !== "function")
+    throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: "rowRules must be a model-bound callback" });
+  const declarations = params.model.__rowRules(createRowRuleBuilder());
+  if (!Array.isArray(declarations))
+    throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: "rowRules must return an array of declarations" });
+  const rules = declarations.map((declaration) => {
+    if (declaration === null || typeof declaration !== "object" || Array.isArray(declaration))
+      throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: "Row-rule declarations must be data objects" });
+    const candidate = declaration;
+    if (candidate.kind !== "frozen")
+      return declaration;
+    if (typeof candidate.from !== "string" || candidate.from.length === 0)
+      throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: "Frozen from must be create or a logical field name" });
+    return { ...candidate, kind: "frozen", from: candidate.from === "create" ? { create: true } : { field: candidate.from }, mutable: candidate.mutable };
+  });
+  return normalizeRowRules({ model: params.irModel, rules, dialect: params.dialect, schema: params.schema });
+}
+
 // packages/dsl/src/predicate.ts
-import { VibeError as VibeError2 } from "@vibeorm/schema";
+import { IDENTIFIER_LIMITS, VibeError as VibeError3, checkRulePredicate, identifierLength, isEnumType } from "@vibeorm/schema";
 import { compileExclusion, renderPredicate } from "@vibeorm/sql";
 function isFieldExpr(operand) {
   return typeof operand === "object" && operand !== null && "kind" in operand && operand.kind === "field";
@@ -262,7 +389,7 @@ function toValue(params) {
   if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
     return { kind: "value", value: input };
   }
-  throw new VibeError2({
+  throw new VibeError3({
     code: "VIBE_SCHEMA_INVALID",
     message: `${at}: ${input === null ? "null" : typeof input} is not a comparable literal \u2014 use isNull()/isNotNull() for null, and a string, number, bigint or boolean otherwise`,
     meta: { rule: "predicate-literal-invalid", at }
@@ -280,17 +407,28 @@ function toExpression(params) {
     if (value.kind === "jsonText" && "field" in value && "path" in value && Array.isArray(value.path) && Array.from(value.path).every((segment) => typeof segment === "string" && !segment.includes("\x00"))) {
       return { kind: "jsonText", field: toRef({ expr: requireFieldExpr({ value: value.field, at }) }), path: [...value.path] };
     }
-    if (value.kind === "length" && "expression" in value) {
-      return { kind: "length", expression: toExpression({ value: value.expression, at }) };
+    if ((value.kind === "length" || value.kind === "lower" || value.kind === "upper") && "expression" in value) {
+      return { kind: value.kind, expression: toExpression({ value: value.expression, at }) };
+    }
+    if ((value.kind === "add" || value.kind === "sub" || value.kind === "mul") && "left" in value && "right" in value) {
+      const right = value.right;
+      return {
+        kind: value.kind,
+        left: toExpression({ value: value.left, at }),
+        right: typeof right === "object" && right !== null && "kind" in right && right.kind === "value" && "value" in right ? toValue({ input: right.value, at }) : toOperand({ operand: right, at })
+      };
     }
   }
-  throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: `${at}: expected a field, jsonText or length expression with a string-only JSON path`, meta: { rule: "predicate-operand-invalid", at } });
+  throw new VibeError3({ code: "VIBE_SCHEMA_INVALID", message: `${at}: expected a field, jsonText, length, add, sub, mul, lower or upper expression; JSON paths must contain only strings`, meta: { rule: "predicate-operand-invalid", at } });
+}
+function toPredicateExpression(params) {
+  return toExpression(params);
 }
 function requireFieldExpr(params) {
   const { value, at } = params;
   if (isFieldExpr(value))
     return value;
-  throw new VibeError2({
+  throw new VibeError3({
     code: "VIBE_SCHEMA_INVALID",
     message: `${at}: the left side of a comparison must be c.field("\u2026"), not a bare value`,
     meta: { rule: "predicate-operand-invalid", at }
@@ -299,7 +437,7 @@ function requireFieldExpr(params) {
 function requireOperands(params) {
   const { operands, at } = params;
   if (operands.length === 0) {
-    throw new VibeError2({
+    throw new VibeError3({
       code: "VIBE_SCHEMA_INVALID",
       message: `${at}: an empty boolean group has no honest SQL spelling \u2014 pass at least one operand`,
       meta: { rule: "predicate-empty", at }
@@ -318,7 +456,7 @@ function createPredicateBuilder() {
     const at = negate ? "c.notInList()" : "c.inList()";
     const ref = toRef({ expr: requireFieldExpr({ value: field, at }) });
     if (values.length === 0) {
-      throw new VibeError2({
+      throw new VibeError3({
         code: "VIBE_SCHEMA_INVALID",
         message: `${at}: an empty IN list is UNKNOWN on every row and is never what an author means`,
         meta: { rule: "predicate-empty", at, field: ref.name }
@@ -339,6 +477,11 @@ function createPredicateBuilder() {
     gte: compare("gte"),
     lt: compare("lt"),
     lte: compare("lte"),
+    add: ({ left, right }) => ({ ...toExpression({ value: { kind: "add", left, right }, at: "c.add()" }), __kind: "Int" }),
+    sub: ({ left, right }) => ({ ...toExpression({ value: { kind: "sub", left, right }, at: "c.sub()" }), __kind: "Int" }),
+    mul: ({ left, right }) => ({ ...toExpression({ value: { kind: "mul", left, right }, at: "c.mul()" }), __kind: "Int" }),
+    lower: (expression) => ({ kind: "lower", expression: toExpression({ value: expression, at: "c.lower()" }), __kind: "String" }),
+    upper: (expression) => ({ kind: "upper", expression: toExpression({ value: expression, at: "c.upper()" }), __kind: "String" }),
     jsonText: ({ field, path }) => ({ ...toExpression({ value: { kind: "jsonText", field: { kind: "field", name: field }, path }, at: "c.jsonText()" }), __kind: "String" }),
     length: (expression) => ({ kind: "length", expression: toExpression({ value: expression, at: "c.length()" }), __kind: "Int" }),
     isTrue: (operand) => ({ kind: "isTrue", operand }),
@@ -351,7 +494,7 @@ function createPredicateBuilder() {
     not: (operand) => ({ kind: "not", operand }),
     named: (name, predicate) => {
       if (name.trim() === "") {
-        throw new VibeError2({
+        throw new VibeError3({
           code: "VIBE_SCHEMA_INVALID",
           message: "c.named(): a CHECK needs a non-empty name \u2014 the name is what keys the migration diff",
           meta: { rule: "predicate-unnamed-check" }
@@ -361,6 +504,262 @@ function createPredicateBuilder() {
     }
   };
 }
+var MAX_LIST_PREVIEW = 6;
+function preview(params) {
+  const { values } = params;
+  return values.length <= MAX_LIST_PREVIEW ? values.join(", ") : `${values.slice(0, MAX_LIST_PREVIEW).join(", ")}, \u2026`;
+}
+function ruleError(params) {
+  return new VibeError3({
+    code: "VIBE_SCHEMA_INVALID",
+    message: `${params.site}: ${params.message}`,
+    meta: { rule: params.rule, site: params.site, ...params.meta ?? {} }
+  });
+}
+function physicalColumn(params) {
+  return params.field.dbName ?? params.field.name;
+}
+function mintedName(params) {
+  return `${params.context.table}_${physicalColumn({ field: params.field })}_${params.rule}_check`;
+}
+function assertRuleWord(params) {
+  const { site, options } = params;
+  if (options?.name !== undefined && (typeof options.name !== "string" || options.name.trim() === "")) {
+    throw ruleError({ site, rule: "predicate-unnamed-check", message: "{ name } must be a non-empty CHECK name" });
+  }
+  if (options?.rule !== undefined && (typeof options.rule !== "string" || options.rule.trim() === "")) {
+    throw ruleError({ site, rule: "check-rule-invalid", message: "{ rule } must be a non-empty rule word" });
+  }
+}
+function ruleField(params) {
+  const { context, name, site } = params;
+  const found = typeof name === "string" ? context.fields.find((field) => field.name === name) : undefined;
+  if (found === undefined) {
+    throw ruleError({ site, rule: "check-rule-unknown-field", message: `names ${JSON.stringify(name)}, which model "${context.model}" does not declare`, meta: { model: context.model, field: name } });
+  }
+  if (found.isList) {
+    throw ruleError({ site, rule: "check-rule-list-field", message: `"${found.name}" is a list column \u2014 a check rule compares scalar values`, meta: { model: context.model, field: found.name } });
+  }
+  return found;
+}
+function ruleCheck(params) {
+  return { __type: "check", name: params.name, predicate: params.predicate, __origin: params.origin, __minted: params.minted };
+}
+function createChecksBuilder(params) {
+  const { context } = params;
+  const group = (kind) => (...args) => {
+    const arrayForm = Array.isArray(args[0]);
+    const names = arrayForm ? [...args[0]] : args;
+    const options = arrayForm ? args[1] : undefined;
+    const site = `c.${kind}(${names.map((name) => JSON.stringify(name)).join(", ")}) on "${context.model}"`;
+    assertRuleWord({ site, options });
+    const fields = names.map((name) => ruleField({ context, name, site }));
+    if (fields.length < 2 || fields.length > 8) {
+      throw ruleError({ site, rule: "check-rule-group-arity", message: `takes 2 to 8 columns, not ${fields.length}` });
+    }
+    if (new Set(fields.map((field) => field.name)).size !== fields.length) {
+      throw ruleError({ site, rule: "check-rule-duplicate-field", message: "names a column twice \u2014 the expansion would contradict itself" });
+    }
+    const predicate = checkRulePredicate({ rule: { kind, fields: fields.map((field) => field.name) } });
+    const name = options?.name ?? mintedName({ context, field: fields[0], rule: options?.rule ?? kind });
+    return ruleCheck({ name, predicate, origin: site, minted: options?.name === undefined });
+  };
+  const order = (earlier, later, options) => {
+    const site = `c.order(${JSON.stringify(earlier)}, ${JSON.stringify(later)}) on "${context.model}"`;
+    assertRuleWord({ site, options });
+    const first = ruleField({ context, name: earlier, site });
+    const second = ruleField({ context, name: later, site });
+    if (first.name === second.name) {
+      throw ruleError({ site, rule: "check-rule-duplicate-field", message: "orders a column against itself" });
+    }
+    const nameColumn = options?.nameColumn ?? later;
+    if (nameColumn !== earlier && nameColumn !== later) {
+      throw ruleError({ site, rule: "check-rule-invalid", message: `nameColumn ${JSON.stringify(nameColumn)} must be one of the two ordered columns` });
+    }
+    const strict = options?.strict !== false;
+    const rule = nameColumn === later ? { kind: "order", left: second.name, op: strict ? "gt" : "gte", right: first.name } : { kind: "order", left: first.name, op: strict ? "lt" : "lte", right: second.name };
+    const name = options?.name ?? mintedName({ context, field: nameColumn === later ? second : first, rule: options?.rule ?? "order" });
+    return ruleCheck({ name, predicate: checkRulePredicate({ rule }), origin: site, minted: options?.name === undefined });
+  };
+  const presence = (config) => {
+    const site = `c.presence({ by: ${JSON.stringify(config?.by)} }) on "${context.model}"`;
+    if (config === null || typeof config !== "object")
+      throw ruleError({ site, rule: "presence-invalid", message: "takes { by, states }" });
+    assertRuleWord({ site, options: { ...config.rule === undefined ? {} : { rule: config.rule } } });
+    const by = ruleField({ context, name: config.by, site });
+    const byType = by.type;
+    if (!isEnumType(byType) || by.isOptional) {
+      throw ruleError({ site, rule: "presence-by-invalid", message: `"${by.name}" must be a REQUIRED enum column \u2014 a NULL state makes every IN unknown, and a CHECK passes on unknown`, meta: { model: context.model, field: by.name } });
+    }
+    const members = context.enums.find((entry) => entry.name === byType.enum)?.values;
+    if (members === undefined) {
+      throw ruleError({ site, rule: "presence-by-invalid", message: `enum "${byType.enum}" of "${by.name}" is not declared in the schema` });
+    }
+    const states = config.states;
+    if (states === null || typeof states !== "object")
+      throw ruleError({ site, rule: "presence-invalid", message: "states must map every enum member to { set, unset }" });
+    const missing = members.filter((member) => !Object.hasOwn(states, member));
+    const extra = Object.keys(states).filter((key) => !members.includes(key));
+    if (missing.length > 0 || extra.length > 0) {
+      throw ruleError({
+        site,
+        rule: "presence-states-mismatch",
+        message: `states must list every member of enum "${byType.enum}" exactly once${missing.length === 0 ? "" : `; missing: ${preview({ values: missing })}`}${extra.length === 0 ? "" : `; not members: ${preview({ values: extra })}`}`,
+        meta: { missing, extra }
+      });
+    }
+    const setIn = new Map;
+    const unsetIn = new Map;
+    for (const member of members) {
+      const state = states[member];
+      if (state === null || typeof state !== "object")
+        throw ruleError({ site, rule: "presence-invalid", message: `state "${member}" must be { set?, unset? }` });
+      const lists = { set: state.set ?? [], unset: state.unset ?? [] };
+      for (const [kind, list] of Object.entries(lists)) {
+        if (!Array.isArray(list))
+          throw ruleError({ site, rule: "presence-invalid", message: `state "${member}".${kind} must be a list of columns` });
+        if (new Set(list).size !== list.length)
+          throw ruleError({ site, rule: "check-rule-duplicate-field", message: `state "${member}".${kind} names a column twice` });
+        for (const name of list) {
+          const field = ruleField({ context, name, site });
+          if (field.name === by.name)
+            throw ruleError({ site, rule: "presence-invalid", message: `state "${member}" lists the state column "${by.name}" itself` });
+          if (!field.isOptional) {
+            throw ruleError({ site, rule: "presence-required-column", message: `"${field.name}" is required, so it is set in every state \u2014 a presence table lists optional columns only`, meta: { model: context.model, field: field.name } });
+          }
+          const target = kind === "set" ? setIn : unsetIn;
+          target.set(field.name, [...target.get(field.name) ?? [], member]);
+        }
+      }
+      const both = lists.set.filter((name) => lists.unset.includes(name));
+      if (both.length > 0)
+        throw ruleError({ site, rule: "presence-conflict", message: `state "${member}" lists ${preview({ values: both })} as both set and unset` });
+    }
+    const columns = context.fields.filter((field) => setIn.has(field.name) || unsetIn.has(field.name));
+    if (columns.length === 0)
+      throw ruleError({ site, rule: "presence-empty", message: "names no column \u2014 it would hold nothing" });
+    const names = config.names ?? {};
+    for (const [column, name] of Object.entries(names)) {
+      if (!columns.some((field) => field.name === column))
+        throw ruleError({ site, rule: "presence-invalid", message: `names.${column} is not a column this presence table constrains` });
+      assertRuleWord({ site, options: { ...name === undefined ? {} : { name } } });
+    }
+    return columns.map((field) => {
+      const set = setIn.get(field.name) ?? [];
+      const unset = unsetIn.get(field.name) ?? [];
+      if (set.length === members.length) {
+        throw ruleError({ site, rule: "presence-constant-column", message: `"${field.name}" is set in every state \u2014 declare it required instead`, meta: { model: context.model, field: field.name } });
+      }
+      if (unset.length === members.length) {
+        throw ruleError({ site, rule: "presence-constant-column", message: `"${field.name}" is empty in every state \u2014 it can never hold a value`, meta: { model: context.model, field: field.name } });
+      }
+      const explicit = names[field.name];
+      return ruleCheck({
+        name: explicit ?? mintedName({ context, field, rule: config.rule ?? physicalColumn({ field: by }) }),
+        predicate: checkRulePredicate({ rule: { kind: "presence", by: by.name, field: field.name, set, unset } }),
+        origin: `presence table on "${context.model}.${by.name}" for column "${field.name}"`,
+        minted: explicit === undefined
+      });
+    });
+  };
+  return {
+    ...createPredicateBuilder(),
+    order,
+    allOrNone: group("allOrNone"),
+    exactlyOne: group("exactlyOne"),
+    atMostOne: group("atMostOne"),
+    anySet: group("anySet"),
+    presence
+  };
+}
+var EXACT_NUMBER = /^(-?)(\d+)(?:\.(\d+))?$/;
+function compareBounds(params) {
+  const { left, right } = params;
+  if (typeof left === "number" && typeof right === "number")
+    return Number.isNaN(left - right) ? undefined : Math.sign(left - right);
+  const parse = (value) => {
+    const match = EXACT_NUMBER.exec(String(value));
+    if (match === null)
+      return;
+    const whole = match[2].replace(/^0+(?=\d)/, "");
+    const fraction = (match[3] ?? "").replace(/0+$/, "");
+    return { negative: match[1] === "-" && !(whole === "0" && fraction === ""), whole, fraction };
+  };
+  const a = parse(left);
+  const b = parse(right);
+  if (a === undefined || b === undefined)
+    return;
+  if (a.negative !== b.negative)
+    return a.negative ? -1 : 1;
+  let magnitude = a.whole.length - b.whole.length;
+  if (magnitude === 0 && a.whole !== b.whole)
+    magnitude = a.whole < b.whole ? -1 : 1;
+  if (magnitude === 0) {
+    const width = Math.max(a.fraction.length, b.fraction.length);
+    const x = a.fraction.padEnd(width, "0");
+    const y = b.fraction.padEnd(width, "0");
+    magnitude = x === y ? 0 : x < y ? -1 : 1;
+  }
+  return a.negative ? -Math.sign(magnitude) : Math.sign(magnitude);
+}
+function columnRuleChecks(params) {
+  const { model, context } = params;
+  const checks = [];
+  for (const [name, column] of model.__columns) {
+    const rules = column.__config.checks ?? [];
+    if (rules.length === 0)
+      continue;
+    for (const entry of rules) {
+      const site = `rule "${entry.rule}" on "${context.model}.${name}"`;
+      assertRuleWord({ site, options: { rule: entry.rule, ...entry.name === undefined ? {} : { name: entry.name } } });
+      const field = ruleField({ context, name, site });
+      const shape = entry.check;
+      let rule;
+      switch (shape.kind) {
+        case "compare":
+          rule = { kind: "compare", field: field.name, op: shape.op, value: shape.value };
+          break;
+        case "range":
+          if ((compareBounds({ left: shape.min, right: shape.max }) ?? 0) > 0) {
+            throw ruleError({ site, rule: "check-rule-range-bounds", message: `min ${String(shape.min)} is above max ${String(shape.max)} \u2014 no value could pass`, meta: { min: shape.min, max: shape.max } });
+          }
+          rule = { kind: "range", field: field.name, min: shape.min, max: shape.max };
+          break;
+        case "oneOf":
+          if (shape.values.length === 0)
+            throw ruleError({ site, rule: "check-rule-empty", message: "oneOf() has no values \u2014 an empty IN list is never what an author means" });
+          rule = { kind: "oneOf", field: field.name, values: shape.values };
+          break;
+        case "lengthAtMost":
+          if (!Number.isSafeInteger(shape.max) || shape.max < 0) {
+            throw ruleError({ site, rule: "check-rule-length-bound", message: `lengthAtMost(${String(shape.max)}) needs a non-negative whole number` });
+          }
+          rule = { kind: "lengthAtMost", field: field.name, max: shape.max };
+          break;
+      }
+      checks.push(ruleCheck({
+        name: entry.name ?? mintedName({ context, field, rule: entry.rule }),
+        predicate: checkRulePredicate({ rule }),
+        origin: site,
+        minted: entry.name === undefined
+      }));
+    }
+  }
+  return checks;
+}
+function isRuleCheck(entry) {
+  return entry !== null && typeof entry === "object" && "__type" in entry && entry.__type === "check";
+}
+function typedCheck(params) {
+  const { entry } = params;
+  return {
+    kind: "typed",
+    name: entry.name,
+    predicate: entry.predicate,
+    ...entry.__origin === undefined ? {} : { origin: entry.__origin },
+    ...entry.__minted === true ? { minted: true } : {}
+  };
+}
 function evaluateChecks(params) {
   const { checks, model } = params;
   if (checks === undefined)
@@ -368,28 +767,61 @@ function evaluateChecks(params) {
   if (typeof checks !== "function") {
     return checks.map((check) => ({ kind: "raw", name: check.name, expression: check.expression }));
   }
-  const declared = checks(createPredicateBuilder());
+  const builder = params.context === undefined ? contextlessChecksBuilder({ model }) : createChecksBuilder({ context: params.context });
+  const declared = checks(builder);
   return declared.map((entry, index) => {
-    if (entry !== null && typeof entry === "object" && !("__type" in entry) && typeof entry.name === "string" && "expression" in entry && typeof entry.expression === "string") {
+    if (entry !== null && typeof entry === "object" && !("__type" in entry) && "name" in entry && typeof entry.name === "string" && "expression" in entry && typeof entry.expression === "string") {
       return { kind: "raw", name: entry.name, expression: entry.expression };
     }
-    if (entry === null || typeof entry !== "object" || !("__type" in entry) || entry.__type !== "check") {
-      throw new VibeError2({
+    if (Array.isArray(entry)) {
+      throw new VibeError3({
         code: "VIBE_SCHEMA_INVALID",
-        message: `Model "${model}": checks[${index}] must be c.named("name", predicate) or a raw { name, expression } CHECK`,
+        message: `Model "${model}": checks[${index}] is a list \u2014 spread c.presence(...) into the checks: [...c.presence({ \u2026 })]`,
         meta: { rule: "predicate-unnamed-check", model, index }
       });
     }
-    return { kind: "typed", name: entry.name, predicate: entry.predicate };
+    if (!isRuleCheck(entry)) {
+      throw new VibeError3({
+        code: "VIBE_SCHEMA_INVALID",
+        message: `Model "${model}": checks[${index}] must be c.named("name", predicate), a check rule (c.order, c.allOrNone, \u2026) or a raw { name, expression } CHECK`,
+        meta: { rule: "predicate-unnamed-check", model, index }
+      });
+    }
+    return typedCheck({ entry });
   });
 }
+function contextlessChecksBuilder(params) {
+  const refuse = (name) => () => {
+    throw new VibeError3({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `Model "${params.model}": c.${name}() needs the model's fields \u2014 compile the schema with toIR (or compileModelChecks)`,
+      meta: { rule: "check-rule-context", model: params.model }
+    });
+  };
+  return {
+    ...createPredicateBuilder(),
+    order: refuse("order"),
+    allOrNone: refuse("allOrNone"),
+    exactlyOne: refuse("exactlyOne"),
+    atMostOne: refuse("atMostOne"),
+    anySet: refuse("anySet"),
+    presence: refuse("presence")
+  };
+}
 function compileExclusions(params) {
   const specs = typeof params.exclusions === "function" ? params.exclusions(createPredicateBuilder()) : params.exclusions ?? [];
   return specs.map((exclusion) => compileExclusion({ exclusion, model: params.model, dialect: params.dialect }));
 }
 function compileChecks(params) {
   const { checks, model, dialect, enums } = params;
-  return evaluateChecks({ checks, model: model.name }).map((check) => check.kind === "raw" ? { name: check.name, expression: check.expression } : {
+  const context = { model: model.name, table: params.table ?? model.name, fields: model.fields, enums };
+  const evaluated = evaluateChecks({ checks, model: model.name, context });
+  assertRuleNames({ checks: evaluated, model: model.name, dialect });
+  return renderChecks({ checks: evaluated, model, dialect, enums });
+}
+function renderChecks(params) {
+  const { model, dialect, enums } = params;
+  return params.checks.map((check) => check.kind === "raw" ? { name: check.name, expression: check.expression } : {
     name: check.name,
     expression: renderPredicate({
       predicate: check.predicate,
@@ -397,15 +829,50 @@ function compileChecks(params) {
       dialect,
       enums,
       usage: "check",
-      site: `CHECK "${check.name}"`
+      site: check.origin === undefined ? `CHECK "${check.name}"` : `CHECK "${check.name}" (${check.origin})`
     }),
     predicate: check.predicate
   });
 }
+function assertRuleNames(params) {
+  const { checks, model, dialect } = params;
+  const seen = new Map;
+  const limit = IDENTIFIER_LIMITS[dialect.name];
+  for (const check of checks) {
+    const origin = check.kind === "typed" ? check.origin : undefined;
+    const previous = seen.get(check.name);
+    const previousOrigin = previous?.kind === "typed" ? previous.origin : undefined;
+    if (previous !== undefined && (origin !== undefined || previousOrigin !== undefined)) {
+      throw new VibeError3({
+        code: "VIBE_SCHEMA_INVALID",
+        message: `Model "${model}": CHECK name "${check.name}" is produced twice (${previousOrigin ?? "a hand-written CHECK"}; ${origin ?? "a hand-written CHECK"}) \u2014 names key the migration diff. Pass { name: "\u2026" } to one of the rules`,
+        meta: { rule: "duplicate-check", model, name: check.name }
+      });
+    }
+    seen.set(check.name, check);
+    if (check.kind === "typed" && check.minted === true && limit !== undefined && identifierLength({ name: check.name, dialect: dialect.name }) > limit.max) {
+      throw new VibeError3({
+        code: "VIBE_SCHEMA_INVALID",
+        message: `Model "${model}": generated CHECK name "${check.name}" (${origin ?? "check rule"}) is longer than ${dialect.name}'s ${limit.max}-${limit.unit} identifier limit \u2014 pass a shorter { name: "\u2026" } to the rule`,
+        meta: { rule: "identifier-too-long", model, name: check.name }
+      });
+    }
+  }
+}
+function compileModelChecks(params) {
+  const { model, predicateModel, dialect, enums } = params;
+  const context = { model: model.__name, table: model.__map ?? model.__name, fields: predicateModel.fields, enums };
+  const checks = [
+    ...evaluateChecks({ checks: model.__checks, model: model.__name, context }),
+    ...columnRuleChecks({ model, context }).map((entry) => typedCheck({ entry }))
+  ];
+  assertRuleNames({ checks, model: model.__name, dialect });
+  return renderChecks({ checks, model: predicateModel, dialect, enums });
+}
 function compileIndexPredicate(params) {
   const { where, wherePredicate, columns, model, dialect, enums } = params;
   if (where !== undefined && wherePredicate !== undefined) {
-    throw new VibeError2({
+    throw new VibeError3({
       code: "VIBE_SCHEMA_INVALID",
       message: `Index on "${model.name}" [${columns.join(", ")}] carries both a raw where: string and a typed .where() \u2014 an index has ONE predicate`,
       meta: { rule: "predicate-duplicate-where", model: model.name, columns: [...columns] }
@@ -431,17 +898,22 @@ function compileIndexPredicate(params) {
 // packages/dsl/src/to-ir.ts
 import {
   EMPTY_EXTENSION_REGISTRY,
-  VibeError as VibeError5,
+  VibeError as VibeError6,
   assertValidSchemaIR,
+  assertIndexExpressions,
+  indexKeyFieldNames,
   exactIntegerLiteral,
+  generatedColumnFromSql as generatedColumnFromSql2,
+  isCanonicalLocalDate,
   providerToDialect,
   scalarListDefault,
   serializeJsonDefault,
   mergeExtensionDeclarations,
   normalizeJsonSchemaRef,
+  normalizeValidatorRef,
   unsupportedCapability
 } from "@vibeorm/schema";
-import { getSqlDialect } from "@vibeorm/sql";
+import { getSqlDialect, renderSchemaExpression } from "@vibeorm/sql";
 
 // packages/dsl/src/field-type.ts
 import { fieldTypeIdentity } from "@vibeorm/schema";
@@ -449,6 +921,7 @@ function columnFieldType(params) {
   const { column } = params;
   switch (column.__columnType) {
     case "string":
+    case "localDate":
       return "String";
     case "int":
       return "Int";
@@ -475,14 +948,17 @@ function columnFieldType(params) {
   }
 }
 function fieldTypeKey(params) {
-  return fieldTypeIdentity({ type: columnFieldType({ column: params.column }) });
+  return fieldTypeIdentity({
+    type: columnFieldType({ column: params.column }),
+    ...params.column.__columnType === "localDate" ? { nativeType: "Date" } : {}
+  });
 }
 
 // packages/dsl/src/relation-plan.ts
-import { VibeError as VibeError4, isSqlObjectIdentity, predicateKey } from "@vibeorm/schema";
+import { VibeError as VibeError5, indexKeyDefinitionKey, isSqlObjectIdentity, predicateKey } from "@vibeorm/schema";
 
 // packages/dsl/src/model.ts
-import { VibeError as VibeError3 } from "@vibeorm/schema";
+import { VibeError as VibeError4 } from "@vibeorm/schema";
 
 // packages/dsl/src/naming.ts
 function capitalize(params) {
@@ -524,7 +1000,7 @@ function createIndexBuilder() {
   const partial = (index) => {
     const where = (predicate) => {
       if (index.__where !== undefined) {
-        throw new VibeError3({
+        throw new VibeError4({
           code: "VIBE_SCHEMA_INVALID",
           message: `Index on [${index.__columns.join(", ")}] already carries a raw where: predicate \u2014 an index has ONE predicate, so use either the raw string or .where(), not both`,
           meta: { rule: "predicate-duplicate-where", columns: [...index.__columns] }
@@ -539,53 +1015,92 @@ function createIndexBuilder() {
       configurable: true
     });
   };
+  const freeze = (value) => {
+    if (value !== null && typeof value === "object") {
+      for (const child of Object.values(value))
+        freeze(child);
+      Object.freeze(value);
+    }
+    return value;
+  };
+  const keyTerms = (params) => {
+    if (params.keys.every((key) => typeof key === "string"))
+      return { __columns: [...params.keys] };
+    const terms = params.keys.map((entry) => {
+      const sorted = typeof entry === "object" && entry !== null && "__type" in entry && entry.__type === "sortedIndexKey";
+      const key = sorted ? entry.key : entry;
+      const direction = sorted ? { sort: entry.sort } : {};
+      if (typeof key === "string")
+        return { kind: "field", field: { name: key, ...direction } };
+      if (typeof key === "object" && key !== null && "__type" in key && key.__type === "rawIndexExpression") {
+        if (typeof key.text !== "string" || key.text.trim() === "" || key.text.includes("\x00"))
+          throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "i.sql requires nonempty NUL-free scalar SQL", meta: { rule: "expression-index-raw-sql" } });
+        return { kind: "raw", sql: key.text, ...direction };
+      }
+      return { kind: "expression", expression: toPredicateExpression({ value: key, at: "index key" }), ...direction };
+    });
+    const computed = terms.some((term) => term.kind !== "field");
+    return { __columns: computed ? [] : terms.flatMap((term) => term.kind === "field" ? [term.field.name] : []), __keys: freeze(terms) };
+  };
+  const scalar = createPredicateBuilder();
   const createIndex = (params) => ({
     __type: "index",
-    __columns: [...params.columns],
+    ...keyTerms({ keys: params.keys }),
     __indexType: params.type,
     ...params.map === undefined ? {} : { __map: params.map },
     ...params.where === undefined ? {} : { __where: params.where },
     ...params.ops === undefined ? {} : { __ops: params.ops }
   });
   return {
+    field: scalar.field,
+    add: scalar.add,
+    sub: scalar.sub,
+    mul: scalar.mul,
+    lower: (value) => scalar.lower(typeof value === "string" ? scalar.field(value) : value),
+    upper: (value) => scalar.upper(typeof value === "string" ? scalar.field(value) : value),
+    asc: (key) => ({ __type: "sortedIndexKey", key, sort: "asc" }),
+    desc: (key) => ({ __type: "sortedIndexKey", key, sort: "desc" }),
+    sql: ({ text }) => ({ __type: "rawIndexExpression", text }),
     on(...args) {
       const [first, second] = args;
       if (args.length === 2 && Array.isArray(first) && typeof second === "object" && !Array.isArray(second)) {
-        return partial(createIndex({ columns: first, type: second.type, where: second.where, map: second.map, ops: second.ops }));
+        const options = second;
+        return partial(createIndex({ keys: first, type: options.type, where: options.where, map: options.map, ops: options.ops }));
       }
-      return partial(createIndex({ columns: args }));
+      return partial(createIndex({ keys: args }));
     },
-    index(...columns) {
-      return partial(createIndex({ columns }));
+    index(...keys) {
+      return partial(createIndex({ keys }));
     },
     unique(...args) {
       const [first, second] = args;
       if (args.length === 2 && Array.isArray(first) && typeof second === "object" && !Array.isArray(second)) {
         if ("ops" in second && second.ops !== undefined) {
-          throw new VibeError3({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Custom unique operator classes can change client selector equality", meta: { feature: "uniqueIndexOperatorClasses" } });
+          throw new VibeError4({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Custom unique operator classes can change client selector equality", meta: { feature: "uniqueIndexOperatorClasses" } });
         }
+        const options = second;
         return partial({
           __type: "unique",
-          __columns: [...first],
-          ...second.map === undefined ? {} : { __map: second.map },
-          ...second.where === undefined ? {} : { __where: second.where },
-          ...second.nullsNotDistinct === true ? { __nullsNotDistinct: true } : {},
-          ...second.name === undefined ? {} : { __clientName: second.name }
+          ...keyTerms({ keys: first }),
+          ...options.map === undefined ? {} : { __map: options.map },
+          ...options.where === undefined ? {} : { __where: options.where },
+          ...options.nullsNotDistinct === true ? { __nullsNotDistinct: true } : {},
+          ...options.name === undefined ? {} : { __clientName: options.name }
         });
       }
-      return partial({ __type: "unique", __columns: [...args] });
+      return partial({ __type: "unique", ...keyTerms({ keys: args }) });
     },
     gin(...columns) {
-      return partial(createIndex({ columns, type: "Gin" }));
+      return partial(createIndex({ keys: columns, type: "Gin" }));
     },
     gist(...columns) {
-      return partial(createIndex({ columns, type: "Gist" }));
+      return partial(createIndex({ keys: columns, type: "Gist" }));
     },
     hash(...columns) {
-      return partial(createIndex({ columns, type: "Hash" }));
+      return partial(createIndex({ keys: columns, type: "Hash" }));
     },
     brin(...columns) {
-      return partial(createIndex({ columns, type: "Brin" }));
+      return partial(createIndex({ keys: columns, type: "Brin" }));
     }
   };
 }
@@ -629,6 +1144,7 @@ function create(config) {
     __primaryKey: config.primaryKey,
     __exclusions: config.exclusions,
     __checks: config.checks,
+    __rowRules: config.rowRules,
     __extensions: config.extensions,
     __policy: config.policy,
     __comment: config.comment
@@ -657,7 +1173,7 @@ function detectOneToOnePairs(params) {
   for (const [modelName, modelRelations] of Object.entries(relations)) {
     for (const [relName, rel] of Object.entries(modelRelations)) {
       if (rel.__ownsForeignKey !== undefined && (typeof rel.__ownsForeignKey !== "boolean" || rel.__relationType !== "one" || rel.__ownsForeignKey && rel.__fromModel !== modelName)) {
-        throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: `Invalid foreign-key ownership declaration on ${modelName}.${relName}` });
+        throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: `Invalid foreign-key ownership declaration on ${modelName}.${relName}` });
       }
       if (rel.__relationType === "one") {
         allOnes.push({ modelName, relName, rel });
@@ -732,7 +1248,7 @@ function sameColumnTuple(params) {
 function resolveFkOwner(params) {
   const { a, b, models } = params;
   const ownershipError = () => {
-    throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: `Ambiguous foreign-key ownership between ${a.modelName}.${a.relName} and ${b.modelName}.${b.relName}; set ownsForeignKey: true on the foreign-key side`, meta: { rule: "ambiguous-foreign-key-owner" } });
+    throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: `Ambiguous foreign-key ownership between ${a.modelName}.${a.relName} and ${b.modelName}.${b.relName}; set ownsForeignKey: true on the foreign-key side`, meta: { rule: "ambiguous-foreign-key-owner" } });
   };
   const aOwns = a.rel.__ownsForeignKey;
   const bOwns = b.rel.__ownsForeignKey;
@@ -901,28 +1417,31 @@ function planIndexes(params) {
     }
   }
   for (const index of evaluateIndexes({ model })) {
+    if (index.__keys?.some((term) => term.kind !== "field") && index.__ops !== undefined)
+      throw new VibeError5({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Custom operator classes are not admitted on expression-bearing keys", meta: { feature: "expressionIndexOperatorClasses", rule: "expression-index-operator-classes", model: model.__name } });
     if (index.__ops !== undefined) {
       if (index.__ops === null || typeof index.__ops !== "object" || Array.isArray(index.__ops))
-        throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "Index ops must be a field-keyed qualified-name map", meta: { rule: "index-operator-class-map", model: model.__name } });
+        throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: "Index ops must be a field-keyed qualified-name map", meta: { rule: "index-operator-class-map", model: model.__name } });
       if (index.__type === "unique")
-        throw new VibeError4({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Custom unique operator classes can change client selector equality", meta: { feature: "uniqueIndexOperatorClasses", model: model.__name } });
+        throw new VibeError5({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Custom unique operator classes can change client selector equality", meta: { feature: "uniqueIndexOperatorClasses", model: model.__name } });
       for (const [field, operatorClass] of Object.entries(index.__ops)) {
         if (!index.__columns.includes(field))
-          throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "Operator class names a field outside the index", meta: { rule: "index-operator-class-field", model: model.__name, field } });
+          throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: "Operator class names a field outside the index", meta: { rule: "index-operator-class-field", model: model.__name, field } });
         if (operatorClass !== undefined && !isSqlObjectIdentity({ kind: "table", name: operatorClass }))
-          throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "Index operator class must be a qualified SQL name { namespace, name }", meta: { rule: "index-operator-class-identity", model: model.__name, field } });
+          throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: "Index operator class must be a qualified SQL name { namespace, name }", meta: { rule: "index-operator-class-identity", model: model.__name, field } });
       }
     }
     const operatorClasses = index.__columns.map((field) => index.__ops?.[field]);
     const operatorSuffix = operatorClasses.some((operatorClass) => operatorClass !== undefined) ? `|ops:${JSON.stringify([index.__indexType ?? "BTree", operatorClasses.map((operatorClass) => operatorClass === undefined ? null : [operatorClass.namespace, operatorClass.name])])}` : "";
     const predicateSuffix = index.__where !== undefined ? `|where:${index.__where}` : index.__wherePredicate === undefined ? "" : `|where:${predicateKey({ predicate: index.__wherePredicate })}`;
-    const key = index.__columns.join(",") + predicateSuffix + operatorSuffix;
+    const key = index.__keys === undefined ? index.__columns.join(",") + predicateSuffix + operatorSuffix : index.__keys.some((term) => term.kind !== "field") ? indexKeyDefinitionKey({ index: { kind: index.__type === "unique" ? "unique" : (index.__indexType ?? "BTree").toLowerCase(), fields: [], expressions: index.__keys, ...index.__map === undefined ? {} : { name: index.__map }, ...index.__where === undefined ? {} : { where: index.__where }, ...index.__wherePredicate === undefined ? {} : { wherePredicate: index.__wherePredicate }, ...index.__nullsNotDistinct === undefined ? {} : { nullsNotDistinct: index.__nullsNotDistinct } } }) : `${index.__columns.join(",")}${predicateSuffix}${operatorSuffix}|sort:${JSON.stringify(index.__keys)}`;
     const existing = byKey.get(key);
     const isUnique = index.__type === "unique";
     if (existing === undefined || isUnique) {
       byKey.set(key, {
         isUnique,
         columns: [...index.__columns],
+        ...index.__keys === undefined ? {} : { keys: index.__keys },
         indexType: index.__indexType,
         ...index.__ops === undefined ? {} : { ops: index.__ops },
         ...index.__map === undefined ? {} : { map: index.__map },
@@ -949,7 +1468,7 @@ function referenceableKeys(params) {
   if (model.__primaryKey !== undefined && model.__primaryKey.length > 0)
     keys.push([...model.__primaryKey]);
   for (const index of evaluateIndexes({ model })) {
-    if (index.__type === "unique" && index.__where === undefined && index.__wherePredicate === undefined) {
+    if (index.__type === "unique" && !index.__keys?.some((term) => term.kind !== "field") && index.__where === undefined && index.__wherePredicate === undefined) {
       keys.push([...index.__columns]);
     }
   }
@@ -961,7 +1480,7 @@ function assertForeignKeyIntegrity(params) {
   const references = relation.references ?? [];
   const at = `${relation.model}.${relation.name}`;
   const refuse = (message, rule, meta = {}) => {
-    throw new VibeError4({
+    throw new VibeError5({
       code: "VIBE_SCHEMA_INVALID",
       message: `Relation ${at}: ${message}`,
       meta: { rule, model: relation.model, relation: relation.name, ...meta }
@@ -1011,12 +1530,14 @@ function assertForeignKeyIntegrity(params) {
   }
 }
 function relationLookups(params) {
+  const inputs = [];
   const incoming = new Map;
   for (const [modelName, relations] of Object.entries(params.schema.__relations)) {
     for (const [relName, rel] of Object.entries(relations)) {
       if (rel.__relationType !== "one")
         continue;
       const target = rel.__targetModel;
+      inputs.push(modelName, relName, rel, target);
       const entries = incoming.get(target);
       const entry = { modelName, relName, rel };
       if (entries === undefined)
@@ -1028,6 +1549,7 @@ function relationLookups(params) {
   const parents = new Map;
   for (const [name, model] of params.schema.__models) {
     for (const child of model.__children.values()) {
+      inputs.push(child.__name, name, model);
       const entries = parents.get(child.__name);
       if (entries === undefined)
         parents.set(child.__name, [[name, model]]);
@@ -1035,7 +1557,35 @@ function relationLookups(params) {
         entries.push([name, model]);
     }
   }
-  return { incoming, parents };
+  return { incoming, parents, inputs };
+}
+function lookupsCurrent(params) {
+  const { schema, inputs } = params;
+  let at = 0;
+  const byModel = schema.__relations;
+  for (const modelName in byModel) {
+    if (!Object.hasOwn(byModel, modelName))
+      continue;
+    const relations = byModel[modelName];
+    for (const relName in relations) {
+      if (!Object.hasOwn(relations, relName))
+        continue;
+      const rel = relations[relName];
+      if (rel.__relationType !== "one")
+        continue;
+      if (inputs[at] !== modelName || inputs[at + 1] !== relName || inputs[at + 2] !== rel || inputs[at + 3] !== rel.__targetModel)
+        return false;
+      at += 4;
+    }
+  }
+  for (const [name, model] of schema.__models) {
+    for (const child of model.__children.values()) {
+      if (inputs[at] !== child.__name || inputs[at + 1] !== name || inputs[at + 2] !== model)
+        return false;
+      at += 3;
+    }
+  }
+  return at === inputs.length;
 }
 function planSchema(params) {
   const { schema } = params;
@@ -1049,7 +1599,8 @@ function planSchema(params) {
   let refreshLookups = false;
   for (const [modelName, model] of schema.__models) {
     if (refreshLookups) {
-      lookups = relationLookups({ schema });
+      if (!lookupsCurrent({ schema, inputs: lookups.inputs }))
+        lookups = relationLookups({ schema });
       refreshLookups = false;
     }
     const explicit = planExplicitRelations({
@@ -1121,25 +1672,41 @@ function idDefault(params) {
 }
 function fieldDefault(params) {
   const { column } = params;
+  if (column.__columnType === "localDate") {
+    const { default: value, dbgenerated, autoincrement, updatedAt, array, collation } = column.__config;
+    if (array === true || updatedAt === true || autoincrement === true || dbgenerated !== undefined || collation !== undefined) {
+      throw new VibeError6({
+        code: "VIBE_SCHEMA_INVALID",
+        message: `Local-date column "${column.__name ?? "localDate"}" requires a scalar calendar day and an optional canonical YYYY-MM-DD literal default; lists, collation, updatedAt and generated defaults are not supported`,
+        meta: { issues: [{ rule: "local-date-declaration", field: column.__name }] }
+      });
+    }
+    if (value === undefined)
+      return;
+    const candidate = { value };
+    if (!isCanonicalLocalDate(candidate))
+      throw new VibeError6({ code: "VIBE_SCHEMA_INVALID", message: `Local-date default on "${column.__name ?? "localDate"}" must be a canonical YYYY-MM-DD calendar-day literal in years 0001\u20139999` });
+    return { kind: "literal", value: candidate.value };
+  }
   if (column.__columnType === "id") {
     const strategy = column.__config.type;
     const dbgenerated = column.__config.dbgenerated;
     if (column.__config.default !== undefined || column.__config.autoincrement !== undefined)
-      throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: "Use the id generator strategy instead of a conflicting id default" });
+      throw new VibeError6({ code: "VIBE_SCHEMA_INVALID", message: "Use the id generator strategy instead of a conflicting id default" });
     if (dbgenerated !== undefined) {
       if (strategy !== "none" || typeof dbgenerated !== "string")
-        throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: `An id with a database default needs dsl.id({ type: "none" }); the "${String(strategy)}" generator strategy would conflict with it`, meta: { issues: [{ rule: "id-dbgenerated-strategy", column: column.__name, strategy }] } });
+        throw new VibeError6({ code: "VIBE_SCHEMA_INVALID", message: `An id with a database default needs dsl.id({ type: "none" }); the "${String(strategy)}" generator strategy would conflict with it`, meta: { issues: [{ rule: "id-dbgenerated-strategy", column: column.__name, strategy }] } });
       return { kind: "dbgenerated", sql: dbgenerated };
     }
     return idDefault({ column });
   }
   const { dbgenerated, default: value, autoincrement } = column.__config;
   if ([dbgenerated !== undefined, value !== undefined, autoincrement === true].filter(Boolean).length > 1) {
-    throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: `Column "${column.__name ?? column.__columnType}" has conflicting defaults` });
+    throw new VibeError6({ code: "VIBE_SCHEMA_INVALID", message: `Column "${column.__name ?? column.__columnType}" has conflicting defaults` });
   }
   if (autoincrement === true) {
     if (column.__columnType !== "int" && column.__columnType !== "bigint" || column.__config.array === true || column.__config.optional === true) {
-      throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: "autoincrement requires a required scalar Int or BigInt column" });
+      throw new VibeError6({ code: "VIBE_SCHEMA_INVALID", message: "autoincrement requires a required scalar Int or BigInt column" });
     }
     return { kind: "autoincrement" };
   }
@@ -1149,7 +1716,7 @@ function fieldDefault(params) {
     return;
   if (column.__config.array === true) {
     if (!Array.isArray(value))
-      throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: "A scalar-list default must be an array" });
+      throw new VibeError6({ code: "VIBE_SCHEMA_INVALID", message: "A scalar-list default must be an array" });
     return { kind: "list", values: scalarListDefault({ type: fieldType({ column }), values: column.__columnType === "json" ? value.map((entry) => typeof entry === "string" ? entry : serializeJsonDefault({ value: entry })) : value }) };
   }
   if (column.__columnType === "json" && typeof value !== "string") {
@@ -1164,20 +1731,20 @@ function fieldDefault(params) {
     return { kind: "enumValue", value };
   }
   if (typeof value === "number" && (!Number.isFinite(value) || (column.__columnType === "int" || column.__columnType === "bigint") && !Number.isSafeInteger(value))) {
-    throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: "Numeric defaults must be finite; integer defaults must be exact" });
+    throw new VibeError6({ code: "VIBE_SCHEMA_INVALID", message: "Numeric defaults must be finite; integer defaults must be exact" });
   }
   if (typeof value === "string" || typeof value === "boolean" || typeof value === "number") {
     return { kind: "literal", value };
   }
   if (typeof value === "bigint")
     return { kind: "literal", value: exactIntegerLiteral({ text: value.toString() }) };
-  throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: `Unsupported default for ${column.__columnType}` });
+  throw new VibeError6({ code: "VIBE_SCHEMA_INVALID", message: `Unsupported default for ${column.__columnType}` });
 }
 function datetimeNativeType(params) {
   const { tz, precision } = params.config;
   if (precision !== undefined && (tz !== true || !Number.isInteger(precision) || precision < 0 || precision > 6)) {
     const at = params.column === undefined ? "A datetime column" : `Column "${params.column}"`;
-    throw new VibeError5({
+    throw new VibeError6({
       code: "VIBE_SCHEMA_INVALID",
       message: `${at}: a datetime precision must be an integer from 0 to 6 on a tz() column, as in dsl.datetime().tz({ precision: 3 })`,
       meta: { issues: [{ rule: "datetime-precision", column: params.column, precision, tz: tz === true }] }
@@ -1192,7 +1759,7 @@ function stringNativeType(params) {
   if (uuid === true) {
     if (maxLength !== undefined || text === true) {
       const at = params.column === undefined ? "A string column" : `Column "${params.column}"`;
-      throw new VibeError5({
+      throw new VibeError6({
         code: "VIBE_SCHEMA_INVALID",
         message: `${at}: uuid() is the column's type and cannot be combined with maxLength or text`,
         meta: { issues: [{ rule: "string-native-type", column: params.column }] }
@@ -1210,7 +1777,7 @@ function idNativeType(params) {
   if (params.config.uuid !== true)
     return;
   if (params.config.type === "autoincrement") {
-    throw new VibeError5({
+    throw new VibeError6({
       code: "VIBE_SCHEMA_INVALID",
       message: `${params.column === undefined ? "An id" : `Id "${params.column}"`}: uuid() needs a String id; an autoincrement id is an Int`,
       meta: { issues: [{ rule: "id-native-type", column: params.column }] }
@@ -1220,6 +1787,8 @@ function idNativeType(params) {
 }
 function nativeType(params) {
   const { column } = params;
+  if (column.__columnType === "localDate")
+    return "Date";
   if (column.__columnType === "string")
     return stringNativeType({ config: column.__config, column: column.__name });
   if (column.__columnType === "id")
@@ -1229,7 +1798,7 @@ function nativeType(params) {
     if (maxLength !== undefined || text !== undefined) {
       const invalid = column.__enumStorage !== "string" || maxLength !== undefined && (typeof maxLength !== "number" || !Number.isSafeInteger(maxLength) || maxLength <= 0) || text !== undefined && typeof text !== "boolean" || text === true && maxLength !== undefined;
       if (invalid) {
-        throw new VibeError5({
+        throw new VibeError6({
           code: "VIBE_SCHEMA_INVALID",
           message: "Enum text/maxLength options require string storage and either a positive integer maxLength or text: true, not both",
           meta: { issues: [{ rule: "enum-string-storage-options", enum: column.__enumName }] }
@@ -1266,7 +1835,8 @@ function buildField(params) {
   const dbName = typeof config.map === "string" ? config.map : undefined;
   const documentation = typeof config.comment === "string" ? config.comment : undefined;
   const collation = typeof config.collation === "string" ? config.collation : undefined;
-  const metadata = normalizeJsonSchemaRef({ documentation, reference: config.jsonSchema });
+  const validatorMetadata = normalizeValidatorRef({ documentation, reference: config.validator });
+  const metadata = normalizeJsonSchemaRef({ documentation: validatorMetadata.documentation, reference: config.jsonSchema });
   const defaultValue = fieldDefault({ column });
   const native = extensionNativeType ?? nativeType({ column });
   return {
@@ -1280,8 +1850,10 @@ function buildField(params) {
     ...collation === undefined ? {} : { collation },
     ...dbName === undefined ? {} : { dbName },
     ...defaultValue === undefined ? {} : { default: defaultValue },
+    ..."generated" in config ? { generated: generatedColumnFromSql2({ value: config.generated }) } : {},
     ...native === undefined ? {} : { nativeType: native },
     ...column.__columnType === "unsupported" ? { isUnsupported: true } : {},
+    ...validatorMetadata.validator === undefined ? {} : { validator: validatorMetadata.validator },
     ...metadata
   };
 }
@@ -1315,17 +1887,26 @@ function buildIndex(params) {
   if (index.ops !== undefined && Object.values(index.ops).some((operatorClass) => operatorClass !== undefined) && !dialect.capabilities.indexOperatorClasses)
     throw unsupportedCapability({ dialect: dialect.name, feature: "indexOperatorClasses" });
   const kind = index.isUnique ? "unique" : index.indexType === undefined ? "btree" : INDEX_KINDS[index.indexType];
+  const computed = index.keys?.some((term) => term.kind !== "field") === true;
+  const keys = computed ? { fields: [], expressions: index.keys } : { fields: index.keys === undefined ? index.columns.map((name) => ({ name, ...index.ops?.[name] === undefined ? {} : { operatorClass: index.ops[name] } })) : index.keys.flatMap((term) => term.kind === "field" ? [{ ...term.field, ...index.ops?.[term.field.name] === undefined ? {} : { operatorClass: index.ops[term.field.name] } }] : []) };
+  if (computed) {
+    const declaration = { kind, ...keys, ...index.map === undefined ? {} : { name: index.map }, ...index.clientName === undefined ? {} : { clientName: index.clientName }, ...index.nullsNotDistinct === undefined ? {} : { nullsNotDistinct: index.nullsNotDistinct } };
+    assertIndexExpressions({ schema: { datasource: { provider: dialect.name === "postgres" ? "postgresql" : dialect.name }, enums, extensions: [], models: [{ ...model, indexes: [declaration], relations: [], isView: false }] }, dialect: dialect.name });
+    for (const term of index.keys)
+      if (term.kind === "expression")
+        renderSchemaExpression({ expression: term.expression, model, dialect, enums, usage: "indexExpression", site: `expression index on ${model.name}` });
+  }
   const predicate = compileIndexPredicate({
     where: index.where,
     wherePredicate: index.wherePredicate,
-    columns: index.columns,
+    columns: computed ? indexKeyFieldNames({ index: keys }) ?? [] : index.columns,
     model,
     dialect,
     enums
   });
   return {
     kind,
-    fields: index.columns.map((name) => ({ name, ...index.ops?.[name] === undefined ? {} : { operatorClass: index.ops[name] } })),
+    ...keys,
     ...index.map === undefined ? {} : { name: index.map },
     ...predicate === undefined ? {} : { where: predicate.where },
     ...predicate?.wherePredicate === undefined ? {} : { wherePredicate: predicate.wherePredicate },
@@ -1412,8 +1993,8 @@ function buildModel(params) {
   }
   const predicateModel = { name: model.__name, fields };
   const exclusions = compileExclusions({ exclusions: model.__exclusions, model: predicateModel, dialect });
-  const checks = compileChecks({ checks: model.__checks, model: predicateModel, dialect, enums });
-  return {
+  const checks = compileModelChecks({ model, predicateModel, dialect, enums });
+  const irModel = {
     name: model.__name,
     ...model.__map === undefined ? {} : { dbName: model.__map },
     fields,
@@ -1426,6 +2007,8 @@ function buildModel(params) {
     isView: false,
     ...model.__comment === undefined ? {} : { documentation: model.__comment }
   };
+  const rowRules = compileRowRules({ model, irModel, dialect: dialect.name });
+  return rowRules.length === 0 ? irModel : { ...irModel, rowRules };
 }
 
 class ExtensionDeclarationCollector {
@@ -1470,7 +2053,7 @@ function toIR(params) {
     }
   }
   if (issues.length > 0) {
-    throw new VibeError5({
+    throw new VibeError6({
       code: "VIBE_SCHEMA_INVALID",
       message: `Schema validation failed with ${issues.length} issue(s): ${issues.map((issue) => issue.message).join("; ")}`,
       meta: { issues }
@@ -1494,11 +2077,36 @@ function predicateModel(params) {
     fields: Array.from(params.model.__columns, ([name, column]) => buildField({ name, column }))
   };
 }
+function plannedAdmissionModel(params) {
+  const { model, plan } = params;
+  return {
+    name: model.__name,
+    ...model.__map === undefined ? {} : { dbName: model.__map },
+    fields: [...model.__columns].map(([name, column]) => buildField({ name, column })),
+    relations: (plan.relations.get(model.__name) ?? []).map((relation) => ({
+      name: relation.name,
+      model: relation.model,
+      targetModel: relation.targetModel,
+      type: resolveRelationType({ relation, plan }),
+      isList: relation.isList,
+      isOptional: relation.isOptional,
+      ...relation.fields === undefined ? {} : { fields: relation.fields },
+      ...relation.references === undefined ? {} : { references: relation.references },
+      ...relation.onDelete === undefined ? {} : { onDelete: relation.onDelete },
+      ...relation.onUpdate === undefined ? {} : { onUpdate: relation.onUpdate }
+    })),
+    ...model.__primaryKey === undefined ? {} : { primaryKey: { fields: model.__primaryKey } },
+    ...model.__policy === undefined ? {} : { policy: { field: model.__policy.field, context: model.__policy.context ?? model.__policy.field } },
+    indexes: [],
+    isView: false
+  };
+}
 function prismaType(params) {
   const { column } = params;
   const list = column.__config.array === true ? "[]" : "";
   switch (column.__columnType) {
     case "string":
+    case "localDate":
       return `String${list}`;
     case "int":
       return `Int${list}`;
@@ -1551,6 +2159,8 @@ function defaultAttribute(params) {
 }
 function nativeTypeAttribute(params) {
   const { column } = params;
+  if (column.__columnType === "localDate")
+    return "@db.Date";
   if (column.__columnType === "string" || column.__columnType === "id") {
     const native = column.__columnType === "string" ? stringNativeType({ config: column.__config, column: column.__name }) : idNativeType({ config: column.__config, column: column.__name });
     return native === undefined ? undefined : `@db.${native}`;
@@ -1580,6 +2190,10 @@ function formatColumn(params) {
     if (columnDefault !== undefined)
       parts.push(columnDefault);
   }
+  if ("generated" in column.__config) {
+    const generated = generatedColumnFromSql3({ value: column.__config.generated });
+    parts.push(`@generated(sql: ${encodePrismaString2({ value: generated.expression })}, storage: "stored")`);
+  }
   if (column.__columnType === "datetime" && column.__config.updatedAt === true) {
     parts.push("@updatedAt");
   }
@@ -1596,13 +2210,17 @@ function formatColumn(params) {
     parts.push(`@collation(${encodePrismaString2({ value: column.__config.collation })})`);
   }
   const columnLine = parts.join(" ");
-  const metadata = normalizeJsonSchemaRef2({ documentation: typeof column.__config.comment === "string" ? column.__config.comment : undefined, reference: column.__config.jsonSchema });
+  const validatorMetadata = normalizeValidatorRef2({ documentation: typeof column.__config.comment === "string" ? column.__config.comment : undefined, reference: column.__config.validator });
+  const metadata = normalizeJsonSchemaRef2({ documentation: validatorMetadata.documentation, reference: column.__config.jsonSchema });
+  if (validatorMetadata.validator !== undefined && (column.__columnType === "json" || column.__columnType === "unsupported" || metadata.jsonSchema !== undefined))
+    throw new VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "Validators are only valid on queryable non-JSON scalar or enum columns; use .schema() for Json", meta: { issues: [{ rule: "validator-non-scalar", field: name }] } });
   if (metadata.jsonSchema !== undefined && column.__columnType !== "json")
-    throw new VibeError6({ code: "VIBE_SCHEMA_INVALID", message: "JSON schemas are only valid on Json fields", meta: { issues: [{ rule: "json-schema-non-json", field: name }] } });
+    throw new VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "JSON schemas are only valid on Json fields", meta: { issues: [{ rule: "json-schema-non-json", field: name }] } });
   const comments = [
     ...metadata.documentation === undefined ? [] : metadata.documentation.split(`
 `),
-    ...metadata.jsonSchema === undefined ? [] : [`@schema(${metadata.jsonSchema.name} from ${encodePrismaString2({ value: metadata.jsonSchema.from })})`]
+    ...metadata.jsonSchema === undefined ? [] : [`@schema(${metadata.jsonSchema.name} from ${encodePrismaString2({ value: metadata.jsonSchema.from })})`],
+    ...validatorMetadata.validator === undefined ? [] : [`@validate(${validatorMetadata.validator.name} from ${encodePrismaString2({ value: validatorMetadata.validator.from })})`]
   ];
   return [...comments.map((line) => `  /// ${line}`), columnLine].join(`
 `);
@@ -1642,8 +2260,8 @@ function formatRelation(params) {
 function formatIndex(params) {
   const { index } = params;
   if (index.ops !== undefined && Object.values(index.ops).some((operatorClass) => operatorClass !== undefined))
-    throw new VibeError6({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Prisma output cannot preserve qualified index operator classes; keep the DSL source", meta: { feature: "prismaIndexOperatorClasses", target: "prisma" } });
-  const columns = index.columns.join(", ");
+    throw new VibeError7({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Prisma output cannot preserve qualified index operator classes; keep the DSL source", meta: { feature: "prismaIndexOperatorClasses", target: "prisma" } });
+  const columns = index.keys === undefined ? index.columns.join(", ") : indexKeyTerms({ index: buildIndex({ index, model: predicateModel({ model: params.model }), dialect: params.dialect, enums: params.enums }) }).map((term) => indexKeyPrisma({ term })).join(", ");
   const predicate = compileIndexPredicate({
     where: index.where,
     wherePredicate: index.wherePredicate,
@@ -1693,14 +2311,24 @@ function formatModel(params) {
   for (const index of plan.indexes.get(model.__name) ?? []) {
     lines.push(formatIndex({ index, model: params.model, dialect: params.dialect, enums: params.enums }));
   }
-  for (const check of compileChecks({
-    checks: model.__checks,
-    model: predicateModel({ model: params.model }),
+  for (const check of compileModelChecks({
+    model: params.model,
+    predicateModel: predicateModel({ model: params.model }),
     dialect: params.dialect,
     enums: params.enums
   })) {
     lines.push(`  @@check(${encodePrismaString2({ value: check.expression })}, name: ${encodePrismaString2({ value: check.name })})`);
   }
+  const irModel = plannedAdmissionModel({ model, plan });
+  const rowRules = compileRowRules({ model, irModel, dialect: params.dialect.name });
+  assertRowRuleReferentialActions({ schema: {
+    datasource: { provider: params.dialect.name === "postgres" ? "postgresql" : params.dialect.name },
+    enums: params.enums,
+    extensions: [],
+    models: [{ ...irModel, rowRules }]
+  }, dialect: params.dialect.name });
+  for (const rule of rowRules)
+    lines.push(`  ${rowRulePrismaAttribute({ rule })}`);
   for (const use of model.__extensions ?? []) {
     const args = [];
     if (use.fields !== undefined)
@@ -1734,24 +2362,31 @@ function generatePrisma(schema, config = {}) {
   for (const model of schema.__models.values()) {
     const exclusions = compileExclusions({ exclusions: model.__exclusions, model: { name: model.__name, fields: Array.from(model.__columns, ([name, column]) => buildField({ name, column })) }, dialect: getSqlDialect2({ dialect: providerToDialect2({ provider: config.provider ?? "postgresql" }) }) });
     if (exclusions.length > 0)
-      throw new VibeError6({ code: "VIBE_CONFIG", message: "Prisma output cannot preserve exclusion constraints; keep the DSL source", meta: { feature: "exclusionConstraints", target: "prisma" } });
+      throw new VibeError7({ code: "VIBE_CONFIG", message: "Prisma output cannot preserve exclusion constraints; keep the DSL source", meta: { feature: "exclusionConstraints", target: "prisma" } });
   }
   const stringEnums = [...schema.__enumStorage].filter(([, storage]) => storage === "string").map(([name]) => name);
   if (stringEnums.length > 0) {
-    throw new VibeError6({
+    throw new VibeError7({
       code: "VIBE_CONFIG",
       message: `Cannot print to Prisma: enum(s) ${stringEnums.join(", ")} use storage: "string", which .prisma cannot express losslessly. Keep the DSL as the source or switch the enum to database storage.`,
       meta: { enums: stringEnums, target: "prisma" }
     });
   }
   if (schema.__rls !== undefined) {
-    throw new VibeError6({
+    throw new VibeError7({
       code: "VIBE_CONFIG",
       message: "Cannot print to Prisma: this schema uses native RLS, which .prisma cannot express losslessly. Keep the DSL as the source.",
       meta: { feature: "nativeRowLevelSecurity", target: "prisma" }
     });
   }
   const plan = planSchema({ schema });
+  if ([...schema.__models.values()].some((model) => [...model.__columns.values()].some((column) => ("generated" in column.__config))))
+    assertGeneratedColumns({ schema: {
+      datasource: { provider: config.provider ?? "postgresql" },
+      enums: [],
+      extensions: [],
+      models: [...schema.__models.values()].map((model) => plannedAdmissionModel({ model, plan }))
+    } });
   const sections = [];
   const dialect = getSqlDialect2({ dialect: providerToDialect2({ provider: config.provider ?? "postgresql" }) });
   const enums = Array.from(schema.__enums, ([name, values]) => ({ name, values: [...values] }));
@@ -1778,9 +2413,10 @@ function generatePrisma(schema, config = {}) {
 }
 
 // packages/dsl/src/relations.ts
-import { VibeError as VibeError7 } from "@vibeorm/schema";
+import { VibeError as VibeError8 } from "@vibeorm/schema";
 var REF_KIND_BY_COLUMN_TYPE = {
   string: "String",
+  localDate: "String",
   int: "Int",
   bigint: "BigInt",
   float: "Float",
@@ -1819,7 +2455,7 @@ function extractRefInfo(params) {
   }
   const members = ref;
   if (members.length === 0) {
-    throw new VibeError7({
+    throw new VibeError8({
       code: "VIBE_SCHEMA_INVALID",
       message: `Relation to ${target}: "${side}" is an empty tuple \u2014 name at least one column`,
       meta: { rule: "relation-empty-tuple", side, targetModel: target }
@@ -1827,14 +2463,14 @@ function extractRefInfo(params) {
   }
   const models = [...new Set(members.map((member) => member.__model))].sort();
   if (models.length > 1) {
-    throw new VibeError7({
+    throw new VibeError8({
       code: "VIBE_SCHEMA_INVALID",
       message: `Relation to ${target}: "${side}" mixes models ${models.join(", ")} \u2014 every member of a composite key must sit on one model`,
       meta: { rule: "relation-mixed-models", side, targetModel: target, models }
     });
   }
   if (members.some((member) => member.__type !== "columnRef")) {
-    throw new VibeError7({
+    throw new VibeError8({
       code: "VIBE_SCHEMA_INVALID",
       message: `Relation to ${target}: "${side}" routes through a junction inside a tuple \u2014 implicit many-to-many is single-key; model the join with an explicit junction model`,
       meta: { rule: "relation-through-in-tuple", side, targetModel: target }
@@ -1848,7 +2484,7 @@ function createRelationFactory(params) {
     const from = extractRefInfo({ ref: config.from, side: "from", target: targetModelName });
     const to = extractRefInfo({ ref: config.to, side: "to", target: targetModelName });
     if (from.columns.length !== to.columns.length) {
-      throw new VibeError7({
+      throw new VibeError8({
         code: "VIBE_SCHEMA_INVALID",
         message: `Relation to ${targetModelName}: "from" names ${from.columns.length} column(s) but "to" names ${to.columns.length} \u2014 a composite key pairs member by member`,
         meta: { rule: "relation-tuple-arity", targetModel: targetModelName, from: from.columns, to: to.columns }
@@ -1946,7 +2582,7 @@ function mergeRelations(...parts) {
 }
 
 // packages/dsl/src/schema.ts
-import { VibeError as VibeError8, validateRlsContextIR } from "@vibeorm/schema";
+import { VibeError as VibeError9, validateRlsContextIR } from "@vibeorm/schema";
 function sameValues(left, right) {
   return left.length === right.length && left.every((value, index) => value === right[index]);
 }
@@ -1965,7 +2601,7 @@ function registerEnum(params) {
     ...valuesDiffer ? [`values [${existing.values.join(", ")}] vs [${entry.values.join(", ")}]`] : [],
     ...storageDiffers ? [`storage "${existing.storage}" vs "${entry.storage}"`] : []
   ].join("; ");
-  throw new VibeError8({
+  throw new VibeError9({
     code: "VIBE_SCHEMA_INVALID",
     message: `Enum "${name}" is defined more than once with conflicting definitions (${origin}): ${detail} \u2014 share one enum object across modules, or give the definitions different names`,
     meta: {
@@ -1991,7 +2627,7 @@ function addModelTree(params) {
   const { model, models, origin } = params;
   const existing = models.get(model.__name);
   if (existing !== undefined && existing !== model) {
-    throw new VibeError8({
+    throw new VibeError9({
       code: "VIBE_SCHEMA_INVALID",
       message: `Model "${model.__name}" is defined more than once with different definitions (${origin}) \u2014 ` + `share one model object across modules, or give the definitions different names`,
       meta: {
@@ -2069,7 +2705,7 @@ var RLS_CONTEXT_TYPES = {
 };
 function defineRls(params) {
   if (typeof params.context !== "object" || params.context === null || Array.isArray(params.context)) {
-    throw new VibeError8({ code: "VIBE_SCHEMA_INVALID", message: "RLS context must be a record of scalar declarations", meta: { issues: [{ rule: "rls-invalid-context" }] } });
+    throw new VibeError9({ code: "VIBE_SCHEMA_INVALID", message: "RLS context must be a record of scalar declarations", meta: { issues: [{ rule: "rls-invalid-context" }] } });
   }
   const entries = [];
   const refs = [];
@@ -2077,7 +2713,7 @@ function defineRls(params) {
     const descriptor = Object.getOwnPropertyDescriptor(params.context, key);
     const column = descriptor?.value;
     if (typeof key !== "string" || descriptor?.enumerable !== true || typeof column !== "object" || column === null || !("__columnType" in column) || !("__config" in column) || typeof column.__config !== "object" || column.__config === null || typeof column.__columnType !== "string" || !Object.hasOwn(RLS_CONTEXT_TYPES, column.__columnType) || "array" in column.__config && column.__config.array === true) {
-      throw new VibeError8({ code: "VIBE_SCHEMA_INVALID", message: "RLS context slots must be named scalar column declarations", meta: { issues: [{ rule: "rls-invalid-context" }] } });
+      throw new VibeError9({ code: "VIBE_SCHEMA_INVALID", message: "RLS context slots must be named scalar column declarations", meta: { issues: [{ rule: "rls-invalid-context" }] } });
     }
     entries.push([key, { type: RLS_CONTEXT_TYPES[column.__columnType], nullable: "optional" in column.__config && column.__config.optional === true }]);
     refs.push([key, Object.freeze({ context: key })]);
@@ -2085,22 +2721,22 @@ function defineRls(params) {
   const context = Object.freeze(Object.fromEntries(entries));
   const issues = validateRlsContextIR({ context });
   if (issues.length > 0) {
-    throw new VibeError8({ code: "VIBE_SCHEMA_INVALID", message: "Invalid RLS context declaration", meta: { issues } });
+    throw new VibeError9({ code: "VIBE_SCHEMA_INVALID", message: "Invalid RLS context declaration", meta: { issues } });
   }
   const policies = params.policies({ context: Object.freeze(Object.fromEntries(refs)) });
   if (typeof policies !== "object" || policies === null || Array.isArray(policies)) {
-    throw new VibeError8({ code: "VIBE_SCHEMA_INVALID", message: "RLS policies must be a record of model classifications", meta: { issues: [{ rule: "rls-invalid-rule" }] } });
+    throw new VibeError9({ code: "VIBE_SCHEMA_INVALID", message: "RLS policies must be a record of model classifications", meta: { issues: [{ rule: "rls-invalid-rule" }] } });
   }
   const named = [];
   const classified = new Set;
   for (const key of Reflect.ownKeys(policies)) {
     const descriptor = Object.getOwnPropertyDescriptor(policies, key);
     if (typeof key !== "string" || descriptor?.enumerable !== true || !("value" in descriptor)) {
-      throw new VibeError8({ code: "VIBE_SCHEMA_INVALID", message: "RLS policies must be named data properties", meta: { issues: [{ rule: "rls-invalid-rule" }] } });
+      throw new VibeError9({ code: "VIBE_SCHEMA_INVALID", message: "RLS policies must be named data properties", meta: { issues: [{ rule: "rls-invalid-rule" }] } });
     }
     const name = params.models[key]?.__name ?? key;
     if (classified.has(name)) {
-      throw new VibeError8({ code: "VIBE_SCHEMA_INVALID", message: `RLS classifies model "${name}" more than once`, meta: { issues: [{ rule: "rls-duplicate-classification", model: name }] } });
+      throw new VibeError9({ code: "VIBE_SCHEMA_INVALID", message: `RLS classifies model "${name}" more than once`, meta: { issues: [{ rule: "rls-duplicate-classification", model: name }] } });
     }
     classified.add(name);
     named.push([name, descriptor.value]);
@@ -2343,6 +2979,7 @@ function enumFactory(config) {
 var generate = Object.assign((schemaDef) => ({ prisma: generatePrisma(schemaDef) }), { prisma: generatePrisma });
 var dsl = {
   string,
+  localDate,
   int,
   bigint,
   float,
@@ -2372,9 +3009,11 @@ export {
   ChainableDatetimeColumn,
   ChainableDecimalColumn,
   ChainableEnumColumn,
+  ChainableFloatColumn,
   ChainableIdColumn,
   ChainableIntegerColumn,
   ChainableJsonColumn,
+  ChainableNumericColumn,
   ChainableStringColumn,
   base,
   baseWithWorkspace,
@@ -2382,11 +3021,15 @@ export {
   cloneColumnDef,
   compileChecks,
   compileIndexPredicate,
+  compileModelChecks,
+  compileRowRules,
   create,
+  createChecksBuilder,
   createChildrenBuilder,
   createEnum,
   createIndexBuilder,
   createPredicateBuilder,
+  createRowRuleBuilder,
   defineRelations,
   defineRelationsPart,
   defineRls,
@@ -2398,6 +3041,7 @@ export {
   fields,
   generatePrisma,
   getColumnNames,
+  localDate,
   mergeRelations,
   planSchema,
   resolveRelationType,
@@ -2412,4 +3056,4 @@ export {
   withNameDescription
 };
 
-//# debugId=24494B6B129BF22A64756E2164756E21
+//# debugId=7EE10300C00F60DE64756E2164756E21