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

package/dist/ast-YEMe_B8z.d.mts

@@ -0,0 +1,292 @@
+import { Dt as ProjectionItem, E as CodecRef$1, ft as LockWaitPolicy, gt as LoweredStatement, h as AnyQueryAst, m as AnyParamRef } from "./types-DriMIMNQ-BkbsW7w3.mjs";
+import { c as SqlQueryable } from "./driver-types-DRsYeq3j-BimeCnUk.mjs";
+import "./ddl-types-By5mT2_S-CdaaFvsX.mjs";
+import { StructuredError } from "@prisma/orm-framework/utils/structured-error";
+import { CodecCallContext, CodecDescriptorTemplateImpl, CodecImpl, CodecInstanceContext, CodecLookupWithDescriptors, DataTypeValue } from "@prisma/orm-framework/components/codec";
+import { ColumnDefaultLiteralInputValue, ContractMarkerRecord, JsonValue } from "@prisma/orm-framework/contract/types";
+//#region ../../../2-sql-family/4-lanes/relational-core/dist/exports/ast.d.mts
+//#region src/ast/adapter-types.d.ts
+type AdapterTarget = string;
+/**
+ * Outcome of an adapter's marker read. `no-table` means the marker storage itself is absent
+ * (e.g. attaching to a database that was never `db init`'d); `absent` means the storage exists
+ * but holds no row for the requested space; `present` carries the parsed record. Callers
+ * distinguish these to produce appropriate log diagnostics for each case.
+ */
+type MarkerReadResult = {
+  readonly kind: 'present';
+  readonly record: ContractMarkerRecord;
+} | {
+  readonly kind: 'absent';
+} | {
+  readonly kind: 'no-table';
+};
+interface AdapterProfile<TTarget extends AdapterTarget = AdapterTarget> {
+  readonly id: string;
+  readonly target: TTarget;
+  readonly capabilities: Record<string, unknown>;
+  /**
+   * Reads the contract marker via the supplied queryable. The adapter owns the full flow — probing for the marker storage, issuing the read, and decoding the row — so callers receive a tagged result rather than a raw driver error when the marker storage is absent.
+   */
+  readMarker(queryable: SqlQueryable): Promise<MarkerReadResult>;
+}
+interface LowererContext<TContract = unknown> {
+  readonly contract: TContract;
+  readonly params?: readonly unknown[];
+}
+type Lowerer<Ast = unknown, TContract = unknown, TBody = LoweredStatement> = (ast: Ast, context: LowererContext<TContract>) => TBody;
+/**
+ * Lowers a query AST into a target-specific executable body (typically `LoweredStatement` for SQL adapters). The `lower` method returns the body directly; per-statement metadata, when needed, lives on the body itself (e.g. `LoweredStatement.annotations`). Adapter-level metadata such as the profile id is reachable via `profile.id` for callers that genuinely need it.
+ */
+interface Adapter<Ast = unknown, TContract = unknown, TBody = LoweredStatement> {
+  readonly profile: AdapterProfile;
+  lower(ast: Ast, context: LowererContext<TContract>): TBody;
+}
+//#endregion
+//#region src/ast/ddl-default.d.ts
+/** What a literal default renders as in DDL: SQL NULL, or the wire value the column's codec encoded. */
+type EncodedLiteralDefault = {
+  readonly kind: 'sql-null';
+} | {
+  readonly kind: 'wire';
+  readonly wire: unknown;
+};
+/** The column whose default is rendered, which a refusal names. */
+interface LiteralDefaultColumn {
+  readonly table: string;
+  readonly column: string;
+}
+/**
+ * Reads a column's literal default as a value of the column's data type, converts it with the column's codec, built with its type parameters, and writes it with `toWire` for the DDL renderer to inline. `undefined` when no codec descriptor has the column's codec id, so the renderer inlines the value as written.
+ *
+ * A `Date` is the one authored value JSON has no notation for, so the codec reads it into a value of the column's type with `toDataTypeValue`, and the Date it reads back from that value is encoded: the type and the codec check it as they check any other default. A `null` the type or codec refuses is SQL NULL, because SQL NULL has no stored form of its own; a type that stores `null` (a JSON type) makes it the JSON value null. Any other value either refuses is a `CONTRACT.DEFAULT_INVALID` naming the column.
+ */
+declare function encodeLiteralDefault(codecLookup: Pick<CodecLookupWithDescriptors, 'descriptorFor'>, codecRef: CodecRef$1, value: ColumnDefaultLiteralInputValue, where: LiteralDefaultColumn): Promise<EncodedLiteralDefault | undefined>;
+/**
+ * Reads and encodes each element of a list column's literal default with the column's codec, as {@link encodeLiteralDefault} does a single value, so a `null` element the codec refuses is SQL NULL. `undefined` when no codec descriptor has the column's codec id. An element the codec refuses is a `CONTRACT.DEFAULT_INVALID` naming the column and the element's 1-based position.
+ */
+declare function encodeListLiteralDefault(codecLookup: Pick<CodecLookupWithDescriptors, 'descriptorFor'>, codecRef: CodecRef$1, elements: readonly JsonValue[], where: LiteralDefaultColumn): Promise<readonly EncodedLiteralDefault[] | undefined>;
+//#endregion
+//#region src/ast/locking.d.ts
+/** What a row lock was combined with when it was refused, as `meta.conflict` of `ORM.LOCK_INCOMPATIBLE`. */
+type LockConflict = 'distinct' | 'distinctOn' | 'groupBy' | 'having' | 'aggregate' | 'subquery' | 'include' | 'includeRefinement' | 'mutation';
+/** The `ORM.LOCK_INCOMPATIBLE` error for a lock refused because of `conflict`. */
+declare function lockIncompatible(conflict: LockConflict, message: string): StructuredError;
+/** A capability requirement: each group's flags that must be reported as `true`. */
+type CapabilityRequirement = {
+  readonly [group: string]: {
+    readonly [flag: string]: true;
+  };
+};
+/** The capability each lock strength needs. */
+declare const lockStrengthCapabilities: {
+  readonly forUpdate: {
+    readonly sql: {
+      readonly forUpdate: true;
+    };
+  };
+  readonly forNoKeyUpdate: {
+    readonly postgres: {
+      readonly forNoKeyUpdate: true;
+    };
+  };
+  readonly forShare: {
+    readonly sql: {
+      readonly forShare: true;
+    };
+  };
+  readonly forKeyShare: {
+    readonly postgres: {
+      readonly forKeyShare: true;
+    };
+  };
+};
+/** The capability each locking option needs; the wait-policy keys equal the `LockWaitPolicy` values. */
+declare const lockOptionCapabilities: {
+  readonly of: {
+    readonly sql: {
+      readonly lockOf: true;
+    };
+  };
+  readonly nowait: {
+    readonly sql: {
+      readonly lockNowait: true;
+    };
+  };
+  readonly skipLocked: {
+    readonly sql: {
+      readonly lockSkipLocked: true;
+    };
+  };
+};
+type LockStrengthCapabilities = typeof lockStrengthCapabilities;
+type LockOptionCapabilities = typeof lockOptionCapabilities;
+/** The first flag in `requirement` that `capabilities` does not report as `true`, as `group.flag`. */
+declare function missingCapability(capabilities: {
+  readonly [group: string]: {
+    readonly [flag: string]: unknown;
+  } | undefined;
+}, requirement: CapabilityRequirement): string | undefined;
+/** The wait-policy options of a locking method; each key exists only when its capability is reported. */
+type LockWaitOptions<Capabilities> = (Capabilities extends LockOptionCapabilities['nowait'] ? {
+  readonly nowait?: true;
+  readonly skipLocked?: never;
+} : never) | (Capabilities extends LockOptionCapabilities['skipLocked'] ? {
+  readonly skipLocked?: true;
+  readonly nowait?: never;
+} : never) | {
+  readonly nowait?: never;
+  readonly skipLocked?: never;
+};
+/** The wait-policy options as a locking method receives them at run time. */
+interface LockWaitRequest {
+  readonly nowait?: true;
+  readonly skipLocked?: true;
+}
+/** Turns `{ nowait, skipLocked }` into a wait policy, refusing both together with `ORM.ARGUMENT_INVALID`. */
+declare function lockWaitPolicyOf(methodName: string, options: LockWaitRequest | undefined): LockWaitPolicy | undefined;
+//#endregion
+//#region src/ast/sql-codec-helpers.d.ts
+/**
+ * Shared encode/decode constants and codec id literals for the five SQL base codecs (`sql/char@1`, `sql/varchar@1`, `sql/int@1`, `sql/float@1`, `sql/text@1`).
+ *
+ * The codec implementations live in `sql-codecs.ts` (TML-2357). This module retains only the conversion helpers the codec methods compose with — keeping a single source of truth for non-trivial conversions while the codec methods provide the framework-required `Promise<…>` boundary.
+ */
+declare const SQL_CHAR_CODEC_ID: "sql/char@1";
+declare const SQL_VARCHAR_CODEC_ID: "sql/varchar@1";
+declare const SQL_INT_CODEC_ID: "sql/int@1";
+declare const SQL_FLOAT_CODEC_ID: "sql/float@1";
+declare const SQL_TEXT_CODEC_ID: "sql/text@1";
+declare const SQL_RAW_CODEC_ID: "sql/raw@1";
+declare const sqlCharEncode: (value: string) => string;
+/** A `character` value as the database returns it, without the spaces that pad it to its length. Only spaces pad it, so a trailing tab or newline is part of the value. */
+declare const sqlCharDecode: (wire: string) => string;
+declare const sqlVarcharEncode: (value: string) => string;
+declare const sqlVarcharDecode: (wire: string) => string;
+declare const sqlIntEncode: (value: number) => number;
+declare const sqlIntDecode: (wire: number) => number;
+declare const sqlFloatEncode: (value: number) => number;
+declare const sqlFloatDecode: (wire: number) => number;
+declare const sqlTextEncode: (value: string) => string;
+declare const sqlTextDecode: (wire: string) => string;
+//#endregion
+//#region src/ast/sql-codecs.d.ts
+type LengthParams = {
+  readonly length?: number;
+};
+declare class SqlTextCodec extends CodecImpl<typeof SQL_TEXT_CODEC_ID, readonly ['equality', 'order', 'textual'], string, string> {
+  toWire(value: string, _ctx: CodecCallContext): Promise<string>;
+  fromWire(wire: string, _ctx: CodecCallContext): Promise<string>;
+  fromDataTypeValue(value: DataTypeValue<string>): string;
+  toDataTypeValue(input: string): DataTypeValue;
+}
+declare class SqlTextDescriptor extends CodecDescriptorTemplateImpl<void> {
+  readonly codecId: "sql/text@1";
+  readonly traits: readonly ["equality", "order", "textual"];
+  readonly paramsSchema: undefined;
+  factory(): (ctx: CodecInstanceContext) => SqlTextCodec;
+}
+declare const sqlTextDescriptor: SqlTextDescriptor;
+declare const sqlTextColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<SqlTextCodec, undefined>;
+declare class SqlIntCodec extends CodecImpl<typeof SQL_INT_CODEC_ID, readonly ['equality', 'order', 'numeric'], number, number> {
+  toWire(value: number, _ctx: CodecCallContext): Promise<number>;
+  fromWire(wire: number, _ctx: CodecCallContext): Promise<number>;
+  /** A `number` holds an integer exactly only within the safe integer range. */
+  fromDataTypeValue(value: DataTypeValue): number;
+  toDataTypeValue(input: number): DataTypeValue;
+}
+declare class SqlIntDescriptor extends CodecDescriptorTemplateImpl<void> {
+  readonly codecId: "sql/int@1";
+  readonly traits: readonly ["equality", "order", "numeric"];
+  readonly paramsSchema: undefined;
+  factory(): (ctx: CodecInstanceContext) => SqlIntCodec;
+}
+declare const sqlIntDescriptor: SqlIntDescriptor;
+declare const sqlIntColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<SqlIntCodec, undefined>;
+declare class SqlFloatCodec extends CodecImpl<typeof SQL_FLOAT_CODEC_ID, readonly ['equality', 'order', 'numeric'], number, number> {
+  toWire(value: number, _ctx: CodecCallContext): Promise<number>;
+  fromWire(wire: number, _ctx: CodecCallContext): Promise<number>;
+  fromDataTypeValue(value: DataTypeValue): number;
+  toDataTypeValue(input: number): DataTypeValue;
+}
+declare class SqlFloatDescriptor extends CodecDescriptorTemplateImpl<void> {
+  readonly codecId: "sql/float@1";
+  readonly traits: readonly ["equality", "order", "numeric"];
+  readonly paramsSchema: undefined;
+  factory(): (ctx: CodecInstanceContext) => SqlFloatCodec;
+}
+declare const sqlFloatDescriptor: SqlFloatDescriptor;
+declare const sqlFloatColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<SqlFloatCodec, undefined>;
+declare class SqlCharCodec extends CodecImpl<typeof SQL_CHAR_CODEC_ID, readonly ['equality', 'order', 'textual'], string, string> {
+  toWire(value: string, _ctx: CodecCallContext): Promise<string>;
+  fromWire(wire: string, _ctx: CodecCallContext): Promise<string>;
+  fromDataTypeValue(value: DataTypeValue<string>): string;
+  toDataTypeValue(input: string): DataTypeValue;
+}
+declare class SqlCharDescriptor extends CodecDescriptorTemplateImpl<LengthParams> {
+  readonly codecId: "sql/char@1";
+  readonly traits: readonly ["equality", "order", "textual"];
+  readonly paramsSchema: undefined;
+  factory(_params: LengthParams): (ctx: CodecInstanceContext) => SqlCharCodec;
+}
+declare const sqlCharDescriptor: SqlCharDescriptor;
+declare const sqlCharColumn: (params?: LengthParams) => import("@prisma/orm-framework/components/codec").ColumnSpec<SqlCharCodec, LengthParams>;
+declare class SqlVarcharCodec extends CodecImpl<typeof SQL_VARCHAR_CODEC_ID, readonly ['equality', 'order', 'textual'], string, string> {
+  toWire(value: string, _ctx: CodecCallContext): Promise<string>;
+  fromWire(wire: string, _ctx: CodecCallContext): Promise<string>;
+  fromDataTypeValue(value: DataTypeValue<string>): string;
+  toDataTypeValue(input: string): DataTypeValue;
+}
+declare class SqlVarcharDescriptor extends CodecDescriptorTemplateImpl<LengthParams> {
+  readonly codecId: "sql/varchar@1";
+  readonly traits: readonly ["equality", "order", "textual"];
+  readonly paramsSchema: undefined;
+  factory(_params: LengthParams): (ctx: CodecInstanceContext) => SqlVarcharCodec;
+}
+declare const sqlVarcharDescriptor: SqlVarcharDescriptor;
+declare const sqlVarcharColumn: (params?: LengthParams) => import("@prisma/orm-framework/components/codec").ColumnSpec<SqlVarcharCodec, LengthParams>;
+type RawParams = {
+  readonly sql: string;
+};
+/**
+ * The codec of a raw column, whose type no other data type claims. Values pass through unchanged and
+ * are typed `unknown`, since nothing is known about them beyond what the database returns. A raw
+ * column has no literal values, but that is its data type's rule: the data type's reader refuses
+ * every value, so `toDataTypeValue` refuses every literal. ADR 273.
+ */
+declare class SqlRawCodec extends CodecImpl<typeof SQL_RAW_CODEC_ID, readonly [], unknown, unknown> {
+  toWire(value: unknown, _ctx: CodecCallContext): Promise<unknown>;
+  fromWire(wire: unknown, _ctx: CodecCallContext): Promise<unknown>;
+  fromDataTypeValue(value: DataTypeValue): unknown;
+  toDataTypeValue(input: unknown): DataTypeValue;
+}
+declare class SqlRawDescriptor extends CodecDescriptorTemplateImpl<RawParams> {
+  readonly codecId: "sql/raw@1";
+  readonly traits: readonly [];
+  readonly enumRefusal = "A raw column has a type Prisma does not interpret, so no member can be written as one of its values. No enum can use the raw codec; use a text enum instead.";
+  readonly paramsSchema: undefined;
+  factory(_params: RawParams): (ctx: CodecInstanceContext) => SqlRawCodec;
+}
+declare const sqlRawDescriptor: SqlRawDescriptor;
+declare const sqlRawColumn: (sql: string) => import("@prisma/orm-framework/components/codec").ColumnSpec<SqlRawCodec, {
+  sql: string;
+}>;
+//#endregion
+//#region src/ast/util.d.ts
+declare function compact<T extends Record<string, unknown>>(o: T): T;
+/**
+ * Walks an AST's parameter references in first-encounter order and dedupes
+ * by ParamRef identity. The single canonical helper used by every consumer
+ * that aligns `plan.params` with metadata-by-index — the SQL builder lane,
+ * the SQL ORM client, the SQL runtime encoder, and the Postgres renderer's
+ * `$N` index map — so the four walks cannot drift in dedupe semantics.
+ *
+ * SQLite's `?`-placeholder renderer intentionally does NOT use this helper
+ * because it needs one params entry per occurrence in the SQL.
+ */
+declare function collectOrderedParamRefs(ast: AnyQueryAst): ReadonlyArray<AnyParamRef>;
+/** Whether a projection item's top-level expression is an aggregate, `json_agg` or window function. Nested expressions are not inspected. */
+declare function isAggregateProjection(item: ProjectionItem): boolean;
+//#endregion
+export { sqlIntDescriptor as $, SqlTextDescriptor as A, lockStrengthCapabilities as B, SqlFloatCodec as C, SqlRawCodec as D, SqlIntDescriptor as E, encodeListLiteralDefault as F, sqlCharDescriptor as G, missingCapability as H, encodeLiteralDefault as I, sqlFloatDecode as J, sqlCharEncode as K, isAggregateProjection as L, SqlVarcharDescriptor as M, collectOrderedParamRefs as N, SqlRawDescriptor as O, compact as P, sqlIntDecode as Q, lockIncompatible as R, SqlCharDescriptor as S, SqlIntCodec as T, sqlCharColumn as U, lockWaitPolicyOf as V, sqlCharDecode as W, sqlFloatEncode as X, sqlFloatDescriptor as Y, sqlIntColumn as Z, SQL_INT_CODEC_ID as _, EncodedLiteralDefault as a, sqlTextDescriptor as at, SQL_VARCHAR_CODEC_ID as b, LockOptionCapabilities as c, sqlVarcharDecode as ct, LockWaitRequest as d, sqlIntEncode as et, Lowerer as f, SQL_FLOAT_CODEC_ID as g, SQL_CHAR_CODEC_ID as h, CapabilityRequirement as i, sqlTextDecode as it, SqlVarcharCodec as j, SqlTextCodec as k, LockStrengthCapabilities as l, sqlVarcharDescriptor as lt, MarkerReadResult as m, AdapterProfile as n, sqlRawDescriptor as nt, LiteralDefaultColumn as o, sqlTextEncode as ot, LowererContext as p, sqlFloatColumn as q, AdapterTarget as r, sqlTextColumn as rt, LockConflict as s, sqlVarcharColumn as st, Adapter as t, sqlRawColumn as tt, LockWaitOptions as u, sqlVarcharEncode as ut, SQL_RAW_CODEC_ID as v, SqlFloatDescriptor as w, SqlCharCodec as x, SQL_TEXT_CODEC_ID as y, lockOptionCapabilities as z };
+//# sourceMappingURL=ast-YEMe_B8z.d.mts.map

package/dist/ast-YEMe_B8z.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-YEMe_B8z.d.mts","names":[],"sources":["../../../../2-sql-family/4-lanes/relational-core/dist/exports/ast.d.mts"],"mappings":"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"}

package/dist/attribute-specs-DA_RwQFB.d.mts

@@ -0,0 +1,114 @@
+import "./contract-builder-C_Zi57iD.mjs";
+import "./psl-column-resolution-ChZqioOc-BREg4J7d.mjs";
+import { DataTypeSupport } from "@prisma/orm-framework/components/authoring";
+import { PslSources } from "@prisma/orm-framework/psl-parser/syntax";
+import "@prisma/orm-framework/components/psl-ast";
+import { ControlMutationDefaultEntry } from "@prisma/orm-framework/components/control";
+import { ArgType, AttributeCtx, AttributeSpec, AttributeSpecContext, DescribeUnsupportedAttribute, FieldAttributeCtx, FieldAttributeSpecContext, FuncCallSig, ModelAttributeCtx, ModelSymbol, ParsedWrittenList, ParsedWrittenScalar, PslSpan, TypedFuncCall } from "@prisma/orm-framework/psl-parser";
+//#region ../../../2-sql-family/2-authoring/contract-psl/dist/sql-attribute-specs-CK9iRCBj.d.mts
+//#region src/sql-attribute-specs.d.ts
+interface EnumMemberDefault {
+  readonly kind: 'member';
+  readonly name: string;
+}
+/** A written `null`, as a nullable field's default or a list element, with its span. */
+interface ParsedNullLiteral {
+  readonly kind: 'null';
+  readonly span: PslSpan;
+}
+/** An enum list default: its members and nulls. */
+interface EnumMemberListDefault {
+  readonly kind: 'member-list';
+  readonly elements: readonly (EnumMemberDefault | ParsedNullLiteral)[];
+}
+/** A call to a registered default function, such as `uuid()`. Not the contract's `{ kind: 'function' }` storage default. */
+interface DefaultFunctionCall {
+  readonly kind: 'default-function';
+  readonly call: TypedFuncCall;
+}
+type DefaultArgValue = ParsedWrittenScalar | ParsedNullLiteral | ParsedWrittenList<ParsedWrittenScalar | ParsedNullLiteral> | DefaultFunctionCall | EnumMemberDefault | EnumMemberListDefault;
+/** A default function's signature, or a function that builds it from the stack's data types when its arguments are values of a data type. */
+type DefaultFunctionSignature = FuncCallSig | ((dataTypes: DataTypeSupport) => FuncCallSig);
+/**
+ * A call to the registered default function `name`, with its signature built from the stack's data types when it needs them. Its binding diagnostics name it as a default function.
+ */
+declare function defaultFunctionCall(name: string, entry: ControlMutationDefaultEntry, dataTypes: DataTypeSupport): ArgType<TypedFuncCall, AttributeCtx>;
+declare function indexModelSpec(ctx: AttributeSpecContext): AttributeSpec<{
+  fields?: string[];
+  readonly expression?: import("@prisma/orm-framework/psl-parser").ParsedTypedValue;
+  readonly where?: import("@prisma/orm-framework/psl-parser").ParsedTypedValue;
+  readonly unique?: boolean;
+  readonly name?: string;
+  readonly map?: string;
+  readonly type?: string;
+  readonly options?: Record<string, string>;
+}, ModelAttributeCtx>;
+declare function checkModelSpec(ctx: AttributeSpecContext): AttributeSpec<{
+  readonly expression: import("@prisma/orm-framework/psl-parser").ParsedTypedValue;
+  readonly name?: string;
+  readonly map?: string;
+}, ModelAttributeCtx>;
+/** Every entry is a factory over the spec context, whether or not its spec reads it. ADR 249. */
+declare const sqlAttributeSpecs: {
+  readonly model: {
+    readonly map: (_ctx: AttributeSpecContext) => AttributeSpec<{
+      name: string;
+    }, ModelAttributeCtx>;
+    readonly id: (_ctx: AttributeSpecContext) => AttributeSpec<{
+      fields: string[];
+      readonly map?: string;
+    }, ModelAttributeCtx>;
+    readonly unique: (_ctx: AttributeSpecContext) => AttributeSpec<{
+      fields: string[];
+      readonly map?: string;
+    }, ModelAttributeCtx>;
+    readonly index: typeof indexModelSpec;
+    readonly check: typeof checkModelSpec;
+    readonly control: (_ctx: AttributeSpecContext) => AttributeSpec<{
+      policy: "managed" | "tolerated" | "external" | "observed";
+    }, ModelAttributeCtx>;
+    readonly discriminator: (_ctx: AttributeSpecContext) => AttributeSpec<{
+      field: string;
+    }, ModelAttributeCtx>;
+    readonly base: (_ctx: AttributeSpecContext) => AttributeSpec<{
+      base: import("@prisma/orm-framework/psl-parser").ResolvedEntityReference<ModelSymbol>;
+      value: ParsedWrittenScalar;
+    }, ModelAttributeCtx>;
+  };
+  readonly field: {
+    readonly map: (_ctx: FieldAttributeSpecContext) => AttributeSpec<{
+      name: string;
+    }, FieldAttributeCtx>;
+    readonly id: (_ctx: FieldAttributeSpecContext) => AttributeSpec<{
+      readonly map?: string;
+    }, FieldAttributeCtx>;
+    readonly unique: (_ctx: FieldAttributeSpecContext) => AttributeSpec<{
+      readonly map?: string;
+    }, FieldAttributeCtx>;
+    readonly relation: (_ctx: FieldAttributeSpecContext) => AttributeSpec<{
+      name?: string;
+      readonly fields?: string[];
+      readonly references?: string[];
+      readonly map?: string;
+      readonly onDelete?: "NoAction" | "Restrict" | "Cascade" | "SetNull" | "SetDefault";
+      readonly onUpdate?: "NoAction" | "Restrict" | "Cascade" | "SetNull" | "SetDefault";
+      readonly index?: string | boolean;
+    }, FieldAttributeCtx>;
+    readonly default: (ctx: FieldAttributeSpecContext) => AttributeSpec<{
+      value: DefaultArgValue;
+    }, AttributeCtx>;
+    readonly onCreate: (ctx: FieldAttributeSpecContext) => AttributeSpec<{
+      value: TypedFuncCall;
+    }, AttributeCtx>;
+    readonly onUpdate: (ctx: FieldAttributeSpecContext) => AttributeSpec<{
+      value: TypedFuncCall;
+    }, AttributeCtx>;
+  };
+};
+//#endregion
+//#region ../../../2-sql-family/2-authoring/contract-psl/dist/attribute-specs.d.mts
+//#region src/psl-field-resolution.d.ts
+declare function describeUnsupportedSqlAttribute(sources: PslSources): DescribeUnsupportedAttribute;
+//#endregion
+export { EnumMemberListDefault as a, sqlAttributeSpecs as c, EnumMemberDefault as i, DefaultFunctionCall as n, ParsedNullLiteral as o, DefaultFunctionSignature as r, defaultFunctionCall as s, describeUnsupportedSqlAttribute as t };
+//# sourceMappingURL=attribute-specs-DA_RwQFB.d.mts.map

package/dist/attribute-specs-DA_RwQFB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribute-specs-DA_RwQFB.d.mts","names":[],"sources":["../../../../2-sql-family/2-authoring/contract-psl/dist/sql-attribute-specs-CK9iRCBj.d.mts","../../../../2-sql-family/2-authoring/contract-psl/dist/attribute-specs.d.mts"],"mappings":";;;;;;;;;UAOU;WACC;WACA;;;UAGD;WACC;WACA,MAAM;;;UAGP;WACC;WACA,oBAAoB,oBAAoB;;;UAGzC;WACC;WACA,MAAM;;KAEZ,kBAAkB,sBAAsB,oBAAoB,kBAAkB,sBAAsB,qBAAqB,sBAAsB,oBAAoB;;KAEnK,2BAA2B,gBAAgB,WAAW,oBAAoB;;;;iBAI9D,oBAAoB,cAAc,OAAO,6BAA6B,WAAW,kBAAkB,QAAQ,eAAe;iBAC1H,eAAe,KAAK,uBAAuB;EAC1D;WACS,4CAA4C;WAC5C,uCAAuC;WACvC;WACA;WACA;WACA;WACA,UAAU;GAClB;iBACc,eAAe,KAAK,uBAAuB;WACjD,2CAA2C;WAC3C;WACA;GACR;;cAEW;WACH;aACE,MAAM,MAAM,yBAAyB;MAC5C;OACC;aACM,KAAK,MAAM,yBAAyB;MAC3C;eACS;OACR;aACM,SAAS,MAAM,yBAAyB;MAC/C;eACS;OACR;aACM,cAAc;aACd,cAAc;aACd,UAAU,MAAM,yBAAyB;MAChD;OACC;aACM,gBAAgB,MAAM,yBAAyB;MACtD;OACC;aACM,OAAO,MAAM,yBAAyB;MAC7C,qCAAqC,wBAAwB;MAC7D,OAAO;OACN;;WAEI;aACE,MAAM,MAAM,8BAA8B;MACjD;OACC;aACM,KAAK,MAAM,8BAA8B;eACvC;OACR;aACM,SAAS,MAAM,8BAA8B;eAC3C;OACR;aACM,WAAW,MAAM,8BAA8B;MACtD;eACS;eACA;eACA;eACA;eACA;eACA;OACR;aACM,UAAU,KAAK,8BAA8B;MACpD,OAAO;OACN;aACM,WAAW,KAAK,8BAA8B;MACrD,OAAO;OACN;aACM,WAAW,KAAK,8BAA8B;MACrD,OAAO;OACN;;;;;;iBC3FU,gCAAgC,SAAS,aAAa"}

package/dist/{authored-check-naming-Hf9990DV.mjs → authored-check-naming-BHGJhjqn.mjs}

@@ -1,8 +1,8 @@
-import { t as contractError } from "./contract-errors-BCN6RVI5-5IHBF_lg.mjs";
-import { i as computeCheckContentHash, n as assertWireNamePrefixLength } from "./naming-DKr4TJd7-Cszhq9RV.mjs";
-import { t as exactNameBodyWarning } from "./index-naming-DREt6js7-CRH27yUv.mjs";
+import { t as contractError } from "./contract-errors-BCN6RVI5-DoH6b_KZ.mjs";
+import { i as computeCheckContentHash, n as assertWireNamePrefixLength } from "./naming-bM5qm5PY-jOg3JFMb.mjs";
+import { t as exactNameBodyWarning } from "./index-naming-BOcJT1B3-mG8Fd6KN.mjs";
 import { flushAuthoringWarnings } from "@prisma/orm-framework/components/authoring";
-//#region ../../../2-sql/1-core/contract/dist/authored-check-naming.mjs
+//#region ../../../2-sql-family/1-core/contract/dist/authored-check-naming.mjs
 /**
 * Lowers an authored check constraint into the name-identified entity
 * `contract.json` persists: exact mode adopts `map` verbatim (no prefix, no
@@ -44,4 +44,4 @@ function lowerAuthoredCheck(tableName, authored, warnings) {
 //#endregion
 export { lowerAuthoredCheck as t };
 
-//# sourceMappingURL=authored-check-naming-Hf9990DV.mjs.map
+//# sourceMappingURL=authored-check-naming-BHGJhjqn.mjs.map

package/dist/authored-check-naming-BHGJhjqn.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"authored-check-naming-BHGJhjqn.mjs","names":[],"sources":["../../../../2-sql-family/1-core/contract/dist/authored-check-naming.mjs"],"sourcesContent":["import { t as contractError } from \"./contract-errors-BCN6RVI5.mjs\";\nimport { t as exactNameBodyWarning } from \"./index-naming-BOcJT1B3.mjs\";\nimport { flushAuthoringWarnings } from \"@internal/framework-components/authoring\";\nimport { assertWireNamePrefixLength, computeCheckContentHash } from \"@internal/sql-schema-ir/naming\";\n//#region src/authored-check-naming.ts\n/**\n* Lowers an authored check constraint into the name-identified entity\n* `contract.json` persists: exact mode adopts `map` verbatim (no prefix, no\n* hash) and warns, because a hand-authored body compared verbatim against\n* Postgres's reprint would false-drift; wire mode appends the content-hash\n* suffix to the authored prefix. There is no default prefix to fall back on\n* — a check has no column tuple to derive one from, unlike an index — so an\n* absent `name` is only valid alongside a present `map`. The cross-field\n* guards are the shared enforcement backstop for both authoring surfaces\n* (PSL pre-empts them with span-anchored diagnostics).\n*/\nfunction lowerAuthoredCheck(tableName, authored, warnings) {\n\tif (authored.map !== void 0 && authored.name !== void 0) throw contractError(\"CONTRACT.ARGUMENT_INVALID\", `Check \"${authored.map}\" on table \"${tableName}\": map and name are mutually exclusive — map adopts an exact physical name, name is a wire prefix.`);\n\tif (authored.expression.trim().length === 0) throw contractError(\"CONTRACT.ARGUMENT_INVALID\", `Check on table \"${tableName}\": expression must not be empty — an empty predicate is not a constraint.`);\n\tif (authored.map !== void 0) {\n\t\tconst warning = exactNameBodyWarning(\"check\", authored.map);\n\t\tif (warnings !== void 0) warnings.push(warning);\n\t\telse flushAuthoringWarnings([warning]);\n\t\treturn {\n\t\t\tnaming: {\n\t\t\t\tkind: \"exact\",\n\t\t\t\tname: authored.map\n\t\t\t},\n\t\t\texpression: authored.expression\n\t\t};\n\t}\n\tif (authored.name === void 0) throw contractError(\"CONTRACT.ARGUMENT_INVALID\", `Check on table \"${tableName}\": a check constraint requires an explicit name (name:) or exact physical name (map:) — unlike an index there is no column tuple to derive a default name from.`);\n\tconst prefix = authored.name;\n\tassertWireNamePrefixLength(prefix, \"check prefix\");\n\treturn {\n\t\tnaming: {\n\t\t\tkind: \"wire\",\n\t\t\tprefix,\n\t\t\thash: computeCheckContentHash(authored.expression)\n\t\t},\n\t\texpression: authored.expression\n\t};\n}\n//#endregion\nexport { lowerAuthoredCheck };\n\n//# sourceMappingURL=authored-check-naming.mjs.map"],"mappings":";;;;;;;;;;;;;;;;AAgBA,SAAS,mBAAmB,WAAW,UAAU,UAAU;CAC1D,IAAI,SAAS,QAAQ,KAAK,KAAK,SAAS,SAAS,KAAK,GAAG,MAAM,cAAc,6BAA6B,UAAU,SAAS,IAAI,cAAc,UAAU,mGAAmG;CAC5P,IAAI,SAAS,WAAW,KAAK,CAAC,CAAC,WAAW,GAAG,MAAM,cAAc,6BAA6B,mBAAmB,UAAU,0EAA0E;CACrM,IAAI,SAAS,QAAQ,KAAK,GAAG;EAC5B,MAAM,UAAU,qBAAqB,SAAS,SAAS,GAAG;EAC1D,IAAI,aAAa,KAAK,GAAG,SAAS,KAAK,OAAO;OACzC,uBAAuB,CAAC,OAAO,CAAC;EACrC,OAAO;GACN,QAAQ;IACP,MAAM;IACN,MAAM,SAAS;GAChB;GACA,YAAY,SAAS;EACtB;CACD;CACA,IAAI,SAAS,SAAS,KAAK,GAAG,MAAM,cAAc,6BAA6B,mBAAmB,UAAU,gKAAgK;CAC5Q,MAAM,SAAS,SAAS;CACxB,2BAA2B,QAAQ,cAAc;CACjD,OAAO;EACN,QAAQ;GACP,MAAM;GACN;GACA,MAAM,wBAAwB,SAAS,UAAU;EAClD;EACA,YAAY,SAAS;CACtB;AACD"}

package/dist/{authored-check-naming-BWBe-PVE.d.mts → authored-check-naming-D-o196ry.d.mts}

@@ -1,6 +1,6 @@
-import { n as CheckConstraintInput } from "./check-constraint-B7qGu6rc-HvQjjX82.mjs";
+import { n as CheckConstraintInput } from "./check-constraint-B7qGu6rc-Bk2ezWXu.mjs";
 import { AuthoringWarningSink } from "@prisma/orm-framework/components/authoring";
-//#region ../../../2-sql/1-core/contract/dist/authored-check-naming.d.mts
+//#region ../../../2-sql-family/1-core/contract/dist/authored-check-naming.d.mts
 //#region src/authored-check-naming.d.ts
 /**
  * A check constraint as authored, before naming: `map` is an exact physical
@@ -27,4 +27,4 @@ type AuthoredCheckInput = {
 declare function lowerAuthoredCheck(tableName: string, authored: AuthoredCheckInput, warnings?: AuthoringWarningSink): CheckConstraintInput;
 //#endregion
 export { lowerAuthoredCheck as n, AuthoredCheckInput as t };
-//# sourceMappingURL=authored-check-naming-BWBe-PVE.d.mts.map
+//# sourceMappingURL=authored-check-naming-D-o196ry.d.mts.map

package/dist/authored-check-naming-D-o196ry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authored-check-naming-D-o196ry.d.mts","names":[],"sources":["../../../../2-sql-family/1-core/contract/dist/authored-check-naming.d.mts"],"mappings":";;;;;;;;;;KASK;WACM;WACA;WACA;;;;;;;;;;;;;iBAaM,mBAAmB,mBAAmB,UAAU,oBAAoB,WAAW,uBAAuB"}

package/dist/authoring-entity-types-CgKIgWq5-pEdfjam5.d.mts

@@ -0,0 +1,9 @@
+import "./contract-builder-C_Zi57iD.mjs";
+import "@prisma/orm-framework/components/authoring";
+import "@prisma/orm-framework/psl-parser";
+//#region ../../../2-sql-family/9-family/dist/authoring-entity-types-CgKIgWq5.d.mts
+//#region src/core/authoring-entity-types.d.ts
+declare function sqlFamilyEnumSpec(): import("@prisma/orm-framework/psl-parser").MapBlockSpec<Record<string, string | number | boolean | import("@prisma/orm-framework/components/authoring").WrittenScalar | (string | number | boolean | import("@prisma/orm-framework/components/authoring").WrittenScalar)[] | undefined>>;
+//#endregion
+export { sqlFamilyEnumSpec as t };
+//# sourceMappingURL=authoring-entity-types-CgKIgWq5-pEdfjam5.d.mts.map

package/dist/authoring-entity-types-CgKIgWq5-pEdfjam5.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authoring-entity-types-CgKIgWq5-pEdfjam5.d.mts","names":[],"sources":["../../../../2-sql-family/9-family/dist/authoring-entity-types-CgKIgWq5.d.mts"],"mappings":";;;;;iBAIiB,oDAAoD,aAAa,8FAA8F,gGAAgG"}

package/dist/builder.d.mts

@@ -1,3 +1,4 @@
-import { o as Expression, x as ScopeField } from "./expression-FJK6Ar-d.mjs";
-import { c as GroupedQuery, d as QueryContext, f as ResolveRow, h as Subquery, i as DeleteQuery, l as InsertQuery, m as SelectQuery, o as Functions, p as Scope, r as Db, s as GatedMethod, t as AggregateFunctions, v as TableProxy, x as UpdateQuery } from "./db-D18PrXKW-DvTv4JFn.mjs";
-export type { AggregateFunctions, Db, DeleteQuery, Expression, Functions, GatedMethod, GroupedQuery, InsertQuery, QueryContext, ResolveRow, Scope, ScopeField, SelectQuery, Subquery, TableProxy, UpdateQuery };
+import { o as Expression, x as ScopeField } from "./expression-6ld_ZQL6-fOuazzzm.mjs";
+import { a as Subquery, r as Functions } from "./functions-EW-RrRn3.mjs";
+import { C as WhereFilter, S as UpdateQuery, d as QueryContext, g as SelectQuery, h as Scope, i as DeleteQuery, l as InsertQuery, m as ResolveRow, o as GatedMethod, r as Db, s as GroupedQuery, t as AggregateFunctions, y as TableProxy } from "./db-D1d75IvM-D4mRDC6w.mjs";
+export type { AggregateFunctions, Db, DeleteQuery, Expression, Functions, GatedMethod, GroupedQuery, InsertQuery, QueryContext, ResolveRow, Scope, ScopeField, SelectQuery, Subquery, TableProxy, UpdateQuery, WhereFilter };

package/dist/builder__runtime.d.mts

@@ -1,40 +1,38 @@
-import { c as SqlStorage } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
-import "./types-UcHa2cTe.mjs";
-import { i as SqlOperationEntry } from "./index-C5I8D-MB.mjs";
-import { s as AnyExpression } from "./types-v3qxLLxo-DCeKv7yY.mjs";
-import "./ast-HFcfQZr-.mjs";
-import { l as RawCodecInferer, o as Expression, x as ScopeField } from "./expression-FJK6Ar-d.mjs";
-import { a as FieldProxy, d as QueryContext, o as Functions, p as Scope, r as Db, t as AggregateFunctions, y as TableProxyContract } from "./db-D18PrXKW-DvTv4JFn.mjs";
-import { c as SqlAggregateDescriptorRegistry, r as ExecutionContext } from "./query-lane-context-Qa-eddrE-kuZ8Z86-.mjs";
-import "./query-lane-context-XMvk7fmY.mjs";
+import { l as SqlStorage } from "./sql-storage-DeCAh5Hi-CEM-m8cs.mjs";
+import "./types-CkAd8SWm.mjs";
+import { i as SqlOperationEntry } from "./index-Nqc3OHR_.mjs";
+import { l as RawCodecInferer } from "./expression-6ld_ZQL6-fOuazzzm.mjs";
+import { t as ExpressionImpl } from "./expression-CieaNuRM-B1uVqxwd.mjs";
+import "./expression-D8HstQiB.mjs";
+import { s as createFunctions } from "./functions-EW-RrRn3.mjs";
+import { a as FieldProxy, b as TableProxyContract, d as QueryContext, f as RawLane, h as Scope, r as Db, t as AggregateFunctions } from "./db-D1d75IvM-D4mRDC6w.mjs";
+import { a as SqlAggregateDescriptorRegistry, n as ExecutionContext } from "./query-lane-context-BCEoKy0_-CzmyavC9.mjs";
+import "./query-lane-context-VqH0mS9B.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
-import { CodecRef } from "@prisma/orm-framework/components/codec";
-//#region ../../../2-sql/4-lanes/sql-builder/dist/runtime/index.d.mts
-//#region src/runtime/expression-impl.d.ts
-/**
- * Runtime wrapper around a relational-core AST expression node. Carries ScopeField metadata (codecId, nullable) so aggregate-like combinators can propagate the input codec onto their result.
- *
- * `codec` records the column-bound {@link CodecRef} when the field-proxy knows the binding — both the namespaced form (`f.user.email` → `ColumnRef`) and the top-level shortcut (`f.email` → `IdentifierRef`) stamp the ref derived from contract storage. `codecOf(expression)` exposes it for operation implementations forwarding the ref to `toExpr`.
- *
- * `projectionAst` carries the descriptor-lowered rendering of the expression, where a target declares one (e.g. SQLite's `CAST(count(*) AS TEXT)`). Lowering exists to carry the value across the driver boundary, so only the projection site consumes it — predicate and ordering positions (`buildAst()`) keep the plain form, where the rendering would change SQL semantics.
- */
-declare class ExpressionImpl<T extends ScopeField = ScopeField> implements Expression<T> {
-  private readonly ast;
-  private readonly projectionAst;
-  readonly returnType: T;
-  readonly codec: CodecRef | undefined;
-  constructor(ast: AnyExpression, returnType: T, codec?: CodecRef, projectionAst?: AnyExpression);
-  buildAst(): AnyExpression;
-  buildProjectionAst(): AnyExpression;
-}
-//#endregion
+//#region ../../../2-sql-family/4-lanes/sql-builder/dist/runtime/index.d.mts
 //#region src/runtime/field-proxy.d.ts
 declare function createFieldProxy<S extends Scope>(scope: S): FieldProxy<S>;
 //#endregion
 //#region src/runtime/functions.d.ts
-declare function createFunctions<QC extends QueryContext>(operations: Readonly<Record<string, SqlOperationEntry>>, rawCodecInferer: RawCodecInferer): Functions<QC>;
 declare function createAggregateFunctions<QC extends QueryContext>(operations: Readonly<Record<string, SqlOperationEntry>>, rawCodecInferer: RawCodecInferer, aggregateRegistry: SqlAggregateDescriptorRegistry): AggregateFunctions<QC>;
 //#endregion
+//#region src/runtime/raw-lane.d.ts
+interface RawLaneOptions<C extends Contract<SqlStorage> & TableProxyContract> {
+  readonly context: ExecutionContext<C>;
+  readonly rawCodecInferer: RawCodecInferer;
+}
+/**
+ * Builds the raw lane a client exposes as `db.raw`.
+ *
+ * The tag binds the adapter's codec inferer and the contract here, once. An
+ * authoring site then carries only its template, its row spec, and a
+ * terminator.
+ *
+ * The row type is phantom: no value holds it. The target-agnostic tag types it
+ * as `unknown`, and the contract says what each declared column decodes to.
+ */
+declare function createRawLane<C extends Contract<SqlStorage> & TableProxyContract>(options: RawLaneOptions<C>): RawLane<C>;
+//#endregion
 //#region src/runtime/sql.d.ts
 interface SqlOptions<C extends Contract<SqlStorage> & TableProxyContract> {
   readonly context: ExecutionContext<C>;
@@ -42,5 +40,5 @@ interface SqlOptions<C extends Contract<SqlStorage> & TableProxyContract> {
 }
 declare function sql<C extends Contract<SqlStorage> & TableProxyContract>(options: SqlOptions<C>): Db<C>;
 //#endregion
-export { type Db, ExpressionImpl, type SqlOptions, createAggregateFunctions, createFieldProxy, createFunctions, sql };
+export { type Db, ExpressionImpl, type RawLaneOptions, type SqlOptions, createAggregateFunctions, createFieldProxy, createFunctions, createRawLane, sql };
 //# sourceMappingURL=builder__runtime.d.mts.map

package/dist/builder__runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"builder__runtime.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/sql-builder/dist/runtime/index.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAgBc,eAAe,UAAU,aAAa,uBAAuB,WAAW;mBACnE;mBACA;WACR,YAAY;WACZ,OAAO;EAChB,YAAY,KAAK,eAAe,YAAY,GAAG,QAAQ,UAAU,gBAAgB;EACjF,YAAY;EACZ,sBAAsB;;;;iBAIP,iBAAiB,UAAU,OAAO,OAAO,IAAI,WAAW;;;iBAGxD,gBAAgB,WAAW,cAAc,YAAY,SAAS,eAAe,qBAAqB,iBAAiB,kBAAkB,UAAU;iBAC/I,yBAAyB,WAAW,cAAc,YAAY,SAAS,eAAe,qBAAqB,iBAAiB,iBAAiB,mBAAmB,iCAAiC,mBAAmB;;;UAG3N,WAAW,UAAU,SAAS,cAAc;WAC3C,SAAS,iBAAiB;WAC1B,iBAAiB;;iBAEX,IAAI,UAAU,SAAS,cAAc,oBAAoB,SAAS,WAAW,KAAK,GAAG"}
+{"version":3,"file":"builder__runtime.d.mts","names":[],"sources":["../../../../2-sql-family/4-lanes/sql-builder/dist/runtime/index.d.mts"],"mappings":";;;;;;;;;;;;;iBAQiB,iBAAiB,UAAU,OAAO,OAAO,IAAI,WAAW;;;iBAGxD,yBAAyB,WAAW,cAAc,YAAY,SAAS,eAAe,qBAAqB,iBAAiB,iBAAiB,mBAAmB,iCAAiC,mBAAmB;;;UAG3N,eAAe,UAAU,SAAS,cAAc;WAC/C,SAAS,iBAAiB;WAC1B,iBAAiB;;;;;;;;;;;;iBAYX,cAAc,UAAU,SAAS,cAAc,oBAAoB,SAAS,eAAe,KAAK,QAAQ;;;UAG/G,WAAW,UAAU,SAAS,cAAc;WAC3C,SAAS,iBAAiB;WAC1B,iBAAiB;;iBAEX,IAAI,UAAU,SAAS,cAAc,oBAAoB,SAAS,WAAW,KAAK,GAAG"}