@vibeorm/dsl 4.2.0 → 4.3.0

package/dist/predicate.d.ts

@@ -12,14 +12,38 @@
  * one instance serves every model. The type parameters on
  * {@link PredicateBuilder} are what bind it to a particular model's columns.
  */
-import type { ExclusionIR, CheckIR, EnumIR, FieldIR, PredicateIR } from "@vibeorm/schema";
+import type { ExclusionIR, CheckIR, EnumIR, FieldIR, PredicateExpression, PredicateIR } from "@vibeorm/schema";
 import type { SqlDialect } from "@vibeorm/sql";
-import type { ModelDef, ChecksCallback, ModelCheckConfig, PredicateBuilder, SchemaDefinition } from "./types.ts";
+import type { ModelDef, ChecksBuilder, ChecksCallback, ModelCheckConfig, PredicateBuilder, SchemaDefinition } from "./types.ts";
+/** Internal shared scalar lowering for index keys; preserves B's exact literal carriers. */
+export declare function toPredicateExpression(params: {
+    readonly value: unknown;
+    readonly at: string;
+}): PredicateExpression;
 /**
  * One predicate builder instance. Stateless and structural — the type
  * parameters, not the value, bind it to a model.
  */
 export declare function createPredicateBuilder<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition>(): PredicateBuilder<TColumns, TSchema>;
+/** What the check rules need to know about the model they belong to. */
+export type CheckModelContext = {
+    /** Logical model name, for messages. */
+    readonly model: string;
+    /** PHYSICAL table name: generated CHECK names start with it. */
+    readonly table: string;
+    /** The model's built fields: logical name, `@map`ped name, scalar type, optional, list. */
+    readonly fields: readonly FieldIR[];
+    /** Schema enums, for a presence table's members. */
+    readonly enums: readonly EnumIR[];
+};
+/**
+ * The `c` a model's `checks` callback receives: the predicate builder plus the
+ * named check rules, each validated against `context` and returned as a named
+ * CHECK.
+ */
+export declare function createChecksBuilder<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition>(params: {
+    context: CheckModelContext;
+}): ChecksBuilder<TColumns, TSchema>;
 /** A model's CHECKs, still un-rendered: raw text stays raw, typed stays typed. */
 export type EvaluatedCheck = {
     readonly kind: "raw";
@@ -29,6 +53,10 @@ export type EvaluatedCheck = {
     readonly kind: "typed";
     readonly name: string;
     readonly predicate: PredicateIR;
+    /** The check rule that produced it, when one did. */
+    readonly origin?: string;
+    /** True when the name was generated by the rule. */
+    readonly minted?: boolean;
 };
 /**
  * Run a model's `checks` declaration, whichever form it took.
@@ -36,10 +64,14 @@ export type EvaluatedCheck = {
  * The raw array form and the typed callback form produce the same shape of
  * answer, so every consumer downstream handles ONE list — and raw text is
  * carried through untouched rather than parsed into a predicate.
+ *
+ * The check rules (`c.order`, `c.allOrNone`, `c.presence`, …) need the model's
+ * fields: pass `context`. Without it they refuse with `check-rule-context`.
  */
 export declare function evaluateChecks(params: {
     checks: readonly ModelCheckConfig[] | ChecksCallback | undefined;
     model: string;
+    context?: CheckModelContext;
 }): readonly EvaluatedCheck[];
 /** What a predicate needs to know about the model it belongs to. */
 export type PredicateModel = {
@@ -62,11 +94,36 @@ export declare function compileExclusions(params: {
     model: PredicateModel;
     dialect: SqlDialect;
 }): readonly ExclusionIR[];
+/**
+ * A `checks` declaration as IR, for a caller that holds the built fields but
+ * not the model definition. Check rules generate their names from `table`;
+ * pass it when the model is `@@map`ped, because `PredicateModel` does not
+ * carry the table name. Without it the model name is the table name, as for
+ * an unmapped model. A generated name that collides or is too long for the
+ * dialect is refused, exactly as `compileModelChecks` refuses it.
+ */
 export declare function compileChecks(params: {
     checks: readonly ModelCheckConfig[] | ChecksCallback | undefined;
     model: PredicateModel;
     dialect: SqlDialect;
     enums: readonly EnumIR[];
+    /** PHYSICAL table name generated CHECK names start with; defaults to `model.name`. */
+    table?: string;
+}): readonly CheckIR[];
+/**
+ * A model's CHECKs as IR: the `checks` declaration (hand-written and check
+ * rules) first, in declaration order, then the column rules (`.nonNegative()`,
+ * …) in column order. Generated names use the PHYSICAL table and column names.
+ *
+ * The one compiler both `toIR` and the `.prisma` generator call, so a printed
+ * schema and a compiled one hold the same CHECKs.
+ */
+export declare function compileModelChecks(params: {
+    model: ModelDef;
+    /** The model's built fields, from the same `buildField` the IR uses. */
+    predicateModel: PredicateModel;
+    dialect: SqlDialect;
+    enums: readonly EnumIR[];
 }): readonly CheckIR[];
 /**
  * An index's partial predicate as IR: the raw string verbatim, or a typed

package/dist/relation-plan.d.ts

@@ -20,7 +20,7 @@
  *    parent) use the `@relation` alias when there is one, else the source model
  *    name, suffixed on collision.
  */
-import type { CascadeAction, PredicateIR, QualifiedSqlName, RelationType } from "@vibeorm/schema";
+import type { CascadeAction, IndexKeyTermIR, PredicateIR, QualifiedSqlName, RelationType } from "@vibeorm/schema";
 import type { IndexType, ModelDef, RelationsMap, SchemaDef } from "./types.ts";
 /**
  * Structural role of a planned relation field:
@@ -57,6 +57,8 @@ export type PlannedIndex = {
     readonly map?: string;
     readonly isUnique: boolean;
     readonly columns: readonly string[];
+    /** Whole ordered key, lowered once by the index builder. */
+    readonly keys?: readonly IndexKeyTermIR[];
     readonly indexType?: IndexType;
     /** Qualified operator classes keyed by logical index column. */
     readonly ops?: Readonly<Partial<Record<string, QualifiedSqlName>>>;

package/dist/row-rules.d.ts

@@ -0,0 +1,63 @@
+import type { Dialect, ModelIR, RowRuleIR, SchemaIR } from "@vibeorm/schema";
+import type { ModelDef } from "./types.ts";
+/** Model-bound authoring declarations; only frozen uses the short creation gate spelling. */
+export type RowRuleDeclaration<TColumn extends string = string> = {
+    readonly kind: "appendOnly";
+    readonly name?: string;
+} | {
+    readonly kind: "fixed";
+    readonly name?: string;
+    readonly columns: readonly TColumn[];
+    readonly when: {
+        readonly fromCreation: true;
+        readonly onceSet?: never;
+    } | {
+        readonly onceSet: TColumn;
+        readonly fromCreation?: never;
+    };
+} | {
+    readonly kind: "rowFixed";
+    readonly name?: string;
+    readonly except: readonly TColumn[];
+} | {
+    readonly kind: "frozen";
+    readonly name?: string;
+    readonly from: "create" | TColumn;
+    readonly mutable: readonly TColumn[];
+};
+/** Immutable row-rule data builder, without client-side row-state inference. */
+export type RowRuleBuilder<TColumn extends string = string> = {
+    appendOnly(options?: {
+        readonly name?: string;
+    }): RowRuleDeclaration<TColumn>;
+    fixed(options: {
+        readonly columns: readonly TColumn[];
+        readonly when: {
+            readonly fromCreation: true;
+            readonly onceSet?: never;
+        } | {
+            readonly onceSet: TColumn;
+            readonly fromCreation?: never;
+        };
+        readonly name?: string;
+    }): RowRuleDeclaration<TColumn>;
+    rowFixed(options: {
+        readonly except: readonly TColumn[];
+        readonly name?: string;
+    }): RowRuleDeclaration<TColumn>;
+    frozen(options: {
+        readonly from: "create" | TColumn;
+        readonly mutable: readonly TColumn[];
+        readonly name?: string;
+    }): RowRuleDeclaration<TColumn>;
+};
+/** Build model-bound row-rule declarations and copy every retained list and gate. */
+export declare function createRowRuleBuilder<TColumn extends string = string>(): RowRuleBuilder<TColumn>;
+/** Evaluate the callback against finalized fields and lower short frozen gates without guessing. */
+export declare function compileRowRules(params: {
+    model: ModelDef;
+    irModel: ModelIR;
+    dialect: Dialect;
+    schema?: SchemaIR;
+}): readonly RowRuleIR[];
+//# sourceMappingURL=row-rules.d.ts.map

package/dist/to-ir.d.ts

@@ -27,7 +27,10 @@
  * - `.collation()` / `{ collation }` → `FieldIR.collation`.
  * - relation types are derived structurally by `resolveRelationType`.
  */
-import type { DefaultValueIR, ExtensionRegistry, FieldIR, Provider, SchemaIR } from "@vibeorm/schema";
+import type { DefaultValueIR, EnumIR, ExtensionRegistry, FieldIR, IndexIR, Provider, SchemaIR } from "@vibeorm/schema";
+import type { SqlDialect } from "@vibeorm/sql";
+import type { PredicateModel } from "./predicate.ts";
+import type { PlannedIndex } from "./relation-plan.ts";
 import type { ColumnDef, DatetimeColumnConfig, IdColumnConfig, SchemaDef, StringColumnConfig } from "./types.ts";
 /** Compile a column default once for both DSL output paths. */
 export declare function fieldDefault(params: {
@@ -70,6 +73,13 @@ export declare function buildField(params: {
     /** Native type resolved by an extension field-type lowering, when present. */
     extensionNativeType?: string;
 }): FieldIR;
+/** Shared planned-index lowering for IR and source spelling; not a package-root authoring API. */
+export declare function buildIndex(params: {
+    index: PlannedIndex;
+    model: PredicateModel;
+    dialect: SqlDialect;
+    enums: readonly EnumIR[];
+}): IndexIR;
 /**
  * Compiles a composed DSL schema to the canonical `SchemaIR`, then validates it.
  *

package/dist/types.d.ts

@@ -5,14 +5,16 @@
  * through `defineRelations` (Drizzle-style), which keeps column references
  * type-safe without inference-heavy model types.
  */
-import type { ExclusionSpec, ExclusionEndpoint, CascadeAction, EnumStorage, JsonSchemaRefIR, ExtensionAttributeValue, PredicateExpression, PredicateIR, Provider, QualifiedSqlName, RlsContextIR, RlsContextRefIR, RlsPolicyIR } from "@vibeorm/schema";
+import type { ExclusionSpec, ExclusionEndpoint, CascadeAction, EnumStorage, GeneratedColumnOptions, IndexKeyTermIR, JsonSchemaRefIR, ValidatorRefIR, ExtensionAttributeValue, PredicateExpression, PredicateIR, PredicateNumericType, Provider, QualifiedSqlName, RlsContextIR, RlsContextRefIR, RlsPolicyIR } from "@vibeorm/schema";
 import type { ChainableEnumColumn } from "./column.ts";
+import type { RowRuleBuilder, RowRuleDeclaration } from "./row-rules.ts";
+export type { RowRuleBuilder, RowRuleDeclaration } from "./row-rules.ts";
 /** Referential actions, re-exported from the IR so both sources agree. */
 export type { CascadeAction };
 /** Enum storage strategies (`"database"` | `"string"`), re-exported from the IR. */
 export type { EnumStorage };
 /** Column kinds the DSL can declare. */
-export type ColumnType = "string" | "int" | "bigint" | "float" | "decimal" | "boolean" | "datetime" | "json" | "id" | "bytes" | "enum" | "unsupported";
+export type ColumnType = "string" | "localDate" | "int" | "bigint" | "float" | "decimal" | "boolean" | "datetime" | "json" | "id" | "bytes" | "enum" | "unsupported";
 /** Primary-key generator strategies for `dsl.id()`. */
 export type IdGeneratorType = "ulid" | "cuid" | "uuid" | "nanoid" | "autoincrement" | "none";
 /** PostgreSQL index types Prisma can express via `@@index(..., type: X)`. */
@@ -25,12 +27,53 @@ export type BaseColumnConfig = {
     array?: boolean;
     /** `@map("column_name")` — database column name when it differs. */
     map?: string;
+    /** Stored database expression; the declaration is copied and frozen. */
+    generated?: GeneratedColumnOptions;
     /** `@default(dbgenerated("..."))` — database-native default expression. */
     dbgenerated?: string;
     /** Emitted as a `///` doc comment above the column (Zod generators, docs). */
     comment?: string;
+    /**
+     * One-column CHECK rules (`.nonNegative()`, `.range()`, `.oneOf()`, …),
+     * each compiled to a named CHECK. Stored copy-on-write and frozen, so a
+     * template column never shares rules with another model.
+     */
+    checks?: readonly ColumnCheckRule[];
+    /** Consumer-owned write-only scalar validator export; types remain unchanged. */
+    validator?: ValidatorRefIR;
     [key: string]: unknown;
 };
+/** Options every check rule takes. */
+export type CheckRuleOptions = {
+    /** Explicit CHECK name, replacing the generated `<Table>_<column>_<rule>_check`. */
+    readonly name?: string;
+    /** The rule word in the generated name (`range` in `Device_volume_range_check`). */
+    readonly rule?: string;
+};
+/** What a one-column rule asserts, as data; the column is the one it is declared on. */
+export type ColumnCheckShape = {
+    readonly kind: "compare";
+    readonly op: "gt" | "gte" | "lt" | "lte";
+    readonly value: string | number;
+} | {
+    readonly kind: "range";
+    readonly min: string | number;
+    readonly max: string | number;
+} | {
+    readonly kind: "oneOf";
+    readonly values: readonly string[];
+} | {
+    readonly kind: "lengthAtMost";
+    readonly max: number;
+};
+/** One one-column CHECK rule, as a column method records it. */
+export type ColumnCheckRule = {
+    /** The rule word in the generated name. */
+    readonly rule: string;
+    readonly check: ColumnCheckShape;
+    /** Explicit CHECK name, replacing the generated one. */
+    readonly name?: string;
+};
 export type StringColumnConfig = BaseColumnConfig & {
     default?: string | readonly string[];
     /** `@db.VarChar(n)` */
@@ -49,6 +92,10 @@ export type StringColumnConfig = BaseColumnConfig & {
      */
     collation?: string;
 };
+/** A calendar day stored as String @db.Date; only canonical literal defaults are admitted. */
+export type LocalDateColumnConfig = BaseColumnConfig & {
+    default?: string;
+};
 export type IntColumnConfig = BaseColumnConfig & {
     autoincrement?: boolean;
     default?: number | readonly number[];
@@ -234,6 +281,10 @@ export type NamedCheckDef = {
     readonly __type: "check";
     readonly name: string;
     readonly predicate: PredicateIR;
+    /** The check rule that produced it (`c.allOrNone(…)`, a presence table), for error messages. */
+    readonly __origin?: string;
+    /** True when the name was generated, not passed with `{ name }`. */
+    readonly __minted?: boolean;
 };
 /**
  * The `c` handed to a model's `checks` callback, returning typed or raw named CHECKs.
@@ -243,7 +294,91 @@ export type NamedCheckDef = {
  *   c.named("dispatch_clock", c.gt(c.field("deadlineAt"), c.field("startedAt"))),
  * ]
  */
-export type ChecksCallback<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition> = (c: PredicateBuilder<TColumns, TSchema>) => (NamedCheckDef | ModelCheckConfig)[];
+export type ChecksCallback<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition> = (c: ChecksBuilder<TColumns, TSchema>) => (NamedCheckDef | ModelCheckConfig)[];
+/** Options of `c.order()`. */
+export type OrderCheckOptions<TColumn extends string = string> = CheckRuleOptions & {
+    /** `false` allows equal values (`>=`); default `true` (`>`). */
+    readonly strict?: boolean;
+    /**
+     * The column the generated name is built from and the CHECK reads first:
+     * the later column by default (`"endAt" > "startAt"`), or the earlier one
+     * (`"cancelledAt" < "startAt"`).
+     */
+    readonly nameColumn?: TColumn;
+};
+/** One state of a presence table: the optional columns that must be set, and those that must be empty. */
+export type PresenceState<TColumns extends string = string> = {
+    /** NOT NULL while the enum column holds this member. */
+    readonly set?: readonly TColumns[];
+    /** NULL while the enum column holds this member. */
+    readonly unset?: readonly TColumns[];
+};
+/**
+ * A presence table: per enum member, which optional columns are set and which
+ * are empty. A column listed in neither is free in that state. Every member
+ * must appear exactly once.
+ */
+export type PresenceCheckConfig<TColumns extends string = string, TMember extends string = string, TBy extends string = string> = {
+    /** A REQUIRED enum column of this model. */
+    readonly by: TBy;
+    /** The rule word in each generated name; defaults to the `by` column's name. */
+    readonly rule?: string;
+    /** Explicit CHECK names per column, replacing the generated ones. */
+    readonly names?: {
+        readonly [C in TColumns]?: string;
+    };
+    readonly states: {
+        readonly [S in TMember]: PresenceState<TColumns>;
+    };
+};
+/**
+ * The model's enum columns, as names. An unbound builder (`ChecksBuilder` with
+ * its default `string` columns) knows no column kinds, so any name is allowed
+ * and the schema build checks it.
+ */
+type EnumColumnNames<TColumns extends string, TSchema extends SchemaDefinition> = string extends TColumns ? TColumns : {
+    [C in TColumns]: C extends keyof TSchema ? (TSchema[C] extends ColumnDef<"enum"> ? C : never) : never;
+}[TColumns];
+/** The members of one enum column, read from its `__enumValues` tuple. */
+type EnumMembersOf<TSchema extends SchemaDefinition, TColumn extends string> = TColumn extends keyof TSchema ? TSchema[TColumn] extends {
+    readonly __enumValues?: infer TValues extends readonly string[];
+} ? TValues[number] : string : string;
+/** Columns that can pair with another column through the shared scalar-family table. */
+type PairableCheckColumns<TColumns extends string, TSchema extends SchemaDefinition, TColumn extends TColumns> = ColumnRefKind extends SchemaColumnRefKind<TSchema, TColumn> ? TColumns : {
+    [C in TColumns]: SchemaColumnRefKind<TSchema, C> extends PairableRefKind[SchemaColumnRefKind<TSchema, TColumn>] ? C : never;
+}[TColumns];
+/**
+ * The `c` handed to a model's `checks` callback: the predicate builder plus
+ * the named check rules, each returning ready, named CHECKs.
+ *
+ * Names are generated as `<Table>_<column>_<rule>_check` from the PHYSICAL
+ * table and column names; every rule takes `{ name }` to replace it.
+ *
+ * @example
+ * checks: (c) => [
+ *   c.order("startAt", "endAt"),
+ *   c.allOrNone("latitude", "longitude"),
+ *   ...c.presence({ by: "state", states: { draft: { unset: ["sentAt"] }, sent: { set: ["sentAt"] } } }),
+ * ]
+ */
+export type ChecksBuilder<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition> = PredicateBuilder<TColumns, TSchema> & {
+    /** `later > earlier` (or `>=` with `strict: false`), named after the later column. NULL in either passes. */
+    order<TEarlier extends TColumns, TLater extends PairableCheckColumns<TColumns, TSchema, NoInfer<TEarlier>>>(earlier: TEarlier, later: TLater, options?: OrderCheckOptions<NoInfer<TEarlier | TLater>>): NamedCheckDef;
+    /** All of the columns set, or none of them. */
+    allOrNone<C extends TColumns>(...columns: C[]): NamedCheckDef;
+    allOrNone<C extends TColumns>(columns: readonly C[], options: CheckRuleOptions): NamedCheckDef;
+    /** Exactly one of the columns set. */
+    exactlyOne<C extends TColumns>(...columns: C[]): NamedCheckDef;
+    exactlyOne<C extends TColumns>(columns: readonly C[], options: CheckRuleOptions): NamedCheckDef;
+    /** At most one of the columns set. */
+    atMostOne<C extends TColumns>(...columns: C[]): NamedCheckDef;
+    atMostOne<C extends TColumns>(columns: readonly C[], options: CheckRuleOptions): NamedCheckDef;
+    /** At least one of the columns set. */
+    anySet<C extends TColumns>(...columns: C[]): NamedCheckDef;
+    anySet<C extends TColumns>(columns: readonly C[], options: CheckRuleOptions): NamedCheckDef;
+    /** One CHECK per column the presence table names; spread the result into the list. */
+    presence<TBy extends EnumColumnNames<TColumns, TSchema>>(config: PresenceCheckConfig<TColumns, EnumMembersOf<TSchema, TBy>, TBy>): NamedCheckDef[];
+};
 /**
  * Application-level row-scoping policy — the DSL twin of
  * `@@policy([field], context: "key")`. The runtime fails closed on policied
@@ -263,6 +398,8 @@ export type IndexDef = {
     readonly __map?: string;
     readonly __type: "index" | "unique";
     readonly __columns: readonly string[];
+    /** Complete ordered authoring keys when computation or explicit direction is present. */
+    readonly __keys?: readonly IndexKeyTermIR[];
     readonly __indexType?: IndexType;
     /** Non-unique PostgreSQL operator classes, keyed by logical index field name. */
     readonly __ops?: Readonly<Partial<Record<string, QualifiedSqlName>>>;
@@ -320,14 +457,44 @@ export type UniqueIndexOptions = {
 export type PartialIndexDef<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition> = IndexDef & {
     where(predicate: (c: PredicateBuilder<TColumns, TSchema>) => PredicateIR): IndexDef;
 };
-/** Index builder; column names are constrained to the model's own columns. */
-export type IndexBuilder<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition> = {
-    on<T extends TColumns>(...columns: T[]): PartialIndexDef<TColumns, TSchema>;
-    on<T extends TColumns>(columns: T[], options: IndexOptions<NoInfer<T>>): PartialIndexDef<TColumns, TSchema>;
+/** Dialect-authored trusted scalar SQL; always requires a physical index map. */
+export type RawIndexExpression = {
+    readonly __type: "rawIndexExpression";
+    readonly text: string;
+};
+/** Scalar or named key before direction is applied. */
+export type UnsortedIndexKey<TColumns extends string = string> = TColumns | PredicateExpr | RawIndexExpression;
+/** Direction belongs to the key, not its scalar expression data. */
+export type SortedIndexKey<TColumns extends string = string> = {
+    readonly __type: "sortedIndexKey";
+    readonly key: UnsortedIndexKey<TColumns>;
+    readonly sort: "asc" | "desc";
+};
+/** Ordered mixed key accepted by ordinary and unique BTree builders. */
+export type IndexKey<TColumns extends string = string> = UnsortedIndexKey<TColumns> | SortedIndexKey<TColumns>;
+type StringIndexColumns<TColumns extends string, TSchema extends SchemaDefinition> = {
+    [C in TColumns]: "String" extends SchemaColumnRefKind<TSchema, C> ? C : "Id" extends SchemaColumnRefKind<TSchema, C> ? C : never;
+}[TColumns];
+/** Index builder; scalar helpers are separate from the terminal where builder. */
+export type IndexBuilder<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition> = Pick<PredicateBuilder<TColumns, TSchema>, "field" | "add" | "sub" | "mul"> & {
+    lower<C extends StringIndexColumns<TColumns, TSchema>>(column: C): PredicateExpr<"String">;
+    lower(expression: PredicateExpr<"String" | "Id">): PredicateExpr<"String">;
+    upper<C extends StringIndexColumns<TColumns, TSchema>>(column: C): PredicateExpr<"String">;
+    upper(expression: PredicateExpr<"String" | "Id">): PredicateExpr<"String">;
+    asc(key: UnsortedIndexKey<TColumns>): SortedIndexKey<TColumns>;
+    desc(key: UnsortedIndexKey<TColumns>): SortedIndexKey<TColumns>;
+    sql(params: {
+        readonly text: string;
+    }): RawIndexExpression;
+    on(...keys: IndexKey<TColumns>[]): PartialIndexDef<TColumns, TSchema>;
+    on<C extends TColumns>(keys: C[], options: IndexOptions<NoInfer<C>>): PartialIndexDef<TColumns, TSchema>;
+    on(keys: IndexKey<TColumns>[], options: Omit<IndexOptions, "ops"> & {
+        readonly ops?: never;
+    }): PartialIndexDef<TColumns, TSchema>;
     /** Alias of `on(...)` — reads better next to `unique(...)`. */
-    index<T extends TColumns>(...columns: T[]): PartialIndexDef<TColumns, TSchema>;
-    unique<T extends TColumns>(...columns: T[]): PartialIndexDef<TColumns, TSchema>;
-    unique<T extends TColumns>(columns: T[], options: UniqueIndexOptions): PartialIndexDef<TColumns, TSchema>;
+    index(...keys: IndexKey<TColumns>[]): PartialIndexDef<TColumns, TSchema>;
+    unique(...keys: IndexKey<TColumns>[]): PartialIndexDef<TColumns, TSchema>;
+    unique(keys: IndexKey<TColumns>[], options: UniqueIndexOptions): PartialIndexDef<TColumns, TSchema>;
     gin<T extends TColumns>(...columns: T[]): PartialIndexDef<TColumns, TSchema>;
     gist<T extends TColumns>(...columns: T[]): PartialIndexDef<TColumns, TSchema>;
     hash<T extends TColumns>(...columns: T[]): PartialIndexDef<TColumns, TSchema>;
@@ -386,6 +553,17 @@ export type PredicateFieldExpr<TColumn extends string = string, TKind extends Co
 export type PredicateExpr<TKind extends ColumnRefKind = ColumnRefKind> = PredicateExpression & {
     readonly __kind: TKind;
 };
+/** Numeric scalar families accepted by arithmetic, without implicit promotion. */
+export type PredicateNumericKind = PredicateNumericType;
+/** Exact literal carriers for each numeric scalar family. */
+export type PredicateNumericLiteral = {
+    readonly Int: number;
+    readonly BigInt: bigint | number;
+    readonly Float: number;
+    readonly Decimal: string;
+};
+/** An arithmetic operand in the same numeric family as its left expression. */
+export type PredicateNumericOperand<TKind extends PredicateNumericKind> = PredicateExpr<TKind> | PredicateNumericLiteral[TKind];
 type JsonPredicateColumns<TColumns extends string, TSchema extends SchemaDefinition> = {
     [C in TColumns]: "Json" extends SchemaColumnRefKind<TSchema, C> ? C : never;
 }[TColumns];
@@ -411,6 +589,25 @@ export type PredicateBuilder<TColumns extends string = string, TSchema extends S
     gte<TKind extends ColumnRefKind>(left: PredicateExpr<TKind>, right: ComparisonOperand<NoInfer<TKind>>): PredicateIR;
     lt<TKind extends ColumnRefKind>(left: PredicateExpr<TKind>, right: ComparisonOperand<NoInfer<TKind>>): PredicateIR;
     lte<TKind extends ColumnRefKind>(left: PredicateExpr<TKind>, right: ComparisonOperand<NoInfer<TKind>>): PredicateIR;
+    /** Add same-family numeric operands. SQL NULL behavior is unchanged. */
+    add<TKind extends PredicateNumericKind>(params: {
+        left: PredicateExpr<TKind>;
+        right: PredicateNumericOperand<NoInfer<TKind>>;
+    }): PredicateExpr<TKind>;
+    /** Subtract same-family numeric operands, preserving the authored grouping. */
+    sub<TKind extends PredicateNumericKind>(params: {
+        left: PredicateExpr<TKind>;
+        right: PredicateNumericOperand<NoInfer<TKind>>;
+    }): PredicateExpr<TKind>;
+    /** Multiply same-family numeric operands. SQLite refuses Decimal arithmetic. */
+    mul<TKind extends PredicateNumericKind>(params: {
+        left: PredicateExpr<TKind>;
+        right: PredicateNumericOperand<NoInfer<TKind>>;
+    }): PredicateExpr<TKind>;
+    /** Fold text to lowercase using the database's locale/collation behavior. */
+    lower(expression: PredicateExpr<"String" | "Id">): PredicateExpr<"String">;
+    /** Fold text to uppercase. Local dates and non-text Id storage refuse at build. */
+    upper(expression: PredicateExpr<"String" | "Id">): PredicateExpr<"String">;
     /** PostgreSQL/PGlite CHECK only. Extract text without asserting the JSON leaf's type. */
     jsonText(params: {
         field: JsonPredicateColumns<TColumns, TSchema>;
@@ -452,6 +649,8 @@ export type ModelDef<TSchema extends SchemaDefinition = SchemaDefinition> = {
      */
     readonly __exclusions?: readonly ExclusionSpec[] | ExclusionsCallback;
     readonly __checks?: readonly ModelCheckConfig[] | ChecksCallback;
+    /** Separate row-rule authoring callback, evaluated against finalized model fields. */
+    readonly __rowRules?: (r: RowRuleBuilder) => readonly RowRuleDeclaration[];
     /** Extension attributes declared on the model (`@@search`-style). */
     readonly __extensions?: readonly ExtensionAttributeUse[];
     /** `@@policy([field], context: "key")` — application-level row scoping. */
@@ -486,6 +685,8 @@ export type CreateModelConfig<TSchema extends SchemaDefinition = SchemaDefinitio
      */
     exclusions?: readonly ExclusionConfig<TSchema>[] | ((c: PredicateBuilder<SchemaColumnNames<TSchema>, TSchema>) => readonly ExclusionConfig<TSchema>[]);
     checks?: readonly ModelCheckConfig[] | ChecksCallback<SchemaColumnNames<TSchema>, TSchema>;
+    /** Database-enforced row invariants; every field slot is bound to this model. */
+    rowRules?: (r: RowRuleBuilder<SchemaColumnNames<TSchema>>) => readonly RowRuleDeclaration<SchemaColumnNames<TSchema>>[];
     /** Extension model attributes (`@@search`-style declarations). */
     extensions?: readonly ExtensionAttributeUse[];
     /**
@@ -510,6 +711,7 @@ export type ColumnRefKind = "String" | "Boolean" | "Int" | "BigInt" | "Float" |
 /** `ColumnType` → `ColumnRefKind`, as a table: one indexed access, never a conditional chain. */
 type RefKindByColumnType = {
     readonly string: "String";
+    readonly localDate: "String";
     readonly int: "Int";
     readonly bigint: "BigInt";
     readonly float: "Float";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeorm/dsl",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "description": "TypeScript schema DSL for VibeORM v2 — compiles to canonical SchemaIR, with .prisma generation for interop",
   "keywords": [
     "orm",
@@ -43,8 +43,8 @@
     "bun": ">=1.2.0"
   },
   "dependencies": {
-    "@vibeorm/schema": "4.2.0",
-    "@vibeorm/sql": "4.2.0"
+    "@vibeorm/schema": "4.3.0",
+    "@vibeorm/sql": "4.3.0"
   },
   "publishConfig": {
     "access": "public"