@prisma/orm-family-sql 8.0.0-rc.2-dev.3 → 8.0.0-rc.20-dev.1

package/dist/{db-D18PrXKW-DvTv4JFn.d.mts → db-D1d75IvM-D4mRDC6w.d.mts}

@@ -1,17 +1,20 @@
-import { r as StorageTable } from "./storage-table-DSeWszOL-CI-cItEK.mjs";
-import { T as QueryOperationTypesBase, h as ExtractStorageColumnTypes, l as ExtractAggregateTypes, m as ExtractStorageColumnInputTypes, p as ExtractQueryOperationTypes, r as AggregateTypesBase, u as ExtractCodecTypes } from "./types-BDUG29Df-LE85dIXP.mjs";
-import { t as StorageColumnMapAt } from "./types-UcHa2cTe.mjs";
-import { Et as SelectAst, c as AnyFromSource } from "./types-v3qxLLxo-DCeKv7yY.mjs";
-import "./ast-HFcfQZr-.mjs";
-import { t as SqlQueryPlan } from "./plan-CDxduYaN-pLIyyJaB.mjs";
-import { S as TraitExpression, c as RawAffectedCountQuery, f as RawRowQuery, g as RawSqlInterpolation, h as RawSqlBuilder, i as CodecTypesBase, o as Expression, r as CodecExpression, s as NoReservedRowColumn, x as ScopeField, y as RawSqlTag } from "./expression-FJK6Ar-d.mjs";
-import "./plan-BHLdb0Z7.mjs";
+import { r as StorageTable } from "./storage-table-Bf1ZjnxO-pUj6pyP0.mjs";
+import { D as QueryOperationTypesBase, _ as ExtractStorageColumnTypes, d as ExtractAggregateTypes, f as ExtractCodecTypes, g as ExtractStorageColumnInputTypes, h as ExtractQueryOperationTypes, r as AggregateTypesBase } from "./types-DfKvtJwS-CrpWTGBJ.mjs";
+import { l as StorageColumnMapAt, r as IsOptionalCreateColumn } from "./types-CkAd8SWm.mjs";
+import { Ct as OrderByNulls, l as AnyFromSource } from "./types-DriMIMNQ-BkbsW7w3.mjs";
+import { n as SqlQueryPlan } from "./plan-Cr4azjnG-CuL8FqXC.mjs";
+import { C as TraitExpression, S as StorageColumnScopeField, c as RawAffectedCountQuery, f as RawRowQuery, g as RawSqlInterpolation, h as RawSqlBuilder, i as CodecTypesBase, o as Expression, s as NoReservedRowColumn, x as ScopeField } from "./expression-6ld_ZQL6-fOuazzzm.mjs";
+import "./expression-D8HstQiB.mjs";
+import { a as Subquery, r as Functions, t as BooleanCodecType } from "./functions-EW-RrRn3.mjs";
+import { c as LockOptionCapabilities, l as LockStrengthCapabilities, u as LockWaitOptions } from "./ast-YEMe_B8z.mjs";
+import { r as TableIndexReferences } from "./index-reference-4wsdeB7v-DCwswK-q.mjs";
+import "./index-reference-D8ewQRJr.mjs";
+import "./plan-Di6Gs2JD.mjs";
 import { AnnotationValue, OperationKind, ValidAnnotations } from "@prisma/orm-framework/components/runtime";
-//#region ../../../2-sql/4-lanes/sql-builder/dist/db-D18PrXKW.d.mts
+//#region ../../../2-sql-family/4-lanes/sql-builder/dist/db-D1d75IvM.d.mts
 //#region src/scope.d.ts
 type GatedMethod<Capabilities, Required, Method> = Capabilities extends Required ? Method : never;
 declare const JoinOuterScope: unique symbol;
-declare const SubqueryMarker: unique symbol;
 type Expand<T> = { [K in keyof T]: T[K]; } & unknown;
 type EmptyRow = Record<never, ScopeField>;
 type ScopeTable = Record<string, ScopeField>;
@@ -31,14 +34,7 @@ type DefaultScope<Name extends string, Table extends StorageTable> = {
   topLevel: StorageTableToScopeTable<Table>;
   namespaces: { [K in Name]: StorageTableToScopeTable<Table>; };
 };
-type StorageTableToScopeTable<T extends StorageTable> = { [K in keyof T['columns']]: {
-  codecId: T['columns'][K]['codecId'];
-  nullable: T['columns'][K]['nullable'];
-} & (T['columns'][K] extends {
-  many: true;
-} ? {
-  many: true;
-} : Record<never, never>); };
+type StorageTableToScopeTable<T extends StorageTable> = { [K in keyof T['columns']]: StorageColumnScopeField<T['columns'][K]>; };
 type MergeScopes<A extends Scope, B extends Scope> = {
   topLevel: Expand<Omit<A['topLevel'], keyof B['topLevel']> & Omit<B['topLevel'], keyof A['topLevel']>>;
   namespaces: Expand<A['namespaces'] & B['namespaces']>;
@@ -55,11 +51,6 @@ type NullableScope<S extends Scope> = {
   topLevel: NullableScopeTable<S['topLevel']>;
   namespaces: { [TableName in keyof S['namespaces']]: NullableScopeTable<S['namespaces'][TableName]>; };
 };
-type Subquery<RowType extends Record<string, ScopeField>> = {
-  [SubqueryMarker]: RowType;
-  buildAst(): SelectAst;
-  getRowFields(): Record<string, ScopeField>;
-};
 type QueryContext = {
   readonly codecTypes: CodecTypesBase;
   readonly capabilities: Record<string, Record<string, boolean>>;
@@ -70,17 +61,12 @@ type QueryContext = {
 };
 //#endregion
 //#region src/expression.d.ts
-type BooleanCodecType = {
-  codecId: 'pg/bool@1';
-  nullable: boolean;
-};
 type WithField<Source, Field extends ScopeField, Alias extends string> = Expand<Source & { [K in Alias]: Field; }>;
 type WithFields<Source, FromScope extends ScopeTable, Columns extends readonly (keyof FromScope)[]> = Expand<Source & Pick<FromScope, Columns[number]>>;
 type ExtractScopeFields<T extends Record<string, Expression<ScopeField>>> = { [K in keyof T]: T[K] extends Expression<infer F extends ScopeField> ? F : never; };
 type FieldProxy<AvailableScope extends Scope> = { [K in keyof AvailableScope['topLevel']]: Expression<AvailableScope['topLevel'][K]>; } & { [TableName in keyof AvailableScope['namespaces']]: { [K in keyof AvailableScope['namespaces'][TableName]]: Expression<AvailableScope['namespaces'][TableName][K]>; }; };
 type ExpressionBuilder<AvailableScope extends Scope, QC extends QueryContext> = (fields: FieldProxy<AvailableScope>, fns: Functions<QC>) => Expression<BooleanCodecType>;
 type OrderByDirection = 'asc' | 'desc';
-type OrderByNulls = 'first' | 'last';
 type OrderByOptions = {
   direction?: OrderByDirection;
   nulls?: OrderByNulls;
@@ -89,49 +75,6 @@ type OrderByScope<AvailableScope extends Scope, RowType extends Record<string, S
   topLevel: Expand<AvailableScope['topLevel'] & RowType>;
   namespaces: AvailableScope['namespaces'];
 };
-type DeriveExtFunctions<OT extends QueryOperationTypesBase> = { [K in keyof OT]: OT[K]['impl']; };
-type BuiltinFunctions<CT extends Record<string, {
-  readonly input: unknown;
-}>> = {
-  eq: <CodecId extends string>(a: CodecExpression<CodecId, boolean, CT> | null, b: CodecExpression<CodecId, boolean, CT> | null) => Expression<BooleanCodecType>;
-  ne: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT> | null, b: CodecExpression<CodecId, N, CT> | null) => Expression<BooleanCodecType>;
-  gt: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT>, b: CodecExpression<CodecId, N, CT>) => Expression<BooleanCodecType>;
-  gte: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT>, b: CodecExpression<CodecId, N, CT>) => Expression<BooleanCodecType>;
-  lt: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT>, b: CodecExpression<CodecId, N, CT>) => Expression<BooleanCodecType>;
-  lte: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT>, b: CodecExpression<CodecId, N, CT>) => Expression<BooleanCodecType>;
-  and: (...ands: CodecExpression<'pg/bool@1', boolean, CT>[]) => Expression<BooleanCodecType>;
-  or: (...ors: CodecExpression<'pg/bool@1', boolean, CT>[]) => Expression<BooleanCodecType>;
-  exists: (subquery: Subquery<Record<string, ScopeField>>) => Expression<BooleanCodecType>;
-  notExists: (subquery: Subquery<Record<string, ScopeField>>) => Expression<BooleanCodecType>;
-  in: {
-    <CodecId extends string>(expr: Expression<{
-      codecId: CodecId;
-      nullable: boolean;
-    }>, subquery: Subquery<Record<string, {
-      codecId: CodecId;
-      nullable: boolean;
-    }>>): Expression<BooleanCodecType>;
-    <CodecId extends string>(expr: Expression<{
-      codecId: CodecId;
-      nullable: boolean;
-    }>, values: Array<CodecExpression<CodecId, boolean, CT>>): Expression<BooleanCodecType>;
-  };
-  notIn: {
-    <CodecId extends string>(expr: Expression<{
-      codecId: CodecId;
-      nullable: boolean;
-    }>, subquery: Subquery<Record<string, {
-      codecId: CodecId;
-      nullable: boolean;
-    }>>): Expression<BooleanCodecType>;
-    <CodecId extends string>(expr: Expression<{
-      codecId: CodecId;
-      nullable: boolean;
-    }>, values: Array<CodecExpression<CodecId, boolean, CT>>): Expression<BooleanCodecType>;
-  };
-  readonly raw: RawSqlTag;
-};
-type Functions<QC extends QueryContext> = BuiltinFunctions<QC['codecTypes']> & DeriveExtFunctions<QC['queryOperationTypes']>;
 /**
  * The field an aggregate produces, read from the contract's emitted aggregate map.
  *
@@ -214,6 +157,58 @@ type ResolveRow<Row extends Record<string, ScopeField>, CodecTypes extends Recor
   readonly output: unknown;
 }>, PreResolved extends Record<string, unknown> = Record<string, never>> = Expand<{ -readonly [K in keyof Row]: string extends keyof PreResolved ? ResolveField<Row[K], CodecTypes> : K extends keyof PreResolved ? ApplyNullable<NonNullable<PreResolved[K & keyof PreResolved]>, Row[K]> : ResolveField<Row[K], CodecTypes>; }>;
 //#endregion
+//#region src/types/index-reference.d.ts
+/**
+ * A table's indexes, keyed by the name the contract source gave each: the `name:` prefix, or the `map:` name. An unnamed index, such as a derived foreign-key backing index, appears under its default prefix. A name that more than one index shares is left out, as reading it is refused at runtime.
+ */
+type IndexReferences<C extends TableProxyContract, NsId extends string, Name extends string> = TableIndexReferences<NamespaceTable<C, NsId, Name>>;
+//#endregion
+//#region src/types/mutation-query.d.ts
+type ReturningCapability = {
+  sql: {
+    returning: true;
+  };
+};
+type ColumnValues<Table extends StorageTable, CT extends Record<string, {
+  readonly input: unknown;
+}>> = { [K in keyof Table['columns']]: Table['columns'][K]['codecId'] extends keyof CT ? CT[Table['columns'][K]['codecId']]['input'] : unknown; };
+type UpdateValues<Table extends StorageTable, CT extends Record<string, {
+  readonly input: unknown;
+}>> = Partial<ColumnValues<Table, CT>>;
+interface InsertQuery<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField>> {
+  /**
+   * Attach one or more write-typed annotations to this query plan.
+   * Annotations declare `applicableTo: ['write']` (or `['read', 'write']`)
+   * via `defineAnnotation`; read-only annotations fail to compile here.
+   * Annotations are merged into `plan.meta.annotations` at `.build()` time.
+   * Chainable in any position; multiple calls compose with last-write-wins
+   * on duplicate namespaces.
+   */
+  annotate<As extends readonly AnnotationValue<unknown, OperationKind>[]>(...annotations: As & ValidAnnotations<'write', As>): InsertQuery<QC, AvailableScope, RowType>;
+  returning: GatedMethod<QC['capabilities'], ReturningCapability, <Columns extends (keyof AvailableScope['topLevel'] & string)[]>(...columns: Columns) => InsertQuery<QC, AvailableScope, WithFields<EmptyRow, AvailableScope['topLevel'], Columns>>>;
+  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes'], QC['resolvedColumnOutputTypes']>>;
+}
+interface UpdateQuery<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField>> {
+  /**
+   * Attach one or more write-typed annotations to this query plan.
+   * See `InsertQuery.annotate` for semantics.
+   */
+  annotate<As extends readonly AnnotationValue<unknown, OperationKind>[]>(...annotations: As & ValidAnnotations<'write', As>): UpdateQuery<QC, AvailableScope, RowType>;
+  where(expr: ExpressionBuilder<AvailableScope, QC>): UpdateQuery<QC, AvailableScope, RowType>;
+  returning: GatedMethod<QC['capabilities'], ReturningCapability, <Columns extends (keyof AvailableScope['topLevel'] & string)[]>(...columns: Columns) => UpdateQuery<QC, AvailableScope, WithFields<EmptyRow, AvailableScope['topLevel'], Columns>>>;
+  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes'], QC['resolvedColumnOutputTypes']>>;
+}
+interface DeleteQuery<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField>> {
+  /**
+   * Attach one or more write-typed annotations to this query plan.
+   * See `InsertQuery.annotate` for semantics.
+   */
+  annotate<As extends readonly AnnotationValue<unknown, OperationKind>[]>(...annotations: As & ValidAnnotations<'write', As>): DeleteQuery<QC, AvailableScope, RowType>;
+  where(expr: ExpressionBuilder<AvailableScope, QC>): DeleteQuery<QC, AvailableScope, RowType>;
+  returning: GatedMethod<QC['capabilities'], ReturningCapability, <Columns extends (keyof AvailableScope['topLevel'] & string)[]>(...columns: Columns) => DeleteQuery<QC, AvailableScope, WithFields<EmptyRow, AvailableScope['topLevel'], Columns>>>;
+  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes'], QC['resolvedColumnOutputTypes']>>;
+}
+//#endregion
 //#region src/types/raw-query.d.ts
 /**
  * The output type a contract column reference carries, kept on a symbol key so
@@ -284,6 +279,18 @@ type SpecPreResolved<Spec extends ContractRawRowSpec<CT>, CT extends Record<stri
 type RawRowFor<Spec extends ContractRawRowSpec<CodecTypes>, CodecTypes extends Record<string, {
   readonly output: unknown;
 }>> = ResolveRow<SpecScopeFields<Spec, CodecTypes>, CodecTypes, SpecPreResolved<Spec, CodecTypes>>;
+/**
+ * What a row-spec'd statement publishes as `.returns`. Each declared key gets
+ * one column reference. The reference carries the codec id and nullability the
+ * entry stated, plus the type the row resolves for that key.
+ *
+ * A column reference keeps nullability in its own field rather than in the
+ * type it carries. These references do the same, so a ref fed back into a row
+ * spec resolves the type it came from, whichever form the inner entry took.
+ */
+type ContractRawRefs<Spec extends ContractRawRowSpec<CodecTypes>, CodecTypes extends Record<string, {
+  readonly output: unknown;
+}>> = { readonly [K in keyof Spec]: ContractColumnRef<EntryScopeField<Spec[K]>['codecId'], EntryScopeField<Spec[K]>['nullable'], NonNullable<RawRowFor<Spec, CodecTypes>[K]>>; };
 /**
  * A raw template bound to the contract: the same builder the target-agnostic
  * surface returns, with terminators that resolve their row type from the spec.
@@ -309,58 +316,28 @@ interface ContractRawBuilder<CodecTypes extends Record<string, {
     codecId: S;
     nullable: N;
   }>;
-  returnsRow<Spec extends ContractRawRowSpec<CodecTypes>>(spec: Spec): RawRowQuery<RawRowFor<Spec, CodecTypes>>;
+  returnsRow<Spec extends ContractRawRowSpec<CodecTypes>>(spec: Spec): RawRowQuery<RawRowFor<Spec, CodecTypes>, ContractRawRefs<Spec, CodecTypes>>;
   affectedCount(): RawAffectedCountQuery;
 }
-/** The contract-bound raw tag, as `db.raw` exposes it. */
+/** The contract-bound raw tag, as `db.raw.sql` exposes it. */
 type ContractRawTag<CodecTypes extends Record<string, {
   readonly output: unknown;
 }>> = (strings: TemplateStringsArray, ...values: RawSqlInterpolation[]) => ContractRawBuilder<CodecTypes>;
 /** The raw tag for a contract, with its codec-type map already applied. */
 type RawTagFor<C extends TableProxyContract> = ContractRawTag<ExtractCodecTypes<C>>;
-//#endregion
-//#region src/types/mutation-query.d.ts
-type ReturningCapability = {
-  sql: {
-    returning: true;
-  };
+/**
+ * The raw lane, addressed as `db.raw`. It holds the whole-query statement tag
+ * under `sql`.
+ *
+ * Editors key their SQL highlighting on that name, and a raw plan's
+ * `lane: 'raw'` already uses it.
+ *
+ * The lane is one key wide on purpose. Anything else raw authoring needs can
+ * join it later, without moving the address again.
+ */
+type RawLane<C extends TableProxyContract> = {
+  readonly sql: RawTagFor<C>;
 };
-type InsertValues<Table extends StorageTable, CT extends Record<string, {
-  readonly input: unknown;
-}>> = { [K in keyof Table['columns']]?: Table['columns'][K]['codecId'] extends keyof CT ? CT[Table['columns'][K]['codecId']]['input'] : unknown; };
-interface InsertQuery<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField>> {
-  /**
-   * Attach one or more write-typed annotations to this query plan.
-   * Annotations declare `applicableTo: ['write']` (or `['read', 'write']`)
-   * via `defineAnnotation`; read-only annotations fail to compile here.
-   * Annotations are merged into `plan.meta.annotations` at `.build()` time.
-   * Chainable in any position; multiple calls compose with last-write-wins
-   * on duplicate namespaces.
-   */
-  annotate<As extends readonly AnnotationValue<unknown, OperationKind>[]>(...annotations: As & ValidAnnotations<'write', As>): InsertQuery<QC, AvailableScope, RowType>;
-  returning: GatedMethod<QC['capabilities'], ReturningCapability, <Columns extends (keyof AvailableScope['topLevel'] & string)[]>(...columns: Columns) => InsertQuery<QC, AvailableScope, WithFields<EmptyRow, AvailableScope['topLevel'], Columns>>>;
-  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes'], QC['resolvedColumnOutputTypes']>>;
-}
-interface UpdateQuery<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField>> {
-  /**
-   * Attach one or more write-typed annotations to this query plan.
-   * See `InsertQuery.annotate` for semantics.
-   */
-  annotate<As extends readonly AnnotationValue<unknown, OperationKind>[]>(...annotations: As & ValidAnnotations<'write', As>): UpdateQuery<QC, AvailableScope, RowType>;
-  where(expr: ExpressionBuilder<AvailableScope, QC>): UpdateQuery<QC, AvailableScope, RowType>;
-  returning: GatedMethod<QC['capabilities'], ReturningCapability, <Columns extends (keyof AvailableScope['topLevel'] & string)[]>(...columns: Columns) => UpdateQuery<QC, AvailableScope, WithFields<EmptyRow, AvailableScope['topLevel'], Columns>>>;
-  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes'], QC['resolvedColumnOutputTypes']>>;
-}
-interface DeleteQuery<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField>> {
-  /**
-   * Attach one or more write-typed annotations to this query plan.
-   * See `InsertQuery.annotate` for semantics.
-   */
-  annotate<As extends readonly AnnotationValue<unknown, OperationKind>[]>(...annotations: As & ValidAnnotations<'write', As>): DeleteQuery<QC, AvailableScope, RowType>;
-  where(expr: ExpressionBuilder<AvailableScope, QC>): DeleteQuery<QC, AvailableScope, RowType>;
-  returning: GatedMethod<QC['capabilities'], ReturningCapability, <Columns extends (keyof AvailableScope['topLevel'] & string)[]>(...columns: Columns) => DeleteQuery<QC, AvailableScope, WithFields<EmptyRow, AvailableScope['topLevel'], Columns>>>;
-  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes'], QC['resolvedColumnOutputTypes']>>;
-}
 //#endregion
 //#region src/types/joined-tables.d.ts
 interface JoinedTables<QC extends QueryContext, AvailableScope extends Scope> extends WithSelect<QC, AvailableScope, EmptyRow>, WithJoin<QC, AvailableScope, QC['capabilities']> {}
@@ -415,6 +392,14 @@ interface SelectQuery<QC extends QueryContext, AvailableScope extends Scope, Row
     (...fields: ((keyof RowType | keyof AvailableScope['topLevel']) & string)[]): SelectQuery<QC, AvailableScope, RowType>;
     (expr: (fields: FieldProxy<OrderByScope<AvailableScope, RowType>>, fns: Functions<QC>) => Expression<ScopeField>): SelectQuery<QC, AvailableScope, RowType>;
   }>;
+  /** Renders `FOR UPDATE`; the lock lasts until the enclosing transaction ends. */
+  forUpdate: GatedMethod<QC['capabilities'], LockStrengthCapabilities['forUpdate'], (options?: LockOptions<QC, AvailableScope>) => SelectQuery<QC, AvailableScope, RowType>>;
+  /** Renders `FOR NO KEY UPDATE`; unlike `forUpdate`, it does not block foreign-key checks on the row. */
+  forNoKeyUpdate: GatedMethod<QC['capabilities'], LockStrengthCapabilities['forNoKeyUpdate'], (options?: LockOptions<QC, AvailableScope>) => SelectQuery<QC, AvailableScope, RowType>>;
+  /** Renders `FOR SHARE`. */
+  forShare: GatedMethod<QC['capabilities'], LockStrengthCapabilities['forShare'], (options?: LockOptions<QC, AvailableScope>) => SelectQuery<QC, AvailableScope, RowType>>;
+  /** Renders `FOR KEY SHARE`. */
+  forKeyShare: GatedMethod<QC['capabilities'], LockStrengthCapabilities['forKeyShare'], (options?: LockOptions<QC, AvailableScope>) => SelectQuery<QC, AvailableScope, RowType>>;
 }
 //#endregion
 //#region src/types/shared.d.ts
@@ -449,6 +434,13 @@ interface WithJoin<QC extends QueryContext, AvailableScope extends Scope, Capabi
   }>>>>;
 }
 type PaginationValue<QC extends QueryContext> = number | TraitExpression<readonly ['numeric'], false, QC['codecTypes']>;
+type LockOf<QC extends QueryContext, S extends Scope> = QC['capabilities'] extends LockOptionCapabilities['of'] ? {
+  readonly of?: ReadonlyArray<keyof S['namespaces'] & string>;
+} : {
+  readonly of?: never;
+};
+/** Options for the row-locking methods; each key exists only when the adapter reports its capability. */
+type LockOptions<QC extends QueryContext, S extends Scope> = LockOf<QC, S> & LockWaitOptions<QC['capabilities']>;
 interface WithPagination<QC extends QueryContext> {
   limit(count: PaginationValue<QC>): this;
   offset(count: PaginationValue<QC>): this;
@@ -465,12 +457,14 @@ interface WithBuild<QC extends QueryContext, RowType extends Record<string, Scop
 //#endregion
 //#region src/types/table-proxy.d.ts
 type ResolvedColumnTypes<C extends TableProxyContract, NsId extends string, TableName extends string, ColMap = StorageColumnMapAt<ExtractStorageColumnTypes<C>, NsId, TableName>, ColumnKeys extends string = [ColMap] extends [never] ? never : keyof ColMap & string> = { readonly [K in ColumnKeys]: ColMap extends Record<K, unknown> ? ColMap[K] : never; };
+type IsOptionalInsertColumn<C extends TableProxyContract, NsId extends string, Table extends StorageTable, TableName extends string, K> = IsOptionalCreateColumn<C, K extends keyof Table['columns'] ? Table['columns'][K] : never, NsId, TableName, K & string>;
+type InsertRow<C extends TableProxyContract, NsId extends string, Table extends StorageTable, TableName extends string, Values> = { [K in keyof Values as IsOptionalInsertColumn<C, NsId, Table, TableName, K> extends true ? never : K]: Values[K]; } & { [K in keyof Values as IsOptionalInsertColumn<C, NsId, Table, TableName, K> extends true ? K : never]?: Values[K]; } extends (infer Row) ? { [K in keyof Row]: Row[K]; } : never;
 type ResolvedInsertValues<C extends TableProxyContract, NsId extends string, Table extends StorageTable, TableName extends string, CT extends Record<string, {
   readonly input: unknown;
-}>> = StorageColumnMapAt<ExtractStorageColumnInputTypes<C>, NsId, TableName> extends (infer ColMap) ? [ColMap] extends [never] ? InsertValues<Table, CT> : { [K in keyof ColMap]?: ColMap[K]; } : InsertValues<Table, CT>;
+}>> = StorageColumnMapAt<ExtractStorageColumnInputTypes<C>, NsId, TableName> extends (infer ColMap) ? [ColMap] extends [never] ? InsertRow<C, NsId, Table, TableName, ColumnValues<Table, CT>> : InsertRow<C, NsId, Table, TableName, ColMap> : never;
 type ResolvedUpdateValues<C extends TableProxyContract, NsId extends string, Table extends StorageTable, TableName extends string, CT extends Record<string, {
   readonly input: unknown;
-}>> = ResolvedInsertValues<C, NsId, Table, TableName, CT>;
+}>> = StorageColumnMapAt<ExtractStorageColumnInputTypes<C>, NsId, TableName> extends (infer ColMap) ? [ColMap] extends [never] ? UpdateValues<Table, CT> : { [K in keyof ColMap]?: ColMap[K]; } : UpdateValues<Table, CT>;
 type ResolvedUpdateExpressions<Table extends StorageTable> = { [K in keyof Table['columns']]?: Expression<{
   codecId: Table['columns'][K]['codecId'];
   nullable: boolean;
@@ -492,9 +486,12 @@ type ContractToQC<C extends TableProxyContract, NsId extends string = string, Na
   readonly resolvedColumnOutputTypes: ResolvedColumnTypes<C, NsId, Name>;
   readonly aggregateTypes: ExtractAggregateTypes<C>;
 };
+type WhereFilter<C extends TableProxyContract, NsId extends keyof C['storage']['namespaces'] & string, Name extends TableNamesInNamespace<C, NsId>> = ExpressionBuilder<DefaultScope<Name, NamespaceTable<C, NsId, Name>>, ContractToQC<C, NsId, Name>>;
 interface TableProxy<C extends TableProxyContract, NsId extends string, Name extends string, Alias extends string = Name, AvailableScope extends Scope = DefaultScope<Name, NamespaceTable<C, NsId, Name>>, QC extends QueryContext = ContractToQC<C, NsId, Name>> extends JoinSource<StorageTableToScopeTable<NamespaceTable<C, NsId, Name>>, Alias>, WithSelect<QC, AvailableScope, EmptyRow>, WithJoin<QC, AvailableScope, C['capabilities']> {
   /** The table's columns, for naming in a raw statement's row spec. */
   readonly columns: ColumnRefs<C, NsId, Name>;
+  /** The table's indexes, keyed by the name the contract source gave each, with their columns bound to this table's alias. */
+  readonly indexes: IndexReferences<C, NsId, Name>;
   as<NewAlias extends string>(newAlias: NewAlias): TableProxy<C, NsId, Name, NewAlias, RebindScope<AvailableScope, Alias, NewAlias>, QC>;
   insert(rows: ReadonlyArray<ResolvedInsertValues<C, NsId, NamespaceTable<C, NsId, Name>, Name, QC['codecTypes']>>): InsertQuery<QC, AvailableScope, EmptyRow>;
   update(set: ResolvedUpdateValues<C, NsId, NamespaceTable<C, NsId, Name>, Name, QC['codecTypes']>): UpdateQuery<QC, AvailableScope, EmptyRow>;
@@ -523,22 +520,20 @@ type TablesInNamespace<NS extends {
   readonly entries: NamespaceEntries;
 }> = NS['entries']['table'] extends Readonly<Record<string, StorageTable>> ? NS['entries']['table'] : Readonly<Record<string, StorageTable>>;
 type UnboundTables<C extends TableProxyContract> = { readonly [Name in TableNamesAcrossNamespaces<C>]: TableInAnyNamespace<C, Name>; };
+type TableNamesInNamespace<C extends TableProxyContract, NsId extends keyof C['storage']['namespaces']> = keyof TablesInNamespace<C['storage']['namespaces'][NsId]> & string;
 type TableNamesAcrossNamespaces<C extends TableProxyContract> = { [NSId in keyof C['storage']['namespaces']]: keyof TablesInNamespace<C['storage']['namespaces'][NSId]> & string; }[keyof C['storage']['namespaces']];
 type TableInAnyNamespace<C extends TableProxyContract, Name extends string> = { [NSId in keyof C['storage']['namespaces']]: Name extends keyof TablesInNamespace<C['storage']['namespaces'][NSId]> ? TablesInNamespace<C['storage']['namespaces'][NSId]>[Name] : never; }[keyof C['storage']['namespaces']];
 type NamespaceTable<C extends TableProxyContract, NsId extends string, Name extends string> = TablesInNamespace<C['storage']['namespaces'][NsId]>[Name];
 type Namespace<C extends TableProxyContract, NsId extends string & keyof C['storage']['namespaces']> = { readonly [Name in keyof TablesInNamespace<C['storage']['namespaces'][NsId]> & string]: TableProxy<C, NsId, Name>; };
 /**
- * The contract-bound SQL surface: one facet per storage namespace, plus the
- * raw tag for statements the builders do not express.
+ * The contract-bound SQL surface: one facet per storage namespace, and nothing
+ * else.
  *
- * `raw` sits beside the namespace facets because a whole-query raw statement
- * is a peer of the table proxies, not something reached through one — it names
- * its own tables. The tag binds the adapter's codec inferer and the contract
- * once, here, so an authoring site carries only its template and row spec.
+ * A namespace may be named anything the database allows, `raw` included. The
+ * client carries whole-query raw statements on its own lane, `db.raw.sql`.
+ * This map does not reach that lane.
  */
-type Db<C extends TableProxyContract> = { readonly [Ns in keyof C['storage']['namespaces'] & string]: Namespace<C, Ns>; } & {
-  readonly raw: RawTagFor<C>;
-};
+type Db<C extends TableProxyContract> = { readonly [Ns in keyof C['storage']['namespaces'] & string]: Namespace<C, Ns>; };
 //#endregion
-export { TableNamesAcrossNamespaces as _, FieldProxy as a, UnboundTables as b, GroupedQuery as c, QueryContext as d, ResolveRow as f, TableInAnyNamespace as g, Subquery as h, DeleteQuery as i, InsertQuery as l, SelectQuery as m, BooleanCodecType as n, Functions as o, Scope as p, Db as r, GatedMethod as s, AggregateFunctions as t, Namespace as u, TableProxy as v, UpdateQuery as x, TableProxyContract as y };
-//# sourceMappingURL=db-D18PrXKW-DvTv4JFn.d.mts.map
+export { WhereFilter as C, UpdateQuery as S, TableInAnyNamespace as _, FieldProxy as a, TableProxyContract as b, IndexReferences as c, QueryContext as d, RawLane as f, SelectQuery as g, Scope as h, DeleteQuery as i, InsertQuery as l, ResolveRow as m, ContractRawTag as n, GatedMethod as o, RawTagFor as p, Db as r, GroupedQuery as s, AggregateFunctions as t, Namespace as u, TableNamesAcrossNamespaces as v, UnboundTables as x, TableProxy as y };
+//# sourceMappingURL=db-D1d75IvM-D4mRDC6w.d.mts.map

package/dist/db-D1d75IvM-D4mRDC6w.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-D1d75IvM-D4mRDC6w.d.mts","names":[],"sources":["../../../../2-sql-family/4-lanes/sql-builder/dist/db-D1d75IvM.d.mts"],"mappings":"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"}

package/dist/{ddl-types-CXx4vPz6-BsgrnSUY.d.mts → ddl-types-By5mT2_S-CdaaFvsX.d.mts}

@@ -1,41 +1,36 @@
-import { a as ReferentialAction } from "./foreign-key-C-iTPuRT-C9ip8zFx.mjs";
-import "./types-UcHa2cTe.mjs";
-import { T as CodecRef$1, p as AnyParamRef } from "./types-v3qxLLxo-DCeKv7yY.mjs";
+import { o as ReferentialAction } from "./foreign-key-qkDFfG8t-TaK_GYWR.mjs";
+import "./types-CkAd8SWm.mjs";
+import { E as CodecRef$1, m as AnyParamRef } from "./types-DriMIMNQ-BkbsW7w3.mjs";
 import { ColumnDefaultLiteralInputValue } from "@prisma/orm-framework/contract/types";
-//#region ../../../2-sql/4-lanes/relational-core/dist/ddl-types-CXx4vPz6.d.mts
-//#region src/ast/ddl-types.d.ts
+//#region ../../../2-sql-family/4-lanes/relational-core/dist/ddl-types-By5mT2_S.d.mts
+//#region src/ast/opaque-sql.d.ts
 /**
- * Render-time context the column-default visitor needs to make dialect
- * decisions that depend on the parent column. Today only the parent
- * column's native type (`"jsonb"`, `"text"`, …) — the Postgres renderer
- * uses it to decide whether to emit a `::jsonb` / `::json` cast on JSON
- * literal defaults so the emitted DDL matches the column type without
- * relying on Postgres's implicit text → jsonb cast at default-evaluation
- * time. Additional fields can join without re-shaping the interface.
+ * SQL text that Prisma does not parse, placed inside a larger statement: a CHECK or policy predicate, an index element list or predicate, a column default, or an ALTER COLUMN TYPE conversion. ADR 244 calls such text opaque.
  */
-interface DdlColumnRenderContext {
-  readonly nativeType: string;
-}
-interface DdlColumnDefaultVisitor<R> {
-  literal(node: LiteralColumnDefault, ctx: DdlColumnRenderContext): R;
-  function(node: FunctionColumnDefault, ctx: DdlColumnRenderContext): R;
+declare class OpaqueSql {
+  readonly text: string;
+  constructor(text: string);
 }
+declare function opaqueSql(text: string): OpaqueSql;
+/**
+ * The text as a statement includes it. Text containing `--` ends with a line break, so a line comment on its last line cannot hide what the statement writes after it.
+ */
+declare function renderOpaqueSql(sql: OpaqueSql): string;
+//#endregion
+//#region src/ast/ddl-types.d.ts
 declare abstract class DdlColumnDefault {
   abstract readonly kind: string;
-  abstract accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R;
   protected freeze(): void;
 }
 declare class LiteralColumnDefault extends DdlColumnDefault {
   readonly kind: "literal";
   readonly value: ColumnDefaultLiteralInputValue;
   constructor(value: ColumnDefaultLiteralInputValue);
-  accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R;
 }
 declare class FunctionColumnDefault extends DdlColumnDefault {
   readonly kind: "function";
-  readonly expression: string;
-  constructor(expression: string);
-  accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R;
+  readonly expression: OpaqueSql;
+  constructor(expression: OpaqueSql);
 }
 type AnyDdlColumnDefault = LiteralColumnDefault | FunctionColumnDefault;
 declare class DdlColumn {
@@ -44,7 +39,7 @@ declare class DdlColumn {
   readonly notNull?: boolean | undefined;
   readonly primaryKey?: boolean | undefined;
   readonly default?: AnyDdlColumnDefault | undefined;
-  /** Codec identity for this column. When present, the DDL walker resolves the codec via `codecLookup.get(codecRef.codecId)` and runs the literal default through both declared conversions in order — `codec.encode(codec.decodeJson(default.value), {})` — to obtain the wire value it inlines into the DDL string. The read-back is what makes the pair sound: a contract stores a literal default in the codec's canonical JSON, which is not always the application value `encode` takes (`pg/int8@1` stores decimal text for a `bigint`). A `Date` is the one authored value JSON has no notation for, so it arrives as itself and skips `decodeJson`. When absent, literal defaults follow RawSqlLiteral wire-scalar semantics (string / number / boolean / bigint / null / Uint8Array / Date inlined directly). */
+  /** Codec identity for this column. When present, the DDL walker builds the codec with the column's type parameters and runs the literal default through both declared conversions in order — `codec.toWire(codec.fromDataTypeValue(dataType.fromContract(default.value, params)), {})` — to obtain the wire value it inlines into the DDL string (`encodeLiteralDefault`), and reads each element of a list default the same way (`encodeListLiteralDefault`). The read-back is what makes the pair sound: a contract stores a literal default as its data type's stored JSON, which is not always the application value `toWire` takes (`pg/int8@1` stores decimal text for a `bigint`). A `Date` is the one authored value JSON has no notation for, so it arrives as itself, and the codec reads it with `toDataTypeValue` before `fromDataTypeValue` and `toWire`, so the column's type checks it. A `null` default the type refuses is SQL NULL, `DEFAULT NULL`; a JSON type reads it as the JSON value null. When absent, literal defaults follow RawSqlLiteral wire-scalar semantics (string / number / boolean / bigint / null / Uint8Array / Date inlined directly). */
   readonly codecRef?: CodecRef$1 | undefined;
   constructor(options: {
     readonly name: string;
@@ -128,7 +123,7 @@ declare class UniqueConstraint {
  * A table-level CHECK constraint carrying a raw SQL predicate expression. Used
  * for checks that are not enum value-set restrictions — e.g. the element-non-null
  * constraint on a scalar-array column (`array_position(col, NULL) IS NULL`).
- * The `expression` is emitted verbatim, so callers must supply safe,
+ * The `expression` is emitted through `renderOpaqueSql`, so callers must supply safe,
  * pre-validated SQL.
  *
  * Frozen on construction — immutable after creation.
@@ -136,13 +131,13 @@ declare class UniqueConstraint {
 declare class CheckExpressionConstraint {
   readonly kind: "check-expression";
   readonly name: string;
-  readonly expression: string;
+  readonly expression: OpaqueSql;
   constructor(options: {
     readonly name: string;
-    readonly expression: string;
+    readonly expression: OpaqueSql;
   });
 }
 type DdlTableConstraint = PrimaryKeyConstraint | ForeignKeyConstraint | UniqueConstraint | CheckExpressionConstraint;
 //#endregion
-export { DdlColumnDefaultVisitor as a, DdlTableConstraint as c, LiteralColumnDefault as d, PrimaryKeyConstraint as f, DdlColumnDefault as i, ForeignKeyConstraint as l, isDdlNode as m, CheckExpressionConstraint as n, DdlColumnRenderContext as o, UniqueConstraint as p, DdlColumn as r, DdlNode as s, AnyDdlColumnDefault as t, FunctionColumnDefault as u };
-//# sourceMappingURL=ddl-types-CXx4vPz6-BsgrnSUY.d.mts.map
+export { DdlNode as a, FunctionColumnDefault as c, PrimaryKeyConstraint as d, UniqueConstraint as f, renderOpaqueSql as h, DdlColumnDefault as i, LiteralColumnDefault as l, opaqueSql as m, CheckExpressionConstraint as n, DdlTableConstraint as o, isDdlNode as p, DdlColumn as r, ForeignKeyConstraint as s, AnyDdlColumnDefault as t, OpaqueSql as u };
+//# sourceMappingURL=ddl-types-By5mT2_S-CdaaFvsX.d.mts.map

package/dist/ddl-types-By5mT2_S-CdaaFvsX.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ddl-types-By5mT2_S-CdaaFvsX.d.mts","names":[],"sources":["../../../../2-sql-family/4-lanes/relational-core/dist/ddl-types-By5mT2_S.d.mts"],"mappings":";;;;;;;;;cAOc;WACH;EACT,YAAY;;iBAEG,UAAU,eAAe;;;;iBAIzB,gBAAgB,KAAK;;;uBAGf;oBACH;YACR;;cAEE,6BAA6B;WAChC;WACA,OAAO;EAChB,YAAY,OAAO;;cAEP,8BAA8B;WACjC;WACA,YAAY;EACrB,YAAY,YAAY;;KAErB,sBAAsB,uBAAuB;cACpC;WACH;WACA;WACA;WACA;WACA,UAAU;;WAEV,WAAW;EACpB,YAAY;aACD;aACA;aACA;aACA;aACA,UAAU;aACV,WAAW;;;uBAGD;oBACH;;;;;;;EAOlB;YACU;EACV,oBAAoB;;iBAEL,UAAU,iBAAiB,SAAS;;;;;;;;cAQvC;WACH;WACA,SAAS;WACT;EACT,YAAY;aACD;aACA;;;;;;;;;;cAUC;WACH;WACA,SAAS;WACT;WACA,YAAY;WACZ,UAAU;WACV,UAAU;WACV;EACT,YAAY;aACD;aACA;aACA;aACA,WAAW;aACX,WAAW;aACX;;;;;;;;;;cAUC;WACH;WACA,SAAS;WACT;EACT,YAAY;aACD;aACA;;;;;;;;;;;;cAYC;WACH;WACA;WACA,YAAY;EACrB,YAAY;aACD;aACA,YAAY;;;KAGpB,qBAAqB,uBAAuB,uBAAuB,mBAAmB"}

package/dist/default-mapping-CAOONlKQ-4m07nb-O.d.mts

@@ -0,0 +1,39 @@
+import { DataTypeSupport } from "@prisma/orm-framework/components/authoring";
+import { CodecDescriptor, DataTypeId } from "@prisma/orm-framework/components/codec";
+import { ColumnDefault, ColumnDefaultLiteralInputValue, JsonValue } from "@prisma/orm-framework/contract/types";
+//#region ../../../2-sql-family/9-family/dist/default-mapping-CAOONlKQ.d.mts
+//#region src/core/psl-build/default-mapping.d.ts
+interface DefaultMappingOptions {
+  readonly functionAttributes?: Readonly<Record<string, string>>;
+  /** The stack's data types, whose casts say which other types' values each one takes, with the authoring entries that write them. */
+  readonly dataTypes?: DataTypeSupport | undefined;
+  /** The column's codec, whose data type a default is written in. */
+  readonly columnCodec?: Pick<CodecDescriptor, 'dataType'> | undefined;
+  /** The column's type parameters, under which a shorter literal can read back as the stored value, as `-0.5` does on `numeric(65,30)`. */
+  readonly typeParams?: unknown;
+  /**
+   * Whether the column is a list, whose elements each carry the column's own data type. A written
+   * list on a scalar column goes through that type's list cast instead.
+   */
+  readonly list?: boolean;
+}
+type DefaultMappingResult = {
+  readonly attribute: string;
+};
+/**
+ * The attribute a stored default prints as: a named function, a literal the column takes, or any
+ * other expression as a `sql` literal. `undefined` when a literal has no written form. An expression
+ * prints even when the literal would read back as different text: default expressions are compared
+ * with case and whitespace ignored (`SqlColumnDefaultIR.isEqualTo`), and canonicalization changes only
+ * whitespace (ADR 129).
+ */
+declare function mapDefault(columnDefault: ColumnDefault, options?: DefaultMappingOptions): DefaultMappingResult | undefined;
+/**
+ * `value`, a value of `dataType` as `contract.json` stores it, written as the literal of a type that `dataType` takes, proven to read back as `value`: `255` for `pg/int4`, ``sql`"MyType"[]` `` for `sql/expression`. `undefined` when no literal reads back as it.
+ */
+declare function writeDataTypeValue(value: JsonValue, dataType: DataTypeId, support: DataTypeSupport): string | undefined;
+/** The PSL literal a stored value is written as for the column `options` describe, or `undefined` when it has no written form that reads back as that value. */
+declare function writeDefaultLiteral(value: ColumnDefaultLiteralInputValue, options: DefaultMappingOptions | undefined): string | undefined;
+//#endregion
+export { writeDefaultLiteral as a, writeDataTypeValue as i, DefaultMappingResult as n, mapDefault as r, DefaultMappingOptions as t };
+//# sourceMappingURL=default-mapping-CAOONlKQ-4m07nb-O.d.mts.map

package/dist/default-mapping-CAOONlKQ-4m07nb-O.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-mapping-CAOONlKQ-4m07nb-O.d.mts","names":[],"sources":["../../../../2-sql-family/9-family/dist/default-mapping-CAOONlKQ.d.mts"],"mappings":";;;;;UAIU;WACC,qBAAqB,SAAS;;WAE9B,YAAY;;WAEZ,cAAc,KAAK;;WAEnB;;;;;WAKA;;KAEN;WACM;;;;;;;;;iBASM,WAAW,eAAe,eAAe,UAAU,wBAAwB;;;;iBAI3E,mBAAmB,OAAO,WAAW,UAAU,YAAY,SAAS;;iBAEpE,oBAAoB,OAAO,gCAAgC,SAAS"}

package/dist/default-table-name-BfFY8qYR-CWZFDX6v.mjs

@@ -0,0 +1,9 @@
+//#region ../../../2-sql-family/2-authoring/contract-psl/dist/default-table-name-BfFY8qYR.mjs
+/** Storage table name of a model that declares no `@@map`: the model name, verbatim. */
+function defaultTableName(modelName) {
+	return modelName;
+}
+//#endregion
+export { defaultTableName as t };
+
+//# sourceMappingURL=default-table-name-BfFY8qYR-CWZFDX6v.mjs.map

package/dist/default-table-name-BfFY8qYR-CWZFDX6v.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-table-name-BfFY8qYR-CWZFDX6v.mjs","names":[],"sources":["../../../../2-sql-family/2-authoring/contract-psl/dist/default-table-name-BfFY8qYR.mjs"],"sourcesContent":["//#region src/default-table-name.ts\n/** Storage table name of a model that declares no `@@map`: the model name, verbatim. */\nfunction defaultTableName(modelName) {\n\treturn modelName;\n}\n//#endregion\nexport { defaultTableName as t };\n\n//# sourceMappingURL=default-table-name-BfFY8qYR.mjs.map"],"mappings":";;AAEA,SAAS,iBAAiB,WAAW;CACpC,OAAO;AACR"}