@prisma/orm-family-sql 0.16.0-dev.36

package/dist/control-BHmsZudH.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-BHmsZudH.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/control.d.mts"],"mappings":"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;;;;cAMI,sBAAsB;;;;;;;;;;;;;;iBAcnB,iCAAiC;;;;;;;;;;;iBAWjC,+BAA+B,8BAA8B,2BAA2B;WAC9F,SAAS;WACT,YAAY;;WAEZ;aACE;aACA;eACE,SAAS;eACT,YAAY;eACZ;iBACE;iBACA;;;;WAIN;aACE;aACA;eACE,SAAS;eACT,YAAY;eACZ;iBACE;mBACE;mBACA;;iBAEF;mBACE;mBACA;;;;;;;;;;;;;;;iBAeF,uCAAuC,8BAA8B,2BAA2B;WACtG,SAAS;WACT,YAAY;;WAEZ;WACA;aACE;aACA;aACA;aACA;aACA;;aAEA;aACA;aACA;aACA;;aAEA;aACA;aACA;aACA;;WAEF;aACE,SAAS;aACT,YAAY;aACZ;eACE;iBACE;iBACA;;;aAGJ;eACE;iBACE;iBACA;iBACA;mBACE;qBACE;qBACA;;;;eAIN;iBACE;iBACA;iBACA;mBACE;qBACE;qBACA;;;;;;;;;;;;iBAYJ,0BAA0B,8BAA8B,2BAA2B;WACzF,SAAS;WACT,YAAY;;WAEZ;WACA;aACE;aACA;aACA;aACA;;aAEA;aACA;aACA;aACA;;WAEF;aACE,SAAS;aACT,YAAY;aACZ;eACE;iBACE;iBACA;iBACA;mBACE;qBACE;qBACA;;;;eAIN;iBACE;iBACA;iBACA;mBACE;qBACE;qBACA;;;;;;;;;cASP,UAAU"}

package/dist/control-adapter-4y1O8Ps3.d.mts

@@ -0,0 +1 @@
+import "./control-adapter-C99J7aEF-C-17lFY8.mjs";

package/dist/control-adapter-C99J7aEF-C-17lFY8.d.mts

@@ -0,0 +1,191 @@
+import { C as SqlControlDriverInstance } from "./types-CuDrWc5v-ISVXBmBs.mjs";
+import "./types-BchwQpmO.mjs";
+import { Q as LoweredStatement, p as AnyQueryAst } from "./types-DIBA80mc-wf5wLmON.mjs";
+import { s as DdlNode } from "./ddl-types-rrMsf77U-DGctYf-T.mjs";
+import { a as LowererContext, y as SqlExecuteRequest } from "./ast-DSuzmsWn.mjs";
+import { v as SqlSchemaIRNode } from "./types-CvbBw1Jo-3KQdErJY.mjs";
+import "./types-TvBZ2Ne9.mjs";
+import { ColumnDefault, ContractMarkerRecord, LedgerEntryRecord } from "@prisma/orm-framework/contract/types";
+import { ControlAdapterInstance, ControlStack } from "@prisma/orm-framework/components/control";
+//#region ../../../2-sql/9-family/dist/control-adapter-C99J7aEF.d.mts
+//#region src/core/diff/sql-schema-diff.d.ts
+/**
+ * Function type for normalizing raw database default expressions into ColumnDefault.
+ * Target-specific implementations handle database dialect differences.
+ */
+type DefaultNormalizer = (rawDefault: string, nativeType: string) => ColumnDefault | undefined;
+/**
+ * Function type for normalizing schema native types to canonical form for comparison.
+ * Target-specific implementations handle dialect-specific type name variations
+ * (e.g., Postgres 'varchar' → 'character varying', 'timestamptz' normalization).
+ */
+type NativeTypeNormalizer = (nativeType: string) => string;
+/**
+ * Compares two arrays of strings for equality (order-sensitive).
+ */
+declare function arraysEqual(a: readonly string[], b: readonly string[]): boolean;
+//#endregion
+//#region src/core/control-adapter.d.ts
+/**
+ * Structural interface for anything that can lower a SQL/DDL AST node to a
+ * `LoweredStatement`. `SqlControlAdapter` satisfies this interface; the
+ * migration planner and op-factory calls accept `Lowerer` rather than the
+ * full `SqlControlAdapter` so they are not coupled to the broader control
+ * adapter surface.
+ */
+interface Lowerer {
+  lower(ast: AnyQueryAst | DdlNode, context: LowererContext<unknown>): LoweredStatement;
+}
+/**
+ * Extends {@link Lowerer} with async codec-routed DDL lowering. Control
+ * adapters implement this; the planner's `CreateTableCall.toOp` and
+ * `CreateSchemaCall.toOp` accept it to produce executable DDL statements
+ * with literal defaults encoded through their codec.
+ */
+interface ExecuteRequestLowerer extends Lowerer {
+  lowerToExecuteRequest(ast: AnyQueryAst | DdlNode, context?: LowererContext<unknown>): Promise<SqlExecuteRequest>;
+}
+/**
+ * SQL control adapter interface for control-plane operations.
+ * Implemented by target-specific adapters (e.g., Postgres, MySQL).
+ *
+ * @template TTarget - The target ID (e.g., 'postgres', 'mysql')
+ */
+interface SqlControlAdapter<TTarget extends string = string> extends ControlAdapterInstance<'sql', TTarget>, ExecuteRequestLowerer {
+  /**
+   * Reads the contract marker for `space` from the database, returning
+   * `null` if no marker row exists for that space (or if the marker
+   * table itself is missing). Implementations are responsible for the
+   * dialect-specific existence probe (e.g. Postgres
+   * `information_schema.tables` vs SQLite `sqlite_master`) and parameter
+   * placeholders.
+   *
+   * `space` is required so callers cannot accidentally fall through to
+   * the app's marker row when reading per-extension markers.
+   *
+   * @param driver - ControlDriverInstance for executing queries (target-specific)
+   * @param space - Contract space id whose marker row to read (e.g. `'app'`)
+   * @returns Resolved marker record, or `null` if not yet stamped.
+   */
+  readMarker(driver: SqlControlDriverInstance<TTarget>, space: string): Promise<ContractMarkerRecord | null>;
+  /**
+   * Reads every marker row from `prisma_contract.marker` (one per
+   * contract space) and returns them keyed by `space`. Used by the
+   * per-space verifier to detect marker-vs-on-disk drift and orphan
+   * marker rows. Returns an empty map when the marker table does not
+   * yet exist (fresh database / never-signed project).
+   */
+  readAllMarkers(driver: SqlControlDriverInstance<TTarget>): Promise<ReadonlyMap<string, ContractMarkerRecord>>;
+  /**
+   * Reads the per-migration ledger journal in apply order. When `space` is
+   * omitted, returns rows for every space.
+   */
+  readLedger(driver: SqlControlDriverInstance<TTarget>, space?: string): Promise<readonly LedgerEntryRecord[]>;
+  /**
+   * Inserts the initial marker row for `space` (`INSERT` only). Fails when a
+   * row for that space already exists. Used by `sign()` so concurrent first-time
+   * stamps cannot silently overwrite each other. `updated_at` is DB-side
+   * (`now()` / `datetime('now')`). Mirrors `MongoControlAdapter.initMarker`.
+   */
+  insertMarker(driver: SqlControlDriverInstance<TTarget>, space: string, destination: {
+    readonly storageHash: string;
+    readonly profileHash: string;
+    readonly invariants?: readonly string[];
+  }): Promise<void>;
+  /**
+   * Writes the initial marker row for `space` as an upsert (`INSERT … ON
+   * CONFLICT (space) DO UPDATE SET …`), so re-stamping a space overwrites the
+   * existing row rather than failing. `updated_at` is stamped with a DB-side
+   * time expression (`now()` / `datetime('now')`), never an app-side clock.
+   */
+  initMarker(driver: SqlControlDriverInstance<TTarget>, space: string, destination: {
+    readonly storageHash: string;
+    readonly profileHash: string;
+    readonly invariants?: readonly string[];
+  }): Promise<void>;
+  /**
+   * Atomically advances the marker row for `space` (compare-and-swap on
+   * `core_hash = expectedFrom`). Returns `true` when the swap matched a row,
+   * `false` when another process advanced the marker first. `destination.invariants`
+   * is written verbatim when supplied (the union/dedupe policy lives upstream)
+   * and left untouched when omitted. Mirrors `MongoControlAdapter.updateMarker`.
+   */
+  updateMarker(driver: SqlControlDriverInstance<TTarget>, space: string, expectedFrom: string, destination: {
+    readonly storageHash: string;
+    readonly profileHash: string;
+    readonly invariants?: readonly string[];
+  }): Promise<boolean>;
+  /**
+   * Appends a ledger entry for `space`. Mirrors `MongoControlAdapter.writeLedgerEntry`.
+   * The SQL ledger table keys rows by an autoincrement id and partitions reads
+   * by `space`, so `entry.edgeId` carries no dedicated column; `from` / `to`
+   * land in `origin_core_hash` / `destination_core_hash`.
+   */
+  writeLedgerEntry(driver: SqlControlDriverInstance<TTarget>, space: string, entry: {
+    readonly edgeId: string;
+    readonly from: string;
+    readonly to: string;
+    readonly migrationName: string;
+    readonly migrationHash: string;
+    readonly operations: readonly unknown[];
+    readonly destinationContractJson?: unknown;
+  }): Promise<void>;
+  /**
+   * Introspects a database schema and returns the target's schema-IR node.
+   *
+   * This is a pure schema discovery operation that queries the database catalog
+   * and returns the schema structure without type mapping or contract enrichment.
+   * Type mapping and enrichment are handled separately by enrichment helpers.
+   *
+   * The return type is the family-base `SqlSchemaIRNode` so each target returns
+   * its own node shape: SQLite returns a flat `SqlSchemaIR`, Postgres returns a
+   * `PostgresDatabaseSchemaNode` tree root. Consumers `ensure` the concrete
+   * target type before walking it.
+   *
+   * @param driver - ControlDriverInstance instance for executing queries (target-specific)
+   * @param contract - Optional contract for contract-guided introspection (filtering, optimization)
+   * @param schema - Schema name to introspect (defaults to 'public')
+   * @returns Promise resolving to the live database schema node
+   */
+  introspect(driver: SqlControlDriverInstance<TTarget>, contract?: unknown, schema?: string): Promise<SqlSchemaIRNode>;
+  /**
+   * Optional target-specific normalizer for raw database default expressions.
+   * When provided, schema defaults (raw strings) are normalized before comparison
+   * with contract defaults (ColumnDefault objects) during schema verification.
+   */
+  readonly normalizeDefault?: DefaultNormalizer;
+  /**
+   * Optional target-specific normalizer for schema native type names.
+   * When provided, schema native types (from introspection) are normalized
+   * before comparison with contract native types during schema verification.
+   */
+  readonly normalizeNativeType?: NativeTypeNormalizer;
+  /**
+   * Ordered DDL queries that bootstrap marker/ledger control tables for migration
+   * runners. Postgres includes `CREATE SCHEMA`; SQLite does not.
+   */
+  bootstrapControlTableQueries(): readonly DdlNode[];
+  /**
+   * Ordered DDL queries that bootstrap the marker table (and Postgres schema) for
+   * `sign` — excludes the ledger table.
+   */
+  bootstrapSignMarkerQueries(): readonly DdlNode[];
+}
+/**
+ * SQL control adapter descriptor interface.
+ * Provides a factory method to create control adapter instances.
+ *
+ * @template TTarget - The target ID (e.g., 'postgres', 'mysql')
+ */
+interface SqlControlAdapterDescriptor<TTarget extends string = string> {
+  /**
+   * Creates a SQL control adapter instance for control-plane operations.
+   *
+   * Receives the assembled `ControlStack` so adapters can read aggregated
+   * metadata (codec lookup, extension contributions) when materializing.
+   */
+  create(stack: ControlStack<'sql', TTarget>): SqlControlAdapter<TTarget>;
+}
+//#endregion
+export { SqlControlAdapterDescriptor as a, SqlControlAdapter as i, Lowerer as n, arraysEqual as o, NativeTypeNormalizer as r, ExecuteRequestLowerer as t };
+//# sourceMappingURL=control-adapter-C99J7aEF-C-17lFY8.d.mts.map

package/dist/control-adapter-C99J7aEF-C-17lFY8.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-adapter-C99J7aEF-C-17lFY8.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/control-adapter-C99J7aEF.d.mts"],"mappings":";;;;;;;;;;;;;;;KAUK,qBAAqB,oBAAoB,uBAAuB;;;;;;KAMhE,wBAAwB;;;;iBAIZ,YAAY,sBAAsB;;;;;;;;;;UAUzC;EACR,MAAM,KAAK,cAAc,SAAS,SAAS,0BAA0B;;;;;;;;UAQ7D,8BAA8B;EACtC,sBAAsB,KAAK,cAAc,SAAS,UAAU,0BAA0B,QAAQ;;;;;;;;UAQtF,kBAAkB,yCAAyC,8BAA8B,UAAU;;;;;;;;;;;;;;;;EAgB3G,WAAW,QAAQ,yBAAyB,UAAU,gBAAgB,QAAQ;;;;;;;;EAQ9E,eAAe,QAAQ,yBAAyB,WAAW,QAAQ,oBAAoB;;;;;EAKvF,WAAW,QAAQ,yBAAyB,UAAU,iBAAiB,iBAAiB;;;;;;;EAOxF,aAAa,QAAQ,yBAAyB,UAAU,eAAe;aAC5D;aACA;aACA;MACP;;;;;;;EAOJ,WAAW,QAAQ,yBAAyB,UAAU,eAAe;aAC1D;aACA;aACA;MACP;;;;;;;;EAQJ,aAAa,QAAQ,yBAAyB,UAAU,eAAe,sBAAsB;aAClF;aACA;aACA;MACP;;;;;;;EAOJ,iBAAiB,QAAQ,yBAAyB,UAAU,eAAe;aAChE;aACA;aACA;aACA;aACA;aACA;aACA;MACP;;;;;;;;;;;;;;;;;;EAkBJ,WAAW,QAAQ,yBAAyB,UAAU,oBAAoB,kBAAkB,QAAQ;;;;;;WAM3F,mBAAmB;;;;;;WAMnB,sBAAsB;;;;;EAK/B,yCAAyC;;;;;EAKzC,uCAAuC;;;;;;;;UAQ/B,4BAA4B;;;;;;;EAOpC,OAAO,OAAO,oBAAoB,WAAW,kBAAkB"}

package/dist/db-DhMsmBS--DKENDi3l.d.mts

@@ -0,0 +1,365 @@
+import { a as StorageTable } from "./storage-table-BBaAmanc-BwR37LMA.mjs";
+import { a as ExtractCodecTypes, b as QueryOperationTypesBase, c as ExtractQueryOperationTypes, l as ExtractStorageColumnInputTypes, u as ExtractStorageColumnTypes } from "./types-CuDrWc5v-ISVXBmBs.mjs";
+import { t as StorageColumnMapAt } from "./types-BchwQpmO.mjs";
+import { ft as SelectAst, s as AnyFromSource } from "./types-DIBA80mc-wf5wLmON.mjs";
+import "./ast-DSuzmsWn.mjs";
+import { a as Expression, c as RawSqlTag, d as TraitExpression, n as CodecExpression, r as CodecTypesBase, u as ScopeField } from "./expression-DIf8F4Mc.mjs";
+import { t as SqlQueryPlan } from "./plan-BTD8xFfa-Dd_K-A1R.mjs";
+import "./plan-Cm4jaoNM.mjs";
+import { AnnotationValue, OperationKind, ValidAnnotations } from "@prisma/orm-framework/components/runtime";
+//#region ../../../2-sql/4-lanes/sql-builder/dist/db-DhMsmBS-.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>;
+type Scope = {
+  topLevel: ScopeTable;
+  namespaces: Record<string, ScopeTable>;
+};
+type JoinSource<Row extends ScopeTable, Alias extends string> = {
+  readonly [JoinOuterScope]: {
+    topLevel: Row;
+    namespaces: Record<Alias, Row>;
+  };
+  getJoinOuterScope(): Scope;
+  buildAst(): AnyFromSource;
+};
+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 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']>;
+};
+type RebindScope<S extends Scope, OldKey extends string, NewKey extends string> = {
+  topLevel: S['topLevel'];
+  namespaces: Expand<Omit<S['namespaces'], OldKey> & Record<NewKey, S['namespaces'][OldKey]>>;
+};
+type NullableScopeTable<S extends ScopeTable> = { [K in keyof S]: {
+  codecId: S[K]['codecId'];
+  nullable: true;
+}; };
+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>>;
+  readonly queryOperationTypes: QueryOperationTypesBase;
+  readonly resolvedColumnOutputTypes: Record<string, unknown>;
+};
+//#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;
+};
+type OrderByScope<AvailableScope extends Scope, RowType extends Record<string, ScopeField>> = {
+  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']>;
+type CountField = {
+  codecId: 'pg/int8@1';
+  nullable: false;
+};
+type AggregateOnlyFunctions = {
+  count: (expr?: Expression<ScopeField>) => Expression<CountField>;
+  sum: <T extends ScopeField>(expr: Expression<T>) => Expression<{
+    codecId: T['codecId'];
+    nullable: true;
+  }>;
+  avg: <T extends ScopeField>(expr: Expression<T>) => Expression<{
+    codecId: T['codecId'];
+    nullable: true;
+  }>;
+  min: <T extends ScopeField>(expr: Expression<T>) => Expression<{
+    codecId: T['codecId'];
+    nullable: true;
+  }>;
+  max: <T extends ScopeField>(expr: Expression<T>) => Expression<{
+    codecId: T['codecId'];
+    nullable: true;
+  }>;
+};
+type AggregateFunctions<QC extends QueryContext> = Functions<QC> & AggregateOnlyFunctions;
+//#endregion
+//#region src/resolve.d.ts
+type ResolveField<F extends ScopeField, CodecTypes extends Record<string, {
+  readonly output: unknown;
+}>> = F['codecId'] extends keyof CodecTypes ? F['nullable'] extends true ? CodecTypes[F['codecId']]['output'] | null : CodecTypes[F['codecId']]['output'] : unknown;
+type ApplyNullable<T, F extends ScopeField> = F['nullable'] extends true ? T | null : T;
+type ResolveRow<Row extends Record<string, ScopeField>, CodecTypes extends Record<string, {
+  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/mutation-query.d.ts
+type ReturningCapability = {
+  sql: {
+    returning: true;
+  };
+};
+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']> {}
+//#endregion
+//#region src/types/grouped-query.d.ts
+interface GroupedQuery<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField>> extends Subquery<RowType>, WithPagination<QC>, WithDistinct, WithAlias<RowType>, WithBuild<QC, RowType> {
+  /**
+   * Attach one or more read-typed annotations to this query plan.
+   * Annotations declare `applicableTo: ['read']` (or `['read', 'write']`)
+   * via `defineAnnotation`; write-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<'read', As>): GroupedQuery<QC, AvailableScope, RowType>;
+  groupBy(...fields: ((keyof RowType | keyof AvailableScope['topLevel']) & string)[]): GroupedQuery<QC, AvailableScope, RowType>;
+  groupBy(expr: (fields: FieldProxy<OrderByScope<AvailableScope, RowType>>, fns: Functions<QC>) => Expression<ScopeField>): GroupedQuery<QC, AvailableScope, RowType>;
+  having(expr: (fields: FieldProxy<OrderByScope<AvailableScope, RowType>>, fns: AggregateFunctions<QC>) => Expression<BooleanCodecType>): GroupedQuery<QC, AvailableScope, RowType>;
+  orderBy(field: (keyof RowType | keyof AvailableScope['topLevel']) & string, options?: OrderByOptions): GroupedQuery<QC, AvailableScope, RowType>;
+  orderBy(expr: (fields: FieldProxy<OrderByScope<AvailableScope, RowType>>, fns: AggregateFunctions<QC>) => Expression<ScopeField>, options?: OrderByOptions): GroupedQuery<QC, AvailableScope, RowType>;
+  distinctOn: GatedMethod<QC['capabilities'], {
+    postgres: {
+      distinctOn: true;
+    };
+  }, {
+    (...fields: ((keyof RowType | keyof AvailableScope['topLevel']) & string)[]): GroupedQuery<QC, AvailableScope, RowType>;
+    (expr: (fields: FieldProxy<OrderByScope<AvailableScope, RowType>>, fns: Functions<QC>) => Expression<ScopeField>): GroupedQuery<QC, AvailableScope, RowType>;
+  }>;
+}
+//#endregion
+//#region src/types/select-query.d.ts
+interface SelectQuery<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField>> extends Subquery<RowType>, WithSelect<QC, AvailableScope, RowType>, WithPagination<QC>, WithDistinct, WithAlias<RowType>, WithBuild<QC, RowType> {
+  /**
+   * Attach one or more read-typed annotations to this query plan.
+   * Annotations declare `applicableTo: ['read']` (or `['read', 'write']`)
+   * via `defineAnnotation`; write-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<'read', As>): SelectQuery<QC, AvailableScope, RowType>;
+  where(expr: ExpressionBuilder<AvailableScope, QC>): SelectQuery<QC, AvailableScope, RowType>;
+  orderBy(field: (keyof RowType | keyof AvailableScope['topLevel']) & string, options?: OrderByOptions): SelectQuery<QC, AvailableScope, RowType>;
+  orderBy(expr: (fields: FieldProxy<OrderByScope<AvailableScope, RowType>>, fns: Functions<QC>) => Expression<ScopeField>, options?: OrderByOptions): SelectQuery<QC, AvailableScope, RowType>;
+  groupBy(...fields: ((keyof RowType | keyof AvailableScope['topLevel']) & string)[]): GroupedQuery<QC, AvailableScope, RowType>;
+  groupBy(expr: (fields: FieldProxy<OrderByScope<AvailableScope, RowType>>, fns: Functions<QC>) => Expression<ScopeField>): GroupedQuery<QC, AvailableScope, RowType>;
+  distinctOn: GatedMethod<QC['capabilities'], {
+    postgres: {
+      distinctOn: true;
+    };
+  }, {
+    (...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>;
+  }>;
+}
+//#endregion
+//#region src/types/shared.d.ts
+interface LateralBuilder<QC extends QueryContext, ParentScope extends Scope> {
+  from<Other extends JoinSource<ScopeTable, string | never>>(other: Other): SelectQuery<QC, MergeScopes<ParentScope, Other[typeof JoinOuterScope]>, EmptyRow>;
+}
+interface WithSelect<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField> = EmptyRow> {
+  select<Columns extends (keyof AvailableScope['topLevel'] & string)[]>(...columns: Columns): SelectQuery<QC, AvailableScope, WithFields<RowType, AvailableScope['topLevel'], Columns>>;
+  select<Alias extends string, Field extends ScopeField>(alias: Alias, expr: (fields: FieldProxy<AvailableScope>, fns: AggregateFunctions<QC>) => Expression<Field>): SelectQuery<QC, AvailableScope, WithField<RowType, Field, Alias>>;
+  select<Result extends Record<string, Expression<ScopeField>>>(callback: (fields: FieldProxy<AvailableScope>, fns: AggregateFunctions<QC>) => Result): SelectQuery<QC, AvailableScope, Expand<RowType & ExtractScopeFields<Result>>>;
+}
+interface WithJoin<QC extends QueryContext, AvailableScope extends Scope, Capabilities> {
+  innerJoin<Other extends JoinSource<ScopeTable, string | never>>(other: Other, on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>): JoinedTables<QC, MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>>;
+  outerLeftJoin<Other extends JoinSource<ScopeTable, string | never>>(other: Other, on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>): JoinedTables<QC, MergeScopes<AvailableScope, NullableScope<Other[typeof JoinOuterScope]>>>;
+  outerRightJoin<Other extends JoinSource<ScopeTable, string | never>>(other: Other, on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>): JoinedTables<QC, MergeScopes<NullableScope<AvailableScope>, Other[typeof JoinOuterScope]>>;
+  outerFullJoin<Other extends JoinSource<ScopeTable, string | never>>(other: Other, on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>): JoinedTables<QC, MergeScopes<NullableScope<AvailableScope>, NullableScope<Other[typeof JoinOuterScope]>>>;
+  lateralJoin: GatedMethod<Capabilities, {
+    sql: {
+      lateral: true;
+    };
+  }, <Alias extends string, LateralRow extends Record<string, ScopeField>>(alias: Alias, builder: (lateral: LateralBuilder<QC, AvailableScope>) => Subquery<LateralRow>) => JoinedTables<QC, MergeScopes<AvailableScope, {
+    topLevel: LateralRow;
+    namespaces: Record<Alias, LateralRow>;
+  }>>>;
+  outerLateralJoin: GatedMethod<Capabilities, {
+    sql: {
+      lateral: true;
+    };
+  }, <Alias extends string, LateralRow extends Record<string, ScopeField>>(alias: Alias, builder: (lateral: LateralBuilder<QC, AvailableScope>) => Subquery<LateralRow>) => JoinedTables<QC, MergeScopes<AvailableScope, NullableScope<{
+    topLevel: LateralRow;
+    namespaces: Record<Alias, LateralRow>;
+  }>>>>;
+}
+type PaginationValue<QC extends QueryContext> = number | TraitExpression<readonly ['numeric'], false, QC['codecTypes']>;
+interface WithPagination<QC extends QueryContext> {
+  limit(count: PaginationValue<QC>): this;
+  offset(count: PaginationValue<QC>): this;
+}
+interface WithDistinct {
+  distinct(): this;
+}
+interface WithAlias<RowType extends Record<string, ScopeField>> {
+  as<Alias extends string>(newAlias: Alias): JoinSource<RowType, Alias>;
+}
+interface WithBuild<QC extends QueryContext, RowType extends Record<string, ScopeField>> {
+  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes'], QC['resolvedColumnOutputTypes']>>;
+}
+//#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 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>;
+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>;
+type ResolvedUpdateExpressions<Table extends StorageTable> = { [K in keyof Table['columns']]?: Expression<{
+  codecId: Table['columns'][K]['codecId'];
+  nullable: boolean;
+}>; };
+type ContractToQC<C extends TableProxyContract, NsId extends string = string, Name extends string = string> = {
+  readonly codecTypes: ExtractCodecTypes<C>;
+  readonly capabilities: C['capabilities'];
+  readonly queryOperationTypes: ExtractQueryOperationTypes<C>;
+  readonly resolvedColumnOutputTypes: ResolvedColumnTypes<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']> {
+  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>;
+  update(callback: (fields: FieldProxy<AvailableScope>, fns: Functions<QC>) => ResolvedUpdateExpressions<NamespaceTable<C, NsId, Name>>): UpdateQuery<QC, AvailableScope, EmptyRow>;
+  delete(): DeleteQuery<QC, AvailableScope, EmptyRow>;
+}
+//#endregion
+//#region src/types/db.d.ts
+type CapabilitiesBase = Record<string, Record<string, boolean>>;
+type NamespaceEntries = Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+type NamespaceDomain = Readonly<Record<string, {
+  readonly models: Readonly<Record<string, unknown>>;
+}>>;
+type TableProxyContract = {
+  readonly domain: {
+    readonly namespaces: NamespaceDomain;
+  };
+  readonly storage: {
+    readonly namespaces: Readonly<Record<string, {
+      readonly entries: NamespaceEntries;
+    }>>;
+  };
+  readonly capabilities: CapabilitiesBase;
+};
+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 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>; };
+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-DhMsmBS--DKENDi3l.d.mts.map

package/dist/db-DhMsmBS--DKENDi3l.d.mts.map

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