@prisma-next/sql-relational-core 0.3.0-pr.94.3 → 0.3.0-pr.94.4

package/dist/exports/ast.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ast.mjs","names":["codec","codecTypes: Record<string, { readonly input: unknown; readonly output: unknown }>","result: Record<\n      string,\n      {\n        typeId: string;\n        scalar: string;\n        codec: Codec;\n        input: unknown;\n        output: unknown;\n        jsType: unknown;\n      }\n    >","out: Record<string, unknown>"],"sources":["../../src/ast/codec-types.ts","../../src/ast/util.ts","../../src/ast/common.ts","../../src/ast/delete.ts","../../src/ast/insert.ts","../../src/ast/join.ts","../../src/ast/order.ts","../../src/ast/predicate.ts","../../src/ast/select.ts","../../src/ast/types.ts","../../src/ast/update.ts"],"sourcesContent":["import type { O } from 'ts-toolbelt';\n\n/**\n * Codec metadata for database-specific type information.\n * Used for schema introspection and verification.\n */\nexport interface CodecMeta {\n  readonly db?: {\n    readonly sql?: {\n      readonly postgres?: {\n        readonly nativeType: string; // e.g. 'integer', 'text', 'vector', 'timestamp with time zone'\n      };\n    };\n  };\n}\n\n/**\n * Codec interface for encoding/decoding values between wire format and JavaScript types.\n *\n * Codecs are pure, synchronous functions with no side effects or IO.\n * They provide deterministic conversion between database wire types and JS values.\n */\nexport interface Codec<Id extends string = string, TWire = unknown, TJs = unknown> {\n  /**\n   * Namespaced codec identifier in format 'namespace/name@version'\n   * Examples: 'pg/text@1', 'pg/uuid@1', 'pg/timestamptz@1'\n   */\n  readonly id: Id;\n\n  /**\n   * Contract scalar type IDs that this codec can handle.\n   * Examples: ['text'], ['int4', 'float8'], ['timestamp', 'timestamptz']\n   */\n  readonly targetTypes: readonly string[];\n\n  /**\n   * Optional metadata for database-specific type information.\n   * Used for schema introspection and verification.\n   */\n  readonly meta?: CodecMeta;\n\n  /**\n   * Decode a wire value (from database) to JavaScript type.\n   * Must be synchronous and pure (no side effects).\n   */\n  decode(wire: TWire): TJs;\n\n  /**\n   * Encode a JavaScript value to wire format (for database).\n   * Optional - if not provided, values pass through unchanged.\n   * Must be synchronous and pure (no side effects).\n   */\n  encode?(value: TJs): TWire;\n}\n\n/**\n * Registry interface for codecs organized by ID and by contract scalar type.\n *\n * The registry allows looking up codecs by their namespaced ID or by the\n * contract scalar types they handle. Multiple codecs may handle the same\n * scalar type; ordering in byScalar reflects preference (adapter first,\n * then packs, then app overrides).\n */\nexport interface CodecRegistry {\n  get(id: string): Codec<string> | undefined;\n  has(id: string): boolean;\n  getByScalar(scalar: string): readonly Codec<string>[];\n  getDefaultCodec(scalar: string): Codec<string> | undefined;\n  register(codec: Codec<string>): void;\n  [Symbol.iterator](): Iterator<Codec<string>>;\n  values(): IterableIterator<Codec<string>>;\n}\n\n/**\n * Implementation of CodecRegistry.\n */\nclass CodecRegistryImpl implements CodecRegistry {\n  private readonly _byId = new Map<string, Codec<string>>();\n  private readonly _byScalar = new Map<string, Codec<string>[]>();\n\n  /**\n   * Map-like interface for codec lookup by ID.\n   * Example: registry.get('pg/text@1')\n   */\n  get(id: string): Codec<string> | undefined {\n    return this._byId.get(id);\n  }\n\n  /**\n   * Check if a codec with the given ID is registered.\n   */\n  has(id: string): boolean {\n    return this._byId.has(id);\n  }\n\n  /**\n   * Get all codecs that handle a given scalar type.\n   * Returns an empty frozen array if no codecs are found.\n   * Example: registry.getByScalar('text') → [codec1, codec2, ...]\n   */\n  getByScalar(scalar: string): readonly Codec<string>[] {\n    return this._byScalar.get(scalar) ?? Object.freeze([]);\n  }\n\n  /**\n   * Get the default codec for a scalar type (first registered codec).\n   * Returns undefined if no codec handles this scalar type.\n   */\n  getDefaultCodec(scalar: string): Codec<string> | undefined {\n    const _codecs = this._byScalar.get(scalar);\n    return _codecs?.[0];\n  }\n\n  /**\n   * Register a codec in the registry.\n   * Throws an error if a codec with the same ID is already registered.\n   *\n   * @param codec - The codec to register\n   * @throws Error if a codec with the same ID already exists\n   */\n  register(codec: Codec<string>): void {\n    if (this._byId.has(codec.id)) {\n      throw new Error(`Codec with ID '${codec.id}' is already registered`);\n    }\n\n    this._byId.set(codec.id, codec);\n\n    // Update byScalar mapping\n    for (const scalarType of codec.targetTypes) {\n      const existing = this._byScalar.get(scalarType);\n      if (existing) {\n        existing.push(codec);\n      } else {\n        this._byScalar.set(scalarType, [codec]);\n      }\n    }\n  }\n\n  /**\n   * Returns an iterator over all registered codecs.\n   * Useful for iterating through codecs from another registry.\n   */\n  *[Symbol.iterator](): Iterator<Codec<string>> {\n    for (const codec of this._byId.values()) {\n      yield codec;\n    }\n  }\n\n  /**\n   * Returns an iterable of all registered codecs.\n   */\n  values(): IterableIterator<Codec<string>> {\n    return this._byId.values();\n  }\n}\n\n/**\n * Codec factory - creates a codec with typeId and encode/decode functions.\n */\nexport function codec<Id extends string, TWire, TJs>(config: {\n  typeId: Id;\n  targetTypes: readonly string[];\n  encode: (value: TJs) => TWire;\n  decode: (wire: TWire) => TJs;\n  meta?: CodecMeta;\n}): Codec<Id, TWire, TJs> {\n  return {\n    id: config.typeId,\n    targetTypes: config.targetTypes,\n    ...(config.meta ? { meta: config.meta } : {}),\n    encode: config.encode,\n    decode: config.decode,\n  };\n}\n\n/**\n * Type helpers to extract codec types.\n */\nexport type CodecId<T> =\n  T extends Codec<infer Id, unknown, unknown>\n    ? Id\n    : T extends { readonly id: infer Id }\n      ? Id\n      : never;\nexport type CodecInput<T> = T extends Codec<string, unknown, infer JsT> ? JsT : never;\nexport type CodecOutput<T> = T extends Codec<string, unknown, infer JsT> ? JsT : never;\n\n/**\n * Type helper to extract codec types from builder instance.\n */\nexport type ExtractCodecTypes<\n  ScalarNames extends { readonly [K in keyof ScalarNames]: Codec<string> } = Record<never, never>,\n> = {\n  readonly [K in keyof ScalarNames as ScalarNames[K] extends Codec<infer Id, unknown, unknown>\n    ? Id\n    : never]: {\n    readonly input: CodecInput<ScalarNames[K]>;\n    readonly output: CodecOutput<ScalarNames[K]>;\n  };\n};\n\n/**\n * Type helper to extract data type IDs from builder instance.\n * Uses ExtractCodecTypes which preserves literal types as keys.\n * Since ExtractCodecTypes<Record<K, ScalarNames[K]>> has exactly one key (the Id),\n * we extract it by creating a mapped type that uses the Id as both key and value,\n * then extract the value type. This preserves literal types.\n */\nexport type ExtractDataTypes<\n  ScalarNames extends { readonly [K in keyof ScalarNames]: Codec<string> },\n> = {\n  readonly [K in keyof ScalarNames]: {\n    readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id;\n  }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>];\n};\n\n/**\n * Builder interface for declaring codecs.\n */\nexport interface CodecDefBuilder<\n  ScalarNames extends { readonly [K in keyof ScalarNames]: Codec<string> } = Record<never, never>,\n> {\n  readonly CodecTypes: ExtractCodecTypes<ScalarNames>;\n\n  add<ScalarName extends string, CodecImpl extends Codec<string>>(\n    scalarName: ScalarName,\n    codecImpl: CodecImpl,\n  ): CodecDefBuilder<\n    O.Overwrite<ScalarNames, Record<ScalarName, CodecImpl>> & Record<ScalarName, CodecImpl>\n  >;\n\n  readonly codecDefinitions: {\n    readonly [K in keyof ScalarNames]: {\n      readonly typeId: ScalarNames[K] extends Codec<infer Id extends string, unknown, unknown>\n        ? Id\n        : never;\n      readonly scalar: K;\n      readonly codec: ScalarNames[K];\n      readonly input: CodecInput<ScalarNames[K]>;\n      readonly output: CodecOutput<ScalarNames[K]>;\n      readonly jsType: CodecOutput<ScalarNames[K]>;\n    };\n  };\n\n  readonly dataTypes: {\n    readonly [K in keyof ScalarNames]: {\n      readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id;\n    }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>];\n  };\n}\n\n/**\n * Implementation of CodecDefBuilder.\n */\nclass CodecDefBuilderImpl<\n  ScalarNames extends { readonly [K in keyof ScalarNames]: Codec<string> } = Record<never, never>,\n> implements CodecDefBuilder<ScalarNames>\n{\n  private readonly _codecs: ScalarNames;\n\n  public readonly CodecTypes: ExtractCodecTypes<ScalarNames>;\n  public readonly dataTypes: {\n    readonly [K in keyof ScalarNames]: {\n      readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id;\n    }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>];\n  };\n\n  constructor(codecs: ScalarNames) {\n    this._codecs = codecs;\n\n    // Populate CodecTypes from codecs\n    const codecTypes: Record<string, { readonly input: unknown; readonly output: unknown }> = {};\n    for (const [, codecImpl] of Object.entries(this._codecs)) {\n      const codecImplTyped = codecImpl as Codec<string>;\n      codecTypes[codecImplTyped.id] = {\n        input: undefined as unknown as CodecInput<typeof codecImplTyped>,\n        output: undefined as unknown as CodecOutput<typeof codecImplTyped>,\n      };\n    }\n    this.CodecTypes = codecTypes as ExtractCodecTypes<ScalarNames>;\n\n    // Populate dataTypes from codecs - extract id property from each codec\n    // Build object preserving keys from ScalarNames\n    // Type assertion is safe because we know ScalarNames structure matches the return type\n    // biome-ignore lint/suspicious/noExplicitAny: dynamic codec mapping requires any\n    const dataTypes = {} as any;\n    for (const key in this._codecs) {\n      if (Object.hasOwn(this._codecs, key)) {\n        const codec = this._codecs[key] as Codec<string>;\n        dataTypes[key] = codec.id;\n      }\n    }\n    this.dataTypes = dataTypes as {\n      readonly [K in keyof ScalarNames]: {\n        readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id;\n      }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>];\n    };\n  }\n\n  add<ScalarName extends string, CodecImpl extends Codec<string>>(\n    scalarName: ScalarName,\n    codecImpl: CodecImpl,\n  ): CodecDefBuilder<\n    O.Overwrite<ScalarNames, Record<ScalarName, CodecImpl>> & Record<ScalarName, CodecImpl>\n  > {\n    return new CodecDefBuilderImpl({\n      ...this._codecs,\n      [scalarName]: codecImpl,\n    } as O.Overwrite<ScalarNames, Record<ScalarName, CodecImpl>> & Record<ScalarName, CodecImpl>);\n  }\n\n  /**\n   * Derive codecDefinitions structure.\n   */\n  get codecDefinitions(): {\n    readonly [K in keyof ScalarNames]: {\n      readonly typeId: ScalarNames[K] extends Codec<infer Id, unknown, unknown> ? Id : never;\n      readonly scalar: K;\n      readonly codec: ScalarNames[K];\n      readonly input: CodecInput<ScalarNames[K]>;\n      readonly output: CodecOutput<ScalarNames[K]>;\n      readonly jsType: CodecOutput<ScalarNames[K]>;\n    };\n  } {\n    const result: Record<\n      string,\n      {\n        typeId: string;\n        scalar: string;\n        codec: Codec;\n        input: unknown;\n        output: unknown;\n        jsType: unknown;\n      }\n    > = {};\n\n    for (const [scalarName, codecImpl] of Object.entries(this._codecs)) {\n      const codec = codecImpl as Codec<string>;\n      result[scalarName] = {\n        typeId: codec.id,\n        scalar: scalarName,\n        codec: codec,\n        input: undefined as unknown as CodecInput<typeof codec>,\n        output: undefined as unknown as CodecOutput<typeof codec>,\n        jsType: undefined as unknown as CodecOutput<typeof codec>,\n      };\n    }\n\n    return result as {\n      readonly [K in keyof ScalarNames]: {\n        readonly typeId: ScalarNames[K] extends Codec<infer Id extends string, unknown, unknown>\n          ? Id\n          : never;\n        readonly scalar: K;\n        readonly codec: ScalarNames[K];\n        readonly input: CodecInput<ScalarNames[K]>;\n        readonly output: CodecOutput<ScalarNames[K]>;\n        readonly jsType: CodecOutput<ScalarNames[K]>;\n      };\n    };\n  }\n}\n\n/**\n * Create a new codec registry.\n */\nexport function createCodecRegistry(): CodecRegistry {\n  return new CodecRegistryImpl();\n}\n\n/**\n * Create a new codec definition builder.\n */\nexport function defineCodecs(): CodecDefBuilder<Record<never, never>> {\n  return new CodecDefBuilderImpl({});\n}\n","export function compact<T extends Record<string, unknown>>(o: T): T {\n  const out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(o)) {\n    if (v === undefined || v === null) continue;\n    if (Array.isArray(v) && v.length === 0) continue;\n    out[k] = v;\n  }\n  return out as T;\n}\n","import type { ColumnRef, LiteralExpr, OperationExpr, ParamRef, TableRef } from './types';\nimport { compact } from './util';\n\nexport function createTableRef(name: string): TableRef {\n  return {\n    kind: 'table',\n    name,\n  };\n}\n\nexport function createColumnRef(table: string, column: string): ColumnRef {\n  return {\n    kind: 'col',\n    table,\n    column,\n  };\n}\n\nexport function createParamRef(index: number, name?: string): ParamRef {\n  return compact({\n    kind: 'param',\n    index,\n    name,\n  }) as ParamRef;\n}\n\nexport function createOperationExpr(operation: OperationExpr): OperationExpr {\n  return operation;\n}\n\nexport function createLiteralExpr(value: unknown): LiteralExpr {\n  return {\n    kind: 'literal',\n    value,\n  };\n}\n","import type { BinaryExpr, ColumnRef, DeleteAst, TableRef } from './types';\nimport { compact } from './util';\n\nexport interface CreateDeleteAstOptions {\n  readonly table: TableRef;\n  readonly where: BinaryExpr;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport function createDeleteAst(options: CreateDeleteAstOptions): DeleteAst {\n  return compact({\n    kind: 'delete',\n    table: options.table,\n    where: options.where,\n    returning: options.returning,\n  }) as DeleteAst;\n}\n","import type { ColumnRef, InsertAst, ParamRef, TableRef } from './types';\nimport { compact } from './util';\n\nexport interface CreateInsertAstOptions {\n  readonly table: TableRef;\n  readonly values: Record<string, ColumnRef | ParamRef>;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport function createInsertAst(options: CreateInsertAstOptions): InsertAst {\n  return compact({\n    kind: 'insert',\n    table: options.table,\n    values: options.values,\n    returning: options.returning,\n  }) as InsertAst;\n}\n","import { planInvalid } from '@prisma-next/plan';\nimport type { AnyColumnBuilder, JoinOnBuilder, JoinOnPredicate } from '../types';\nimport { isColumnBuilder } from '../types';\nimport type { ColumnRef, JoinAst, JoinOnExpr, TableRef } from './types';\n\nexport function createJoin(\n  joinType: 'inner' | 'left' | 'right' | 'full',\n  table: TableRef,\n  on: JoinOnExpr,\n): JoinAst {\n  return {\n    kind: 'join',\n    joinType,\n    table,\n    on,\n  };\n}\n\nexport function createJoinOnExpr(left: ColumnRef, right: ColumnRef): JoinOnExpr {\n  return {\n    kind: 'eqCol',\n    left,\n    right,\n  };\n}\n\nclass JoinOnBuilderImpl implements JoinOnBuilder {\n  eqCol(left: AnyColumnBuilder, right: AnyColumnBuilder): JoinOnPredicate {\n    if (!left || !isColumnBuilder(left)) {\n      throw planInvalid('Join ON left operand must be a column');\n    }\n\n    if (!right || !isColumnBuilder(right)) {\n      throw planInvalid('Join ON right operand must be a column');\n    }\n\n    // TypeScript can't narrow ColumnBuilder properly, so we assert\n    const leftCol = left as unknown as { table: string; column: string };\n    const rightCol = right as unknown as { table: string; column: string };\n    if (leftCol.table === rightCol.table) {\n      throw planInvalid('Self-joins are not supported in MVP');\n    }\n\n    return {\n      kind: 'join-on',\n      left: left as AnyColumnBuilder,\n      right: right as AnyColumnBuilder,\n    };\n  }\n}\n\nexport function createJoinOnBuilder(): JoinOnBuilder {\n  return new JoinOnBuilderImpl();\n}\n","import type { ColumnRef, Direction, OperationExpr } from './types';\n\nexport function createOrderByItem(\n  expr: ColumnRef | OperationExpr,\n  dir: 'asc' | 'desc',\n): { expr: ColumnRef | OperationExpr; dir: Direction } {\n  return {\n    expr,\n    dir,\n  };\n}\n","import type { BinaryExpr, BinaryOp, ExistsExpr, Expression, ParamRef, SelectAst } from './types';\n\nexport function createBinaryExpr(\n  op: BinaryOp,\n  left: Expression,\n  right: Expression | ParamRef,\n): BinaryExpr {\n  return {\n    kind: 'bin',\n    op,\n    left,\n    right,\n  };\n}\n\nexport function createExistsExpr(not: boolean, subquery: SelectAst): ExistsExpr {\n  return {\n    kind: 'exists',\n    not,\n    subquery,\n  };\n}\n","import type {\n  BinaryExpr,\n  ColumnRef,\n  Direction,\n  ExistsExpr,\n  IncludeAst,\n  IncludeRef,\n  JoinAst,\n  OperationExpr,\n  SelectAst,\n  TableRef,\n} from './types';\nimport { compact } from './util';\n\nexport interface CreateSelectAstOptions {\n  readonly from: TableRef;\n  readonly joins?: ReadonlyArray<JoinAst>;\n  readonly includes?: ReadonlyArray<IncludeAst>;\n  readonly project: ReadonlyArray<{\n    alias: string;\n    expr: ColumnRef | IncludeRef | OperationExpr;\n  }>;\n  readonly where?: BinaryExpr | ExistsExpr;\n  readonly orderBy?: ReadonlyArray<{ expr: ColumnRef | OperationExpr; dir: Direction }>;\n  readonly limit?: number;\n}\n\nexport function createSelectAst(options: CreateSelectAstOptions): SelectAst {\n  return compact({\n    kind: 'select',\n    from: options.from,\n    joins: options.joins,\n    includes: options.includes,\n    project: options.project,\n    where: options.where,\n    orderBy: options.orderBy,\n    limit: options.limit,\n  }) as SelectAst;\n}\n","import type { ReturnSpec } from '@prisma-next/operations';\nimport type { SqlLoweringSpec } from '@prisma-next/sql-operations';\n\n// SQL-specific AST types and supporting types\n// These types are needed by adapters and runtime for SQL query execution\n\nexport type Direction = 'asc' | 'desc';\n\nexport interface TableRef {\n  readonly kind: 'table';\n  readonly name: string;\n}\n\nexport interface ColumnRef {\n  readonly kind: 'col';\n  readonly table: string;\n  readonly column: string;\n}\n\nexport interface ParamRef {\n  readonly kind: 'param';\n  readonly index: number;\n  readonly name?: string;\n}\n\nexport interface LiteralExpr {\n  readonly kind: 'literal';\n  readonly value: unknown;\n}\n\nexport interface OperationExpr {\n  readonly kind: 'operation';\n  readonly method: string;\n  readonly forTypeId: string;\n  readonly self: Expression;\n  readonly args: ReadonlyArray<Expression | ParamRef | LiteralExpr>;\n  readonly returns: ReturnSpec;\n  readonly lowering: SqlLoweringSpec;\n}\n\n/**\n * Unified expression type - the canonical AST representation for column references\n * and operation expressions. This is what all builders convert to via toExpr().\n */\nexport type Expression = ColumnRef | OperationExpr;\n\n/**\n * Interface for any builder that can produce an Expression.\n * Implemented by ColumnBuilder and ExpressionBuilder.\n */\nexport interface ExpressionSource {\n  toExpr(): Expression;\n}\n\nexport function isOperationExpr(expr: Expression): expr is OperationExpr {\n  return expr.kind === 'operation';\n}\n\nexport type BinaryOp = 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte';\n\nexport interface BinaryExpr {\n  readonly kind: 'bin';\n  readonly op: BinaryOp;\n  readonly left: Expression;\n  readonly right: Expression | ParamRef;\n}\n\nexport interface ExistsExpr {\n  readonly kind: 'exists';\n  readonly not: boolean;\n  readonly subquery: SelectAst;\n}\n\nexport type JoinOnExpr = {\n  readonly kind: 'eqCol';\n  readonly left: ColumnRef;\n  readonly right: ColumnRef;\n};\n\nexport interface JoinAst {\n  readonly kind: 'join';\n  readonly joinType: 'inner' | 'left' | 'right' | 'full';\n  readonly table: TableRef;\n  readonly on: JoinOnExpr;\n}\n\nexport interface IncludeRef {\n  readonly kind: 'includeRef';\n  readonly alias: string;\n}\n\nexport interface IncludeAst {\n  readonly kind: 'includeMany';\n  readonly alias: string;\n  readonly child: {\n    readonly table: TableRef;\n    readonly on: JoinOnExpr;\n    readonly where?: BinaryExpr | ExistsExpr;\n    readonly orderBy?: ReadonlyArray<{ expr: Expression; dir: Direction }>;\n    readonly limit?: number;\n    readonly project: ReadonlyArray<{ alias: string; expr: Expression }>;\n  };\n}\n\nexport interface SelectAst {\n  readonly kind: 'select';\n  readonly from: TableRef;\n  readonly joins?: ReadonlyArray<JoinAst>;\n  readonly includes?: ReadonlyArray<IncludeAst>;\n  readonly project: ReadonlyArray<{\n    alias: string;\n    expr: Expression | IncludeRef | LiteralExpr;\n  }>;\n  readonly where?: BinaryExpr | ExistsExpr;\n  readonly orderBy?: ReadonlyArray<{ expr: Expression; dir: Direction }>;\n  readonly limit?: number;\n}\n\nexport interface InsertAst {\n  readonly kind: 'insert';\n  readonly table: TableRef;\n  readonly values: Record<string, ColumnRef | ParamRef>;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport interface UpdateAst {\n  readonly kind: 'update';\n  readonly table: TableRef;\n  readonly set: Record<string, ColumnRef | ParamRef>;\n  readonly where: BinaryExpr;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport interface DeleteAst {\n  readonly kind: 'delete';\n  readonly table: TableRef;\n  readonly where: BinaryExpr;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport type QueryAst = SelectAst | InsertAst | UpdateAst | DeleteAst;\n\nexport interface LoweredStatement {\n  readonly sql: string;\n  readonly params: readonly unknown[];\n  readonly annotations?: Record<string, unknown>;\n}\n","import type { BinaryExpr, ColumnRef, ParamRef, TableRef, UpdateAst } from './types';\nimport { compact } from './util';\n\nexport interface CreateUpdateAstOptions {\n  readonly table: TableRef;\n  readonly set: Record<string, ColumnRef | ParamRef>;\n  readonly where: BinaryExpr;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport function createUpdateAst(options: CreateUpdateAstOptions): UpdateAst {\n  return compact({\n    kind: 'update',\n    table: options.table,\n    set: options.set,\n    where: options.where,\n    returning: options.returning,\n  }) as UpdateAst;\n}\n"],"mappings":"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"}
+{"version":3,"file":"ast.mjs","names":["codec","codecTypes: Record<string, { readonly input: unknown; readonly output: unknown }>","result: Record<\n      string,\n      {\n        typeId: string;\n        scalar: string;\n        codec: Codec;\n        input: unknown;\n        output: unknown;\n        jsType: unknown;\n      }\n    >","out: Record<string, unknown>"],"sources":["../../src/ast/codec-types.ts","../../src/ast/util.ts","../../src/ast/common.ts","../../src/ast/delete.ts","../../src/ast/insert.ts","../../src/ast/join.ts","../../src/ast/order.ts","../../src/ast/predicate.ts","../../src/ast/select.ts","../../src/ast/types.ts","../../src/ast/update.ts"],"sourcesContent":["import type { O } from 'ts-toolbelt';\n\n/**\n * Codec metadata for database-specific type information.\n * Used for schema introspection and verification.\n */\nexport interface CodecMeta {\n  readonly db?: {\n    readonly sql?: {\n      readonly postgres?: {\n        readonly nativeType: string; // e.g. 'integer', 'text', 'vector', 'timestamp with time zone'\n      };\n    };\n  };\n}\n\n/**\n * Codec interface for encoding/decoding values between wire format and JavaScript types.\n *\n * Codecs are pure, synchronous functions with no side effects or IO.\n * They provide deterministic conversion between database wire types and JS values.\n */\nexport interface Codec<Id extends string = string, TWire = unknown, TJs = unknown> {\n  /**\n   * Namespaced codec identifier in format 'namespace/name@version'\n   * Examples: 'pg/text@1', 'pg/uuid@1', 'pg/timestamptz@1'\n   */\n  readonly id: Id;\n\n  /**\n   * Contract scalar type IDs that this codec can handle.\n   * Examples: ['text'], ['int4', 'float8'], ['timestamp', 'timestamptz']\n   */\n  readonly targetTypes: readonly string[];\n\n  /**\n   * Optional metadata for database-specific type information.\n   * Used for schema introspection and verification.\n   */\n  readonly meta?: CodecMeta;\n\n  /**\n   * Decode a wire value (from database) to JavaScript type.\n   * Must be synchronous and pure (no side effects).\n   */\n  decode(wire: TWire): TJs;\n\n  /**\n   * Encode a JavaScript value to wire format (for database).\n   * Optional - if not provided, values pass through unchanged.\n   * Must be synchronous and pure (no side effects).\n   */\n  encode?(value: TJs): TWire;\n}\n\n/**\n * Registry interface for codecs organized by ID and by contract scalar type.\n *\n * The registry allows looking up codecs by their namespaced ID or by the\n * contract scalar types they handle. Multiple codecs may handle the same\n * scalar type; ordering in byScalar reflects preference (adapter first,\n * then packs, then app overrides).\n */\nexport interface CodecRegistry {\n  get(id: string): Codec<string> | undefined;\n  has(id: string): boolean;\n  getByScalar(scalar: string): readonly Codec<string>[];\n  getDefaultCodec(scalar: string): Codec<string> | undefined;\n  register(codec: Codec<string>): void;\n  [Symbol.iterator](): Iterator<Codec<string>>;\n  values(): IterableIterator<Codec<string>>;\n}\n\n/**\n * Implementation of CodecRegistry.\n */\nclass CodecRegistryImpl implements CodecRegistry {\n  private readonly _byId = new Map<string, Codec<string>>();\n  private readonly _byScalar = new Map<string, Codec<string>[]>();\n\n  /**\n   * Map-like interface for codec lookup by ID.\n   * Example: registry.get('pg/text@1')\n   */\n  get(id: string): Codec<string> | undefined {\n    return this._byId.get(id);\n  }\n\n  /**\n   * Check if a codec with the given ID is registered.\n   */\n  has(id: string): boolean {\n    return this._byId.has(id);\n  }\n\n  /**\n   * Get all codecs that handle a given scalar type.\n   * Returns an empty frozen array if no codecs are found.\n   * Example: registry.getByScalar('text') → [codec1, codec2, ...]\n   */\n  getByScalar(scalar: string): readonly Codec<string>[] {\n    return this._byScalar.get(scalar) ?? Object.freeze([]);\n  }\n\n  /**\n   * Get the default codec for a scalar type (first registered codec).\n   * Returns undefined if no codec handles this scalar type.\n   */\n  getDefaultCodec(scalar: string): Codec<string> | undefined {\n    const _codecs = this._byScalar.get(scalar);\n    return _codecs?.[0];\n  }\n\n  /**\n   * Register a codec in the registry.\n   * Throws an error if a codec with the same ID is already registered.\n   *\n   * @param codec - The codec to register\n   * @throws Error if a codec with the same ID already exists\n   */\n  register(codec: Codec<string>): void {\n    if (this._byId.has(codec.id)) {\n      throw new Error(`Codec with ID '${codec.id}' is already registered`);\n    }\n\n    this._byId.set(codec.id, codec);\n\n    // Update byScalar mapping\n    for (const scalarType of codec.targetTypes) {\n      const existing = this._byScalar.get(scalarType);\n      if (existing) {\n        existing.push(codec);\n      } else {\n        this._byScalar.set(scalarType, [codec]);\n      }\n    }\n  }\n\n  /**\n   * Returns an iterator over all registered codecs.\n   * Useful for iterating through codecs from another registry.\n   */\n  *[Symbol.iterator](): Iterator<Codec<string>> {\n    for (const codec of this._byId.values()) {\n      yield codec;\n    }\n  }\n\n  /**\n   * Returns an iterable of all registered codecs.\n   */\n  values(): IterableIterator<Codec<string>> {\n    return this._byId.values();\n  }\n}\n\n/**\n * Codec factory - creates a codec with typeId and encode/decode functions.\n */\nexport function codec<Id extends string, TWire, TJs>(config: {\n  typeId: Id;\n  targetTypes: readonly string[];\n  encode: (value: TJs) => TWire;\n  decode: (wire: TWire) => TJs;\n  meta?: CodecMeta;\n}): Codec<Id, TWire, TJs> {\n  return {\n    id: config.typeId,\n    targetTypes: config.targetTypes,\n    ...(config.meta ? { meta: config.meta } : {}),\n    encode: config.encode,\n    decode: config.decode,\n  };\n}\n\n/**\n * Type helpers to extract codec types.\n */\nexport type CodecId<T> =\n  T extends Codec<infer Id, unknown, unknown>\n    ? Id\n    : T extends { readonly id: infer Id }\n      ? Id\n      : never;\nexport type CodecInput<T> = T extends Codec<string, unknown, infer JsT> ? JsT : never;\nexport type CodecOutput<T> = T extends Codec<string, unknown, infer JsT> ? JsT : never;\n\n/**\n * Type helper to extract codec types from builder instance.\n */\nexport type ExtractCodecTypes<\n  ScalarNames extends { readonly [K in keyof ScalarNames]: Codec<string> } = Record<never, never>,\n> = {\n  readonly [K in keyof ScalarNames as ScalarNames[K] extends Codec<infer Id, unknown, unknown>\n    ? Id\n    : never]: {\n    readonly input: CodecInput<ScalarNames[K]>;\n    readonly output: CodecOutput<ScalarNames[K]>;\n  };\n};\n\n/**\n * Type helper to extract data type IDs from builder instance.\n * Uses ExtractCodecTypes which preserves literal types as keys.\n * Since ExtractCodecTypes<Record<K, ScalarNames[K]>> has exactly one key (the Id),\n * we extract it by creating a mapped type that uses the Id as both key and value,\n * then extract the value type. This preserves literal types.\n */\nexport type ExtractDataTypes<\n  ScalarNames extends { readonly [K in keyof ScalarNames]: Codec<string> },\n> = {\n  readonly [K in keyof ScalarNames]: {\n    readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id;\n  }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>];\n};\n\n/**\n * Builder interface for declaring codecs.\n */\nexport interface CodecDefBuilder<\n  ScalarNames extends { readonly [K in keyof ScalarNames]: Codec<string> } = Record<never, never>,\n> {\n  readonly CodecTypes: ExtractCodecTypes<ScalarNames>;\n\n  add<ScalarName extends string, CodecImpl extends Codec<string>>(\n    scalarName: ScalarName,\n    codecImpl: CodecImpl,\n  ): CodecDefBuilder<\n    O.Overwrite<ScalarNames, Record<ScalarName, CodecImpl>> & Record<ScalarName, CodecImpl>\n  >;\n\n  readonly codecDefinitions: {\n    readonly [K in keyof ScalarNames]: {\n      readonly typeId: ScalarNames[K] extends Codec<infer Id extends string, unknown, unknown>\n        ? Id\n        : never;\n      readonly scalar: K;\n      readonly codec: ScalarNames[K];\n      readonly input: CodecInput<ScalarNames[K]>;\n      readonly output: CodecOutput<ScalarNames[K]>;\n      readonly jsType: CodecOutput<ScalarNames[K]>;\n    };\n  };\n\n  readonly dataTypes: {\n    readonly [K in keyof ScalarNames]: {\n      readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id;\n    }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>];\n  };\n}\n\n/**\n * Implementation of CodecDefBuilder.\n */\nclass CodecDefBuilderImpl<\n  ScalarNames extends { readonly [K in keyof ScalarNames]: Codec<string> } = Record<never, never>,\n> implements CodecDefBuilder<ScalarNames>\n{\n  private readonly _codecs: ScalarNames;\n\n  public readonly CodecTypes: ExtractCodecTypes<ScalarNames>;\n  public readonly dataTypes: {\n    readonly [K in keyof ScalarNames]: {\n      readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id;\n    }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>];\n  };\n\n  constructor(codecs: ScalarNames) {\n    this._codecs = codecs;\n\n    // Populate CodecTypes from codecs\n    const codecTypes: Record<string, { readonly input: unknown; readonly output: unknown }> = {};\n    for (const [, codecImpl] of Object.entries(this._codecs)) {\n      const codecImplTyped = codecImpl as Codec<string>;\n      codecTypes[codecImplTyped.id] = {\n        input: undefined as unknown as CodecInput<typeof codecImplTyped>,\n        output: undefined as unknown as CodecOutput<typeof codecImplTyped>,\n      };\n    }\n    this.CodecTypes = codecTypes as ExtractCodecTypes<ScalarNames>;\n\n    // Populate dataTypes from codecs - extract id property from each codec\n    // Build object preserving keys from ScalarNames\n    // Type assertion is safe because we know ScalarNames structure matches the return type\n    // biome-ignore lint/suspicious/noExplicitAny: dynamic codec mapping requires any\n    const dataTypes = {} as any;\n    for (const key in this._codecs) {\n      if (Object.hasOwn(this._codecs, key)) {\n        const codec = this._codecs[key] as Codec<string>;\n        dataTypes[key] = codec.id;\n      }\n    }\n    this.dataTypes = dataTypes as {\n      readonly [K in keyof ScalarNames]: {\n        readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id;\n      }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>];\n    };\n  }\n\n  add<ScalarName extends string, CodecImpl extends Codec<string>>(\n    scalarName: ScalarName,\n    codecImpl: CodecImpl,\n  ): CodecDefBuilder<\n    O.Overwrite<ScalarNames, Record<ScalarName, CodecImpl>> & Record<ScalarName, CodecImpl>\n  > {\n    return new CodecDefBuilderImpl({\n      ...this._codecs,\n      [scalarName]: codecImpl,\n    } as O.Overwrite<ScalarNames, Record<ScalarName, CodecImpl>> & Record<ScalarName, CodecImpl>);\n  }\n\n  /**\n   * Derive codecDefinitions structure.\n   */\n  get codecDefinitions(): {\n    readonly [K in keyof ScalarNames]: {\n      readonly typeId: ScalarNames[K] extends Codec<infer Id, unknown, unknown> ? Id : never;\n      readonly scalar: K;\n      readonly codec: ScalarNames[K];\n      readonly input: CodecInput<ScalarNames[K]>;\n      readonly output: CodecOutput<ScalarNames[K]>;\n      readonly jsType: CodecOutput<ScalarNames[K]>;\n    };\n  } {\n    const result: Record<\n      string,\n      {\n        typeId: string;\n        scalar: string;\n        codec: Codec;\n        input: unknown;\n        output: unknown;\n        jsType: unknown;\n      }\n    > = {};\n\n    for (const [scalarName, codecImpl] of Object.entries(this._codecs)) {\n      const codec = codecImpl as Codec<string>;\n      result[scalarName] = {\n        typeId: codec.id,\n        scalar: scalarName,\n        codec: codec,\n        input: undefined as unknown as CodecInput<typeof codec>,\n        output: undefined as unknown as CodecOutput<typeof codec>,\n        jsType: undefined as unknown as CodecOutput<typeof codec>,\n      };\n    }\n\n    return result as {\n      readonly [K in keyof ScalarNames]: {\n        readonly typeId: ScalarNames[K] extends Codec<infer Id extends string, unknown, unknown>\n          ? Id\n          : never;\n        readonly scalar: K;\n        readonly codec: ScalarNames[K];\n        readonly input: CodecInput<ScalarNames[K]>;\n        readonly output: CodecOutput<ScalarNames[K]>;\n        readonly jsType: CodecOutput<ScalarNames[K]>;\n      };\n    };\n  }\n}\n\n/**\n * Create a new codec registry.\n */\nexport function createCodecRegistry(): CodecRegistry {\n  return new CodecRegistryImpl();\n}\n\n/**\n * Create a new codec definition builder.\n */\nexport function defineCodecs(): CodecDefBuilder<Record<never, never>> {\n  return new CodecDefBuilderImpl({});\n}\n","export function compact<T extends Record<string, unknown>>(o: T): T {\n  const out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(o)) {\n    if (v === undefined || v === null) continue;\n    if (Array.isArray(v) && v.length === 0) continue;\n    out[k] = v;\n  }\n  return out as T;\n}\n","import type { ColumnRef, LiteralExpr, OperationExpr, ParamRef, TableRef } from './types.ts';\nimport { compact } from './util.ts';\n\nexport function createTableRef(name: string): TableRef {\n  return {\n    kind: 'table',\n    name,\n  };\n}\n\nexport function createColumnRef(table: string, column: string): ColumnRef {\n  return {\n    kind: 'col',\n    table,\n    column,\n  };\n}\n\nexport function createParamRef(index: number, name?: string): ParamRef {\n  return compact({\n    kind: 'param',\n    index,\n    name,\n  }) as ParamRef;\n}\n\nexport function createOperationExpr(operation: OperationExpr): OperationExpr {\n  return operation;\n}\n\nexport function createLiteralExpr(value: unknown): LiteralExpr {\n  return {\n    kind: 'literal',\n    value,\n  };\n}\n","import type { BinaryExpr, ColumnRef, DeleteAst, TableRef } from './types.ts';\nimport { compact } from './util.ts';\n\nexport interface CreateDeleteAstOptions {\n  readonly table: TableRef;\n  readonly where: BinaryExpr;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport function createDeleteAst(options: CreateDeleteAstOptions): DeleteAst {\n  return compact({\n    kind: 'delete',\n    table: options.table,\n    where: options.where,\n    returning: options.returning,\n  }) as DeleteAst;\n}\n","import type { ColumnRef, InsertAst, ParamRef, TableRef } from './types.ts';\nimport { compact } from './util.ts';\n\nexport interface CreateInsertAstOptions {\n  readonly table: TableRef;\n  readonly values: Record<string, ColumnRef | ParamRef>;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport function createInsertAst(options: CreateInsertAstOptions): InsertAst {\n  return compact({\n    kind: 'insert',\n    table: options.table,\n    values: options.values,\n    returning: options.returning,\n  }) as InsertAst;\n}\n","import { planInvalid } from '@prisma-next/plan';\nimport type { AnyColumnBuilder, JoinOnBuilder, JoinOnPredicate } from '../types.ts';\nimport { isColumnBuilder } from '../types.ts';\nimport type { ColumnRef, JoinAst, JoinOnExpr, TableRef } from './types.ts';\n\nexport function createJoin(\n  joinType: 'inner' | 'left' | 'right' | 'full',\n  table: TableRef,\n  on: JoinOnExpr,\n): JoinAst {\n  return {\n    kind: 'join',\n    joinType,\n    table,\n    on,\n  };\n}\n\nexport function createJoinOnExpr(left: ColumnRef, right: ColumnRef): JoinOnExpr {\n  return {\n    kind: 'eqCol',\n    left,\n    right,\n  };\n}\n\nclass JoinOnBuilderImpl implements JoinOnBuilder {\n  eqCol(left: AnyColumnBuilder, right: AnyColumnBuilder): JoinOnPredicate {\n    if (!left || !isColumnBuilder(left)) {\n      throw planInvalid('Join ON left operand must be a column');\n    }\n\n    if (!right || !isColumnBuilder(right)) {\n      throw planInvalid('Join ON right operand must be a column');\n    }\n\n    // TypeScript can't narrow ColumnBuilder properly, so we assert\n    const leftCol = left as unknown as { table: string; column: string };\n    const rightCol = right as unknown as { table: string; column: string };\n    if (leftCol.table === rightCol.table) {\n      throw planInvalid('Self-joins are not supported in MVP');\n    }\n\n    return {\n      kind: 'join-on',\n      left: left as AnyColumnBuilder,\n      right: right as AnyColumnBuilder,\n    };\n  }\n}\n\nexport function createJoinOnBuilder(): JoinOnBuilder {\n  return new JoinOnBuilderImpl();\n}\n","import type { ColumnRef, Direction, OperationExpr } from './types.ts';\n\nexport function createOrderByItem(\n  expr: ColumnRef | OperationExpr,\n  dir: 'asc' | 'desc',\n): { expr: ColumnRef | OperationExpr; dir: Direction } {\n  return {\n    expr,\n    dir,\n  };\n}\n","import type { BinaryExpr, BinaryOp, ExistsExpr, Expression, ParamRef, SelectAst } from './types.ts';\n\nexport function createBinaryExpr(\n  op: BinaryOp,\n  left: Expression,\n  right: Expression | ParamRef,\n): BinaryExpr {\n  return {\n    kind: 'bin',\n    op,\n    left,\n    right,\n  };\n}\n\nexport function createExistsExpr(not: boolean, subquery: SelectAst): ExistsExpr {\n  return {\n    kind: 'exists',\n    not,\n    subquery,\n  };\n}\n","import type {\n  BinaryExpr,\n  ColumnRef,\n  Direction,\n  ExistsExpr,\n  IncludeAst,\n  IncludeRef,\n  JoinAst,\n  OperationExpr,\n  SelectAst,\n  TableRef,\n} from './types.ts';\nimport { compact } from './util.ts';\n\nexport interface CreateSelectAstOptions {\n  readonly from: TableRef;\n  readonly joins?: ReadonlyArray<JoinAst>;\n  readonly includes?: ReadonlyArray<IncludeAst>;\n  readonly project: ReadonlyArray<{\n    alias: string;\n    expr: ColumnRef | IncludeRef | OperationExpr;\n  }>;\n  readonly where?: BinaryExpr | ExistsExpr;\n  readonly orderBy?: ReadonlyArray<{ expr: ColumnRef | OperationExpr; dir: Direction }>;\n  readonly limit?: number;\n}\n\nexport function createSelectAst(options: CreateSelectAstOptions): SelectAst {\n  return compact({\n    kind: 'select',\n    from: options.from,\n    joins: options.joins,\n    includes: options.includes,\n    project: options.project,\n    where: options.where,\n    orderBy: options.orderBy,\n    limit: options.limit,\n  }) as SelectAst;\n}\n","import type { ReturnSpec } from '@prisma-next/operations';\nimport type { SqlLoweringSpec } from '@prisma-next/sql-operations';\n\n// SQL-specific AST types and supporting types\n// These types are needed by adapters and runtime for SQL query execution\n\nexport type Direction = 'asc' | 'desc';\n\nexport interface TableRef {\n  readonly kind: 'table';\n  readonly name: string;\n}\n\nexport interface ColumnRef {\n  readonly kind: 'col';\n  readonly table: string;\n  readonly column: string;\n}\n\nexport interface ParamRef {\n  readonly kind: 'param';\n  readonly index: number;\n  readonly name?: string;\n}\n\nexport interface LiteralExpr {\n  readonly kind: 'literal';\n  readonly value: unknown;\n}\n\nexport interface OperationExpr {\n  readonly kind: 'operation';\n  readonly method: string;\n  readonly forTypeId: string;\n  readonly self: Expression;\n  readonly args: ReadonlyArray<Expression | ParamRef | LiteralExpr>;\n  readonly returns: ReturnSpec;\n  readonly lowering: SqlLoweringSpec;\n}\n\n/**\n * Unified expression type - the canonical AST representation for column references\n * and operation expressions. This is what all builders convert to via toExpr().\n */\nexport type Expression = ColumnRef | OperationExpr;\n\n/**\n * Interface for any builder that can produce an Expression.\n * Implemented by ColumnBuilder and ExpressionBuilder.\n */\nexport interface ExpressionSource {\n  toExpr(): Expression;\n}\n\nexport function isOperationExpr(expr: Expression): expr is OperationExpr {\n  return expr.kind === 'operation';\n}\n\nexport type BinaryOp = 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte';\n\nexport interface BinaryExpr {\n  readonly kind: 'bin';\n  readonly op: BinaryOp;\n  readonly left: Expression;\n  readonly right: Expression | ParamRef;\n}\n\nexport interface ExistsExpr {\n  readonly kind: 'exists';\n  readonly not: boolean;\n  readonly subquery: SelectAst;\n}\n\nexport type JoinOnExpr = {\n  readonly kind: 'eqCol';\n  readonly left: ColumnRef;\n  readonly right: ColumnRef;\n};\n\nexport interface JoinAst {\n  readonly kind: 'join';\n  readonly joinType: 'inner' | 'left' | 'right' | 'full';\n  readonly table: TableRef;\n  readonly on: JoinOnExpr;\n}\n\nexport interface IncludeRef {\n  readonly kind: 'includeRef';\n  readonly alias: string;\n}\n\nexport interface IncludeAst {\n  readonly kind: 'includeMany';\n  readonly alias: string;\n  readonly child: {\n    readonly table: TableRef;\n    readonly on: JoinOnExpr;\n    readonly where?: BinaryExpr | ExistsExpr;\n    readonly orderBy?: ReadonlyArray<{ expr: Expression; dir: Direction }>;\n    readonly limit?: number;\n    readonly project: ReadonlyArray<{ alias: string; expr: Expression }>;\n  };\n}\n\nexport interface SelectAst {\n  readonly kind: 'select';\n  readonly from: TableRef;\n  readonly joins?: ReadonlyArray<JoinAst>;\n  readonly includes?: ReadonlyArray<IncludeAst>;\n  readonly project: ReadonlyArray<{\n    alias: string;\n    expr: Expression | IncludeRef | LiteralExpr;\n  }>;\n  readonly where?: BinaryExpr | ExistsExpr;\n  readonly orderBy?: ReadonlyArray<{ expr: Expression; dir: Direction }>;\n  readonly limit?: number;\n}\n\nexport interface InsertAst {\n  readonly kind: 'insert';\n  readonly table: TableRef;\n  readonly values: Record<string, ColumnRef | ParamRef>;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport interface UpdateAst {\n  readonly kind: 'update';\n  readonly table: TableRef;\n  readonly set: Record<string, ColumnRef | ParamRef>;\n  readonly where: BinaryExpr;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport interface DeleteAst {\n  readonly kind: 'delete';\n  readonly table: TableRef;\n  readonly where: BinaryExpr;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport type QueryAst = SelectAst | InsertAst | UpdateAst | DeleteAst;\n\nexport interface LoweredStatement {\n  readonly sql: string;\n  readonly params: readonly unknown[];\n  readonly annotations?: Record<string, unknown>;\n}\n","import type { BinaryExpr, ColumnRef, ParamRef, TableRef, UpdateAst } from './types.ts';\nimport { compact } from './util.ts';\n\nexport interface CreateUpdateAstOptions {\n  readonly table: TableRef;\n  readonly set: Record<string, ColumnRef | ParamRef>;\n  readonly where: BinaryExpr;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport function createUpdateAst(options: CreateUpdateAstOptions): UpdateAst {\n  return compact({\n    kind: 'update',\n    table: options.table,\n    set: options.set,\n    where: options.where,\n    returning: options.returning,\n  }) as UpdateAst;\n}\n"],"mappings":"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"}

package/dist/exports/plan.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"plan.mjs","names":[],"sources":["../../src/plan.ts"],"sourcesContent":["import type { ExecutionPlan, ParamDescriptor } from '@prisma-next/contract/types';\nimport type { StorageColumn } from '@prisma-next/sql-contract/types';\nimport type { QueryAst } from './ast/types';\n\n/**\n * SQL query plan produced by lanes before lowering.\n *\n * Lanes build ASTs and metadata but do not perform SQL lowering.\n * The `sql` field is absent - lowering happens in the runtime executor.\n *\n * Structurally aligns with ExecutionPlan<Row, QueryAst> (without sql field) to maintain\n * compatibility with ExecutionPlan/Plan-based utilities.\n * The generic parameter `_Row` is preserved for type extraction via ResultType.\n */\nexport interface SqlQueryPlan<_Row = unknown>\n  extends Pick<ExecutionPlan<_Row, QueryAst>, 'params' | 'meta'> {\n  readonly ast: QueryAst;\n  // Phantom property to preserve generic parameter for type extraction\n  // This allows ResultType to extract _Row for SqlQueryPlan values.\n  readonly _Row?: _Row;\n}\n\n/**\n * Augments the last ParamDescriptor in the array with codecId and nativeType from columnMeta.\n * This is used when building WHERE expressions to ensure param descriptors have type information.\n */\nexport function augmentDescriptorWithColumnMeta(\n  descriptors: ParamDescriptor[],\n  columnMeta: StorageColumn | undefined,\n): void {\n  const descriptor = descriptors[descriptors.length - 1];\n  if (descriptor && columnMeta) {\n    descriptors[descriptors.length - 1] = {\n      ...descriptor,\n      codecId: columnMeta.codecId,\n      nativeType: columnMeta.nativeType,\n    };\n  }\n}\n"],"mappings":";;;;;AA0BA,SAAgB,gCACd,aACA,YACM;CACN,MAAM,aAAa,YAAY,YAAY,SAAS;AACpD,KAAI,cAAc,WAChB,aAAY,YAAY,SAAS,KAAK;EACpC,GAAG;EACH,SAAS,WAAW;EACpB,YAAY,WAAW;EACxB"}
+{"version":3,"file":"plan.mjs","names":[],"sources":["../../src/plan.ts"],"sourcesContent":["import type { ExecutionPlan, ParamDescriptor } from '@prisma-next/contract/types';\nimport type { StorageColumn } from '@prisma-next/sql-contract/types';\nimport type { QueryAst } from './ast/types.ts';\n\n/**\n * SQL query plan produced by lanes before lowering.\n *\n * Lanes build ASTs and metadata but do not perform SQL lowering.\n * The `sql` field is absent - lowering happens in the runtime executor.\n *\n * Structurally aligns with ExecutionPlan<Row, QueryAst> (without sql field) to maintain\n * compatibility with ExecutionPlan/Plan-based utilities.\n * The generic parameter `_Row` is preserved for type extraction via ResultType.\n */\nexport interface SqlQueryPlan<_Row = unknown>\n  extends Pick<ExecutionPlan<_Row, QueryAst>, 'params' | 'meta'> {\n  readonly ast: QueryAst;\n  // Phantom property to preserve generic parameter for type extraction\n  // This allows ResultType to extract _Row for SqlQueryPlan values.\n  readonly _Row?: _Row;\n}\n\n/**\n * Augments the last ParamDescriptor in the array with codecId and nativeType from columnMeta.\n * This is used when building WHERE expressions to ensure param descriptors have type information.\n */\nexport function augmentDescriptorWithColumnMeta(\n  descriptors: ParamDescriptor[],\n  columnMeta: StorageColumn | undefined,\n): void {\n  const descriptor = descriptors[descriptors.length - 1];\n  if (descriptor && columnMeta) {\n    descriptors[descriptors.length - 1] = {\n      ...descriptor,\n      codecId: columnMeta.codecId,\n      nativeType: columnMeta.nativeType,\n    };\n  }\n}\n"],"mappings":";;;;;AA0BA,SAAgB,gCACd,aACA,YACM;CACN,MAAM,aAAa,YAAY,YAAY,SAAS;AACpD,KAAI,cAAc,WAChB,aAAY,YAAY,SAAS,KAAK;EACpC,GAAG;EACH,SAAS,WAAW;EACpB,YAAY,WAAW;EACxB"}

package/dist/guards-4T0IByJo.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"guards-4T0IByJo.mjs","names":["refs: ColumnRef[]"],"sources":["../src/utils/guards.ts"],"sourcesContent":["import type { StorageColumn } from '@prisma-next/sql-contract/types';\nimport type {\n  ColumnRef,\n  Expression,\n  ExpressionSource,\n  LiteralExpr,\n  OperationExpr,\n  ParamRef,\n} from '../ast/types';\nimport type {\n  AnyColumnBuilder,\n  AnyExpressionSource,\n  ExpressionBuilder,\n  ParamPlaceholder,\n  ValueSource,\n} from '../types';\n\n/**\n * Helper to extract columnMeta from a ColumnBuilder or ExpressionBuilder.\n * Returns StorageColumn if present, undefined otherwise.\n * Both ColumnBuilder and ExpressionBuilder have columnMeta property.\n */\nexport function getColumnMeta(expr: AnyExpressionSource): StorageColumn | undefined {\n  // Both ColumnBuilder and ExpressionBuilder have columnMeta: StorageColumn\n  // TypeScript should narrow the type after the 'in' check\n  if ('columnMeta' in expr) {\n    return expr.columnMeta;\n  }\n  return undefined;\n}\n\n/**\n * Type predicate to check if a value is a ParamPlaceholder.\n */\nexport function isParamPlaceholder(value: unknown): value is ParamPlaceholder {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'kind' in value &&\n    (value as { kind: unknown }).kind === 'param-placeholder' &&\n    'name' in value &&\n    typeof (value as { name: unknown }).name === 'string'\n  );\n}\n\n/**\n * Recursively extracts the base ColumnRef from an OperationExpr.\n * If the expression is already a ColumnRef, it is returned directly.\n */\nexport function extractBaseColumnRef(expr: ColumnRef | OperationExpr): ColumnRef {\n  if (expr.kind === 'col') {\n    return expr;\n  }\n  return extractBaseColumnRef(expr.self);\n}\n\n/**\n * Recursively collects all ColumnRef nodes from an expression tree.\n * Handles nested OperationExpr structures by traversing both self and args.\n */\nexport function collectColumnRefs(\n  expr: ColumnRef | ParamRef | LiteralExpr | OperationExpr,\n): ColumnRef[] {\n  if (expr.kind === 'col') {\n    return [expr];\n  }\n  if (expr.kind === 'operation') {\n    const refs: ColumnRef[] = collectColumnRefs(expr.self);\n    for (const arg of expr.args) {\n      refs.push(...collectColumnRefs(arg));\n    }\n    return refs;\n  }\n  return [];\n}\n\n/**\n * Type predicate to check if an expression is an OperationExpr.\n */\nexport function isOperationExpr(\n  expr: AnyExpressionSource | OperationExpr | Expression,\n): expr is OperationExpr {\n  return typeof expr === 'object' && expr !== null && 'kind' in expr && expr.kind === 'operation';\n}\n\n/**\n * Helper to extract table and column from a ColumnBuilder, ExpressionBuilder, or OperationExpr.\n * For ExpressionBuilder or OperationExpr, recursively unwraps to find the base ColumnRef.\n */\nexport function getColumnInfo(expr: AnyExpressionSource | OperationExpr): {\n  table: string;\n  column: string;\n} {\n  if (isOperationExpr(expr)) {\n    const baseCol = extractBaseColumnRef(expr);\n    return { table: baseCol.table, column: baseCol.column };\n  }\n  if (isExpressionBuilder(expr)) {\n    const baseCol = extractBaseColumnRef(expr.expr);\n    return { table: baseCol.table, column: baseCol.column };\n  }\n  // expr is ColumnBuilder - TypeScript can't narrow properly\n  const colBuilder = expr as unknown as { table: string; column: string };\n  return { table: colBuilder.table, column: colBuilder.column };\n}\n\n/**\n * Type predicate to check if a value is a ColumnBuilder.\n */\nexport function isColumnBuilder(value: unknown): value is AnyColumnBuilder {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'kind' in value &&\n    (value as { kind: unknown }).kind === 'column'\n  );\n}\n\n/**\n * Type predicate to check if a value is an ExpressionBuilder.\n */\nexport function isExpressionBuilder(value: unknown): value is ExpressionBuilder {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'kind' in value &&\n    (value as { kind: unknown }).kind === 'expression'\n  );\n}\n\n/**\n * Type predicate to check if a value is an ExpressionSource (has toExpr method).\n */\nexport function isExpressionSource(value: unknown): value is ExpressionSource {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'toExpr' in value &&\n    typeof (value as ExpressionSource).toExpr === 'function'\n  );\n}\n\n/**\n * Converts any ExpressionSource to an Expression.\n * This is the canonical way to get an AST Expression from a builder.\n *\n * @param source - A ColumnBuilder or ExpressionBuilder\n * @returns The corresponding Expression (ColumnRef or OperationExpr)\n */\nexport function toExpression(source: ExpressionSource): Expression {\n  return source.toExpr();\n}\n\n/**\n * Converts an AnyExpressionSource to an Expression.\n * Handles both ColumnBuilder and ExpressionBuilder.\n *\n * @param source - A ColumnBuilder or ExpressionBuilder\n * @returns The corresponding Expression (ColumnRef or OperationExpr)\n */\nexport function expressionFromSource(source: AnyExpressionSource): Expression {\n  return source.toExpr();\n}\n\n/**\n * Type predicate to check if a value is a ValueSource.\n * ValueSource is either a ParamPlaceholder or an ExpressionSource.\n */\nexport function isValueSource(value: unknown): value is ValueSource {\n  return isParamPlaceholder(value) || isExpressionSource(value);\n}\n\n/**\n * Extracts and returns an OperationExpr from a builder.\n * Returns the OperationExpr if the builder is an OperationExpr or has an _operationExpr property,\n * otherwise returns undefined.\n *\n * @deprecated Use isExpressionBuilder() instead. This function exists for backward compatibility\n * with code that uses the hidden _operationExpr property pattern.\n *\n * @design-note: This function accesses the hidden `_operationExpr` property, which is a code smell.\n * The ExpressionBuilder type (introduced in the operation-expr-refactoring) provides a cleaner\n * approach by explicitly representing operation results as a distinct type.\n */\nexport function getOperationExpr(\n  builder: AnyColumnBuilder | OperationExpr,\n): OperationExpr | undefined {\n  if (isOperationExpr(builder)) {\n    return builder;\n  }\n  const builderWithExpr = builder as unknown as { _operationExpr?: OperationExpr };\n  return builderWithExpr._operationExpr;\n}\n"],"mappings":";;;;;;AAsBA,SAAgB,cAAc,MAAsD;AAGlF,KAAI,gBAAgB,KAClB,QAAO,KAAK;;;;;AAQhB,SAAgB,mBAAmB,OAA2C;AAC5E,QACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS,uBACtC,UAAU,SACV,OAAQ,MAA4B,SAAS;;;;;;AAQjD,SAAgB,qBAAqB,MAA4C;AAC/E,KAAI,KAAK,SAAS,MAChB,QAAO;AAET,QAAO,qBAAqB,KAAK,KAAK;;;;;;AAOxC,SAAgB,kBACd,MACa;AACb,KAAI,KAAK,SAAS,MAChB,QAAO,CAAC,KAAK;AAEf,KAAI,KAAK,SAAS,aAAa;EAC7B,MAAMA,OAAoB,kBAAkB,KAAK,KAAK;AACtD,OAAK,MAAM,OAAO,KAAK,KACrB,MAAK,KAAK,GAAG,kBAAkB,IAAI,CAAC;AAEtC,SAAO;;AAET,QAAO,EAAE;;;;;AAMX,SAAgB,gBACd,MACuB;AACvB,QAAO,OAAO,SAAS,YAAY,SAAS,QAAQ,UAAU,QAAQ,KAAK,SAAS;;;;;;AAOtF,SAAgB,cAAc,MAG5B;AACA,KAAI,gBAAgB,KAAK,EAAE;EACzB,MAAM,UAAU,qBAAqB,KAAK;AAC1C,SAAO;GAAE,OAAO,QAAQ;GAAO,QAAQ,QAAQ;GAAQ;;AAEzD,KAAI,oBAAoB,KAAK,EAAE;EAC7B,MAAM,UAAU,qBAAqB,KAAK,KAAK;AAC/C,SAAO;GAAE,OAAO,QAAQ;GAAO,QAAQ,QAAQ;GAAQ;;CAGzD,MAAM,aAAa;AACnB,QAAO;EAAE,OAAO,WAAW;EAAO,QAAQ,WAAW;EAAQ;;;;;AAM/D,SAAgB,gBAAgB,OAA2C;AACzE,QACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS;;;;;AAO1C,SAAgB,oBAAoB,OAA4C;AAC9E,QACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS;;;;;AAO1C,SAAgB,mBAAmB,OAA2C;AAC5E,QACE,OAAO,UAAU,YACjB,UAAU,QACV,YAAY,SACZ,OAAQ,MAA2B,WAAW;;;;;;;;;AAWlD,SAAgB,aAAa,QAAsC;AACjE,QAAO,OAAO,QAAQ;;;;;;;;;AAUxB,SAAgB,qBAAqB,QAAyC;AAC5E,QAAO,OAAO,QAAQ;;;;;;AAOxB,SAAgB,cAAc,OAAsC;AAClE,QAAO,mBAAmB,MAAM,IAAI,mBAAmB,MAAM;;;;;;;;;;;;;;AAe/D,SAAgB,iBACd,SAC2B;AAC3B,KAAI,gBAAgB,QAAQ,CAC1B,QAAO;AAGT,QADwB,QACD"}
+{"version":3,"file":"guards-4T0IByJo.mjs","names":["refs: ColumnRef[]"],"sources":["../src/utils/guards.ts"],"sourcesContent":["import type { StorageColumn } from '@prisma-next/sql-contract/types';\nimport type {\n  ColumnRef,\n  Expression,\n  ExpressionSource,\n  LiteralExpr,\n  OperationExpr,\n  ParamRef,\n} from '../ast/types.ts';\nimport type {\n  AnyColumnBuilder,\n  AnyExpressionSource,\n  ExpressionBuilder,\n  ParamPlaceholder,\n  ValueSource,\n} from '../types.ts';\n\n/**\n * Helper to extract columnMeta from a ColumnBuilder or ExpressionBuilder.\n * Returns StorageColumn if present, undefined otherwise.\n * Both ColumnBuilder and ExpressionBuilder have columnMeta property.\n */\nexport function getColumnMeta(expr: AnyExpressionSource): StorageColumn | undefined {\n  // Both ColumnBuilder and ExpressionBuilder have columnMeta: StorageColumn\n  // TypeScript should narrow the type after the 'in' check\n  if ('columnMeta' in expr) {\n    return expr.columnMeta;\n  }\n  return undefined;\n}\n\n/**\n * Type predicate to check if a value is a ParamPlaceholder.\n */\nexport function isParamPlaceholder(value: unknown): value is ParamPlaceholder {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'kind' in value &&\n    (value as { kind: unknown }).kind === 'param-placeholder' &&\n    'name' in value &&\n    typeof (value as { name: unknown }).name === 'string'\n  );\n}\n\n/**\n * Recursively extracts the base ColumnRef from an OperationExpr.\n * If the expression is already a ColumnRef, it is returned directly.\n */\nexport function extractBaseColumnRef(expr: ColumnRef | OperationExpr): ColumnRef {\n  if (expr.kind === 'col') {\n    return expr;\n  }\n  return extractBaseColumnRef(expr.self);\n}\n\n/**\n * Recursively collects all ColumnRef nodes from an expression tree.\n * Handles nested OperationExpr structures by traversing both self and args.\n */\nexport function collectColumnRefs(\n  expr: ColumnRef | ParamRef | LiteralExpr | OperationExpr,\n): ColumnRef[] {\n  if (expr.kind === 'col') {\n    return [expr];\n  }\n  if (expr.kind === 'operation') {\n    const refs: ColumnRef[] = collectColumnRefs(expr.self);\n    for (const arg of expr.args) {\n      refs.push(...collectColumnRefs(arg));\n    }\n    return refs;\n  }\n  return [];\n}\n\n/**\n * Type predicate to check if an expression is an OperationExpr.\n */\nexport function isOperationExpr(\n  expr: AnyExpressionSource | OperationExpr | Expression,\n): expr is OperationExpr {\n  return typeof expr === 'object' && expr !== null && 'kind' in expr && expr.kind === 'operation';\n}\n\n/**\n * Helper to extract table and column from a ColumnBuilder, ExpressionBuilder, or OperationExpr.\n * For ExpressionBuilder or OperationExpr, recursively unwraps to find the base ColumnRef.\n */\nexport function getColumnInfo(expr: AnyExpressionSource | OperationExpr): {\n  table: string;\n  column: string;\n} {\n  if (isOperationExpr(expr)) {\n    const baseCol = extractBaseColumnRef(expr);\n    return { table: baseCol.table, column: baseCol.column };\n  }\n  if (isExpressionBuilder(expr)) {\n    const baseCol = extractBaseColumnRef(expr.expr);\n    return { table: baseCol.table, column: baseCol.column };\n  }\n  // expr is ColumnBuilder - TypeScript can't narrow properly\n  const colBuilder = expr as unknown as { table: string; column: string };\n  return { table: colBuilder.table, column: colBuilder.column };\n}\n\n/**\n * Type predicate to check if a value is a ColumnBuilder.\n */\nexport function isColumnBuilder(value: unknown): value is AnyColumnBuilder {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'kind' in value &&\n    (value as { kind: unknown }).kind === 'column'\n  );\n}\n\n/**\n * Type predicate to check if a value is an ExpressionBuilder.\n */\nexport function isExpressionBuilder(value: unknown): value is ExpressionBuilder {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'kind' in value &&\n    (value as { kind: unknown }).kind === 'expression'\n  );\n}\n\n/**\n * Type predicate to check if a value is an ExpressionSource (has toExpr method).\n */\nexport function isExpressionSource(value: unknown): value is ExpressionSource {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'toExpr' in value &&\n    typeof (value as ExpressionSource).toExpr === 'function'\n  );\n}\n\n/**\n * Converts any ExpressionSource to an Expression.\n * This is the canonical way to get an AST Expression from a builder.\n *\n * @param source - A ColumnBuilder or ExpressionBuilder\n * @returns The corresponding Expression (ColumnRef or OperationExpr)\n */\nexport function toExpression(source: ExpressionSource): Expression {\n  return source.toExpr();\n}\n\n/**\n * Converts an AnyExpressionSource to an Expression.\n * Handles both ColumnBuilder and ExpressionBuilder.\n *\n * @param source - A ColumnBuilder or ExpressionBuilder\n * @returns The corresponding Expression (ColumnRef or OperationExpr)\n */\nexport function expressionFromSource(source: AnyExpressionSource): Expression {\n  return source.toExpr();\n}\n\n/**\n * Type predicate to check if a value is a ValueSource.\n * ValueSource is either a ParamPlaceholder or an ExpressionSource.\n */\nexport function isValueSource(value: unknown): value is ValueSource {\n  return isParamPlaceholder(value) || isExpressionSource(value);\n}\n\n/**\n * Extracts and returns an OperationExpr from a builder.\n * Returns the OperationExpr if the builder is an OperationExpr or has an _operationExpr property,\n * otherwise returns undefined.\n *\n * @deprecated Use isExpressionBuilder() instead. This function exists for backward compatibility\n * with code that uses the hidden _operationExpr property pattern.\n *\n * @design-note: This function accesses the hidden `_operationExpr` property, which is a code smell.\n * The ExpressionBuilder type (introduced in the operation-expr-refactoring) provides a cleaner\n * approach by explicitly representing operation results as a distinct type.\n */\nexport function getOperationExpr(\n  builder: AnyColumnBuilder | OperationExpr,\n): OperationExpr | undefined {\n  if (isOperationExpr(builder)) {\n    return builder;\n  }\n  const builderWithExpr = builder as unknown as { _operationExpr?: OperationExpr };\n  return builderWithExpr._operationExpr;\n}\n"],"mappings":";;;;;;AAsBA,SAAgB,cAAc,MAAsD;AAGlF,KAAI,gBAAgB,KAClB,QAAO,KAAK;;;;;AAQhB,SAAgB,mBAAmB,OAA2C;AAC5E,QACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS,uBACtC,UAAU,SACV,OAAQ,MAA4B,SAAS;;;;;;AAQjD,SAAgB,qBAAqB,MAA4C;AAC/E,KAAI,KAAK,SAAS,MAChB,QAAO;AAET,QAAO,qBAAqB,KAAK,KAAK;;;;;;AAOxC,SAAgB,kBACd,MACa;AACb,KAAI,KAAK,SAAS,MAChB,QAAO,CAAC,KAAK;AAEf,KAAI,KAAK,SAAS,aAAa;EAC7B,MAAMA,OAAoB,kBAAkB,KAAK,KAAK;AACtD,OAAK,MAAM,OAAO,KAAK,KACrB,MAAK,KAAK,GAAG,kBAAkB,IAAI,CAAC;AAEtC,SAAO;;AAET,QAAO,EAAE;;;;;AAMX,SAAgB,gBACd,MACuB;AACvB,QAAO,OAAO,SAAS,YAAY,SAAS,QAAQ,UAAU,QAAQ,KAAK,SAAS;;;;;;AAOtF,SAAgB,cAAc,MAG5B;AACA,KAAI,gBAAgB,KAAK,EAAE;EACzB,MAAM,UAAU,qBAAqB,KAAK;AAC1C,SAAO;GAAE,OAAO,QAAQ;GAAO,QAAQ,QAAQ;GAAQ;;AAEzD,KAAI,oBAAoB,KAAK,EAAE;EAC7B,MAAM,UAAU,qBAAqB,KAAK,KAAK;AAC/C,SAAO;GAAE,OAAO,QAAQ;GAAO,QAAQ,QAAQ;GAAQ;;CAGzD,MAAM,aAAa;AACnB,QAAO;EAAE,OAAO,WAAW;EAAO,QAAQ,WAAW;EAAQ;;;;;AAM/D,SAAgB,gBAAgB,OAA2C;AACzE,QACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS;;;;;AAO1C,SAAgB,oBAAoB,OAA4C;AAC9E,QACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS;;;;;AAO1C,SAAgB,mBAAmB,OAA2C;AAC5E,QACE,OAAO,UAAU,YACjB,UAAU,QACV,YAAY,SACZ,OAAQ,MAA2B,WAAW;;;;;;;;;AAWlD,SAAgB,aAAa,QAAsC;AACjE,QAAO,OAAO,QAAQ;;;;;;;;;AAUxB,SAAgB,qBAAqB,QAAyC;AAC5E,QAAO,OAAO,QAAQ;;;;;;AAOxB,SAAgB,cAAc,OAAsC;AAClE,QAAO,mBAAmB,MAAM,IAAI,mBAAmB,MAAM;;;;;;;;;;;;;;AAe/D,SAAgB,iBACd,SAC2B;AAC3B,KAAI,gBAAgB,QAAQ,CAC1B,QAAO;AAGT,QADwB,QACD"}

package/dist/operations-registry-7R5KE2-5.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"operations-registry-7R5KE2-5.mjs","names":["selfExpr: Expression","operationArgs: Array<Expression | ParamRef | LiteralExpr>","operationExpr: OperationExpr","returnColumnMeta: StorageColumn","baseResult: ExpressionBuilder"],"sources":["../src/operations-registry.ts"],"sourcesContent":["import type { OperationRegistry } from '@prisma-next/operations';\nimport { hasAllCapabilities } from '@prisma-next/operations';\nimport { planInvalid } from '@prisma-next/plan';\nimport type { StorageColumn } from '@prisma-next/sql-contract/types';\nimport type { SqlOperationSignature } from '@prisma-next/sql-operations';\nimport type {\n  BinaryOp,\n  Expression,\n  ExpressionSource,\n  LiteralExpr,\n  OperationExpr,\n  ParamRef,\n} from './ast/types';\nimport type {\n  AnyBinaryBuilder,\n  AnyOrderBuilder,\n  ColumnBuilder,\n  ExpressionBuilder,\n  OperationTypes,\n  ParamPlaceholder,\n} from './types';\nimport { isParamPlaceholder } from './utils/guards';\n\n/**\n * Type guard to check if a value is an ExpressionSource (has toExpr method).\n */\nfunction isExpressionSource(value: unknown): value is ExpressionSource {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'toExpr' in value &&\n    typeof (value as ExpressionSource).toExpr === 'function'\n  );\n}\n\n/**\n * Executes an operation and returns an ExpressionBuilder.\n * This is the canonical entrypoint for operation invocation, enabling\n * future enhancements like telemetry, caching, or tracing.\n *\n * The returned ExpressionBuilder:\n * - Has `kind: 'expression'` to distinguish it from ColumnBuilder\n * - Contains the operation expression in `expr`\n * - Provides `toExpr()` method to get the Expression\n * - Provides comparison and ordering methods for chaining\n *\n * @param signature - The operation signature from the registry\n * @param selfBuilder - The expression source that the operation is called on\n * @param args - The arguments passed to the operation\n * @param columnMeta - The metadata of the column the operation is called on\n * @returns An ExpressionBuilder containing the operation expression\n */\nfunction executeOperation(\n  signature: SqlOperationSignature,\n  selfBuilder: ExpressionSource,\n  args: unknown[],\n  columnMeta: StorageColumn,\n  operationRegistry?: OperationRegistry,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ExpressionBuilder {\n  if (args.length !== signature.args.length) {\n    throw planInvalid(\n      `Operation ${signature.method} expects ${signature.args.length} arguments, got ${args.length}`,\n    );\n  }\n\n  // Get the Expression from the self builder using toExpr()\n  const selfExpr: Expression = selfBuilder.toExpr();\n\n  const operationArgs: Array<Expression | ParamRef | LiteralExpr> = [];\n  for (let i = 0; i < args.length; i++) {\n    const arg = args[i];\n    const argSpec = signature.args[i];\n    if (!argSpec) {\n      throw planInvalid(`Missing argument spec for argument ${i}`);\n    }\n\n    if (argSpec.kind === 'param') {\n      if (!isParamPlaceholder(arg)) {\n        throw planInvalid(`Argument ${i} must be a parameter placeholder`);\n      }\n      operationArgs.push({\n        kind: 'param',\n        index: 0,\n        name: arg.name,\n      });\n    } else if (argSpec.kind === 'typeId') {\n      // Accept ExpressionSource (ColumnBuilder or ExpressionBuilder)\n      if (!isExpressionSource(arg)) {\n        throw planInvalid(\n          `Argument ${i} must be an ExpressionSource (ColumnBuilder or ExpressionBuilder)`,\n        );\n      }\n      // Use toExpr() to get the Expression\n      operationArgs.push(arg.toExpr());\n    } else if (argSpec.kind === 'literal') {\n      operationArgs.push({\n        kind: 'literal',\n        value: arg,\n      });\n    }\n  }\n\n  const operationExpr: OperationExpr = {\n    kind: 'operation',\n    method: signature.method,\n    forTypeId: signature.forTypeId,\n    self: selfExpr,\n    args: operationArgs,\n    returns: signature.returns,\n    lowering: signature.lowering,\n  };\n\n  const returnTypeId = signature.returns.kind === 'typeId' ? signature.returns.type : undefined;\n  const returnColumnMeta: StorageColumn = returnTypeId\n    ? {\n        ...columnMeta,\n        codecId: returnTypeId,\n      }\n    : columnMeta;\n\n  const createComparisonMethod =\n    (op: BinaryOp) =>\n    (value: ParamPlaceholder | ExpressionSource): AnyBinaryBuilder =>\n      Object.freeze({\n        kind: 'binary' as const,\n        op,\n        left: operationExpr,\n        right: value,\n      }) as AnyBinaryBuilder;\n\n  const baseResult: ExpressionBuilder = {\n    kind: 'expression' as const,\n    expr: operationExpr,\n    get columnMeta() {\n      return returnColumnMeta;\n    },\n    eq: createComparisonMethod('eq'),\n    neq: createComparisonMethod('neq'),\n    gt: createComparisonMethod('gt'),\n    lt: createComparisonMethod('lt'),\n    gte: createComparisonMethod('gte'),\n    lte: createComparisonMethod('lte'),\n    asc(): AnyOrderBuilder {\n      return Object.freeze({\n        kind: 'order' as const,\n        expr: operationExpr,\n        dir: 'asc' as const,\n      });\n    },\n    desc(): AnyOrderBuilder {\n      return Object.freeze({\n        kind: 'order' as const,\n        expr: operationExpr,\n        dir: 'desc' as const,\n      });\n    },\n    toExpr(): OperationExpr {\n      return operationExpr;\n    },\n    get __jsType(): unknown {\n      return undefined;\n    },\n  };\n\n  // If the return type is a typeId, attach operations for that type\n  if (returnTypeId && operationRegistry) {\n    const resultWithOps = attachOperationsToExpressionBuilder(\n      baseResult,\n      returnColumnMeta,\n      operationRegistry,\n      contractCapabilities,\n    );\n    return Object.freeze(resultWithOps);\n  }\n\n  return Object.freeze(baseResult);\n}\n\n/**\n * Attaches operation methods to an ExpressionBuilder for chained operations.\n * When an operation returns a typeId, the result ExpressionBuilder needs\n * operation methods for that type.\n */\nfunction attachOperationsToExpressionBuilder(\n  expressionBuilder: ExpressionBuilder,\n  columnMeta: StorageColumn,\n  registry: OperationRegistry,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ExpressionBuilder {\n  const codecId = columnMeta.codecId;\n  if (!codecId) {\n    return expressionBuilder;\n  }\n\n  const operations = registry.byType(codecId) as SqlOperationSignature[];\n  if (operations.length === 0) {\n    return expressionBuilder;\n  }\n\n  const builderWithOps = expressionBuilder as ExpressionBuilder & Record<string, unknown>;\n\n  for (const operation of operations) {\n    if (operation.capabilities && operation.capabilities.length > 0) {\n      if (!contractCapabilities) {\n        continue;\n      }\n\n      if (!hasAllCapabilities(operation.capabilities, contractCapabilities)) {\n        continue;\n      }\n    }\n    // Method sugar: attach operation as a method on the expression builder\n    builderWithOps[operation.method] = function (this: ExpressionBuilder, ...args: unknown[]) {\n      return executeOperation(operation, this, args, columnMeta, registry, contractCapabilities);\n    };\n  }\n\n  return builderWithOps;\n}\n\nexport function attachOperationsToColumnBuilder<\n  ColumnName extends string,\n  ColumnMeta extends StorageColumn,\n  JsType = unknown,\n  Operations extends OperationTypes = Record<string, never>,\n>(\n  columnBuilder: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>,\n  columnMeta: ColumnMeta,\n  registry: OperationRegistry | undefined,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations> {\n  if (!registry) {\n    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;\n  }\n\n  // Use codecId to look up operations registered for this column's type\n  const codecId = columnMeta.codecId;\n  if (!codecId) {\n    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;\n  }\n\n  const operations = registry.byType(codecId) as SqlOperationSignature[];\n  if (operations.length === 0) {\n    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;\n  }\n\n  const builderWithOps = columnBuilder as unknown as ColumnBuilder<\n    ColumnName,\n    ColumnMeta,\n    JsType,\n    Operations\n  >;\n\n  for (const operation of operations) {\n    if (operation.capabilities && operation.capabilities.length > 0) {\n      if (!contractCapabilities) {\n        continue;\n      }\n\n      if (!hasAllCapabilities(operation.capabilities, contractCapabilities)) {\n        continue;\n      }\n    }\n    // Method sugar: attach operation as a method on the column builder\n    // Operations return ExpressionBuilder, not ColumnBuilder\n    (builderWithOps as Record<string, unknown>)[operation.method] = function (\n      this: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>,\n      ...args: unknown[]\n    ) {\n      return executeOperation(operation, this, args, columnMeta, registry, contractCapabilities);\n    };\n  }\n\n  return builderWithOps;\n}\n"],"mappings":"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"}
+{"version":3,"file":"operations-registry-7R5KE2-5.mjs","names":["selfExpr: Expression","operationArgs: Array<Expression | ParamRef | LiteralExpr>","operationExpr: OperationExpr","returnColumnMeta: StorageColumn","baseResult: ExpressionBuilder"],"sources":["../src/operations-registry.ts"],"sourcesContent":["import type { OperationRegistry } from '@prisma-next/operations';\nimport { hasAllCapabilities } from '@prisma-next/operations';\nimport { planInvalid } from '@prisma-next/plan';\nimport type { StorageColumn } from '@prisma-next/sql-contract/types';\nimport type { SqlOperationSignature } from '@prisma-next/sql-operations';\nimport type {\n  BinaryOp,\n  Expression,\n  ExpressionSource,\n  LiteralExpr,\n  OperationExpr,\n  ParamRef,\n} from './ast/types.ts';\nimport type {\n  AnyBinaryBuilder,\n  AnyOrderBuilder,\n  ColumnBuilder,\n  ExpressionBuilder,\n  OperationTypes,\n  ParamPlaceholder,\n} from './types.ts';\nimport { isParamPlaceholder } from './utils/guards.ts';\n\n/**\n * Type guard to check if a value is an ExpressionSource (has toExpr method).\n */\nfunction isExpressionSource(value: unknown): value is ExpressionSource {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'toExpr' in value &&\n    typeof (value as ExpressionSource).toExpr === 'function'\n  );\n}\n\n/**\n * Executes an operation and returns an ExpressionBuilder.\n * This is the canonical entrypoint for operation invocation, enabling\n * future enhancements like telemetry, caching, or tracing.\n *\n * The returned ExpressionBuilder:\n * - Has `kind: 'expression'` to distinguish it from ColumnBuilder\n * - Contains the operation expression in `expr`\n * - Provides `toExpr()` method to get the Expression\n * - Provides comparison and ordering methods for chaining\n *\n * @param signature - The operation signature from the registry\n * @param selfBuilder - The expression source that the operation is called on\n * @param args - The arguments passed to the operation\n * @param columnMeta - The metadata of the column the operation is called on\n * @returns An ExpressionBuilder containing the operation expression\n */\nfunction executeOperation(\n  signature: SqlOperationSignature,\n  selfBuilder: ExpressionSource,\n  args: unknown[],\n  columnMeta: StorageColumn,\n  operationRegistry?: OperationRegistry,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ExpressionBuilder {\n  if (args.length !== signature.args.length) {\n    throw planInvalid(\n      `Operation ${signature.method} expects ${signature.args.length} arguments, got ${args.length}`,\n    );\n  }\n\n  // Get the Expression from the self builder using toExpr()\n  const selfExpr: Expression = selfBuilder.toExpr();\n\n  const operationArgs: Array<Expression | ParamRef | LiteralExpr> = [];\n  for (let i = 0; i < args.length; i++) {\n    const arg = args[i];\n    const argSpec = signature.args[i];\n    if (!argSpec) {\n      throw planInvalid(`Missing argument spec for argument ${i}`);\n    }\n\n    if (argSpec.kind === 'param') {\n      if (!isParamPlaceholder(arg)) {\n        throw planInvalid(`Argument ${i} must be a parameter placeholder`);\n      }\n      operationArgs.push({\n        kind: 'param',\n        index: 0,\n        name: arg.name,\n      });\n    } else if (argSpec.kind === 'typeId') {\n      // Accept ExpressionSource (ColumnBuilder or ExpressionBuilder)\n      if (!isExpressionSource(arg)) {\n        throw planInvalid(\n          `Argument ${i} must be an ExpressionSource (ColumnBuilder or ExpressionBuilder)`,\n        );\n      }\n      // Use toExpr() to get the Expression\n      operationArgs.push(arg.toExpr());\n    } else if (argSpec.kind === 'literal') {\n      operationArgs.push({\n        kind: 'literal',\n        value: arg,\n      });\n    }\n  }\n\n  const operationExpr: OperationExpr = {\n    kind: 'operation',\n    method: signature.method,\n    forTypeId: signature.forTypeId,\n    self: selfExpr,\n    args: operationArgs,\n    returns: signature.returns,\n    lowering: signature.lowering,\n  };\n\n  const returnTypeId = signature.returns.kind === 'typeId' ? signature.returns.type : undefined;\n  const returnColumnMeta: StorageColumn = returnTypeId\n    ? {\n        ...columnMeta,\n        codecId: returnTypeId,\n      }\n    : columnMeta;\n\n  const createComparisonMethod =\n    (op: BinaryOp) =>\n    (value: ParamPlaceholder | ExpressionSource): AnyBinaryBuilder =>\n      Object.freeze({\n        kind: 'binary' as const,\n        op,\n        left: operationExpr,\n        right: value,\n      }) as AnyBinaryBuilder;\n\n  const baseResult: ExpressionBuilder = {\n    kind: 'expression' as const,\n    expr: operationExpr,\n    get columnMeta() {\n      return returnColumnMeta;\n    },\n    eq: createComparisonMethod('eq'),\n    neq: createComparisonMethod('neq'),\n    gt: createComparisonMethod('gt'),\n    lt: createComparisonMethod('lt'),\n    gte: createComparisonMethod('gte'),\n    lte: createComparisonMethod('lte'),\n    asc(): AnyOrderBuilder {\n      return Object.freeze({\n        kind: 'order' as const,\n        expr: operationExpr,\n        dir: 'asc' as const,\n      });\n    },\n    desc(): AnyOrderBuilder {\n      return Object.freeze({\n        kind: 'order' as const,\n        expr: operationExpr,\n        dir: 'desc' as const,\n      });\n    },\n    toExpr(): OperationExpr {\n      return operationExpr;\n    },\n    get __jsType(): unknown {\n      return undefined;\n    },\n  };\n\n  // If the return type is a typeId, attach operations for that type\n  if (returnTypeId && operationRegistry) {\n    const resultWithOps = attachOperationsToExpressionBuilder(\n      baseResult,\n      returnColumnMeta,\n      operationRegistry,\n      contractCapabilities,\n    );\n    return Object.freeze(resultWithOps);\n  }\n\n  return Object.freeze(baseResult);\n}\n\n/**\n * Attaches operation methods to an ExpressionBuilder for chained operations.\n * When an operation returns a typeId, the result ExpressionBuilder needs\n * operation methods for that type.\n */\nfunction attachOperationsToExpressionBuilder(\n  expressionBuilder: ExpressionBuilder,\n  columnMeta: StorageColumn,\n  registry: OperationRegistry,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ExpressionBuilder {\n  const codecId = columnMeta.codecId;\n  if (!codecId) {\n    return expressionBuilder;\n  }\n\n  const operations = registry.byType(codecId) as SqlOperationSignature[];\n  if (operations.length === 0) {\n    return expressionBuilder;\n  }\n\n  const builderWithOps = expressionBuilder as ExpressionBuilder & Record<string, unknown>;\n\n  for (const operation of operations) {\n    if (operation.capabilities && operation.capabilities.length > 0) {\n      if (!contractCapabilities) {\n        continue;\n      }\n\n      if (!hasAllCapabilities(operation.capabilities, contractCapabilities)) {\n        continue;\n      }\n    }\n    // Method sugar: attach operation as a method on the expression builder\n    builderWithOps[operation.method] = function (this: ExpressionBuilder, ...args: unknown[]) {\n      return executeOperation(operation, this, args, columnMeta, registry, contractCapabilities);\n    };\n  }\n\n  return builderWithOps;\n}\n\nexport function attachOperationsToColumnBuilder<\n  ColumnName extends string,\n  ColumnMeta extends StorageColumn,\n  JsType = unknown,\n  Operations extends OperationTypes = Record<string, never>,\n>(\n  columnBuilder: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>,\n  columnMeta: ColumnMeta,\n  registry: OperationRegistry | undefined,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations> {\n  if (!registry) {\n    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;\n  }\n\n  // Use codecId to look up operations registered for this column's type\n  const codecId = columnMeta.codecId;\n  if (!codecId) {\n    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;\n  }\n\n  const operations = registry.byType(codecId) as SqlOperationSignature[];\n  if (operations.length === 0) {\n    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;\n  }\n\n  const builderWithOps = columnBuilder as unknown as ColumnBuilder<\n    ColumnName,\n    ColumnMeta,\n    JsType,\n    Operations\n  >;\n\n  for (const operation of operations) {\n    if (operation.capabilities && operation.capabilities.length > 0) {\n      if (!contractCapabilities) {\n        continue;\n      }\n\n      if (!hasAllCapabilities(operation.capabilities, contractCapabilities)) {\n        continue;\n      }\n    }\n    // Method sugar: attach operation as a method on the column builder\n    // Operations return ExpressionBuilder, not ColumnBuilder\n    (builderWithOps as Record<string, unknown>)[operation.method] = function (\n      this: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>,\n      ...args: unknown[]\n    ) {\n      return executeOperation(operation, this, args, columnMeta, registry, contractCapabilities);\n    };\n  }\n\n  return builderWithOps;\n}\n"],"mappings":"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"}

package/dist/param-BFvNAaHR.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"param-BFvNAaHR.mjs","names":[],"sources":["../src/param.ts"],"sourcesContent":["import { planInvalid } from '@prisma-next/plan';\nimport type { ParamPlaceholder } from './types';\n\nexport type Parameter = ParamPlaceholder;\n\nexport function param(name: string): Parameter {\n  if (typeof name !== 'string' || name.length === 0) {\n    throw planInvalid('Parameter name must be a non-empty string');\n  }\n\n  return Object.freeze({\n    kind: 'param-placeholder' as const,\n    name,\n  }) satisfies Parameter;\n}\n"],"mappings":";;;AAKA,SAAgB,MAAM,MAAyB;AAC7C,KAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAC9C,OAAM,YAAY,4CAA4C;AAGhE,QAAO,OAAO,OAAO;EACnB,MAAM;EACN;EACD,CAAC"}
+{"version":3,"file":"param-BFvNAaHR.mjs","names":[],"sources":["../src/param.ts"],"sourcesContent":["import { planInvalid } from '@prisma-next/plan';\nimport type { ParamPlaceholder } from './types.ts';\n\nexport type Parameter = ParamPlaceholder;\n\nexport function param(name: string): Parameter {\n  if (typeof name !== 'string' || name.length === 0) {\n    throw planInvalid('Parameter name must be a non-empty string');\n  }\n\n  return Object.freeze({\n    kind: 'param-placeholder' as const,\n    name,\n  }) satisfies Parameter;\n}\n"],"mappings":";;;AAKA,SAAgB,MAAM,MAAyB;AAC7C,KAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAC9C,OAAM,YAAY,4CAA4C;AAGhE,QAAO,OAAO,OAAO;EACnB,MAAM;EACN;EACD,CAAC"}

package/dist/schema-BsY2EXAf.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"schema-BsY2EXAf.mjs","names":["table: string","column: ColumnName","storageColumn: ColumnMeta"],"sources":["../src/schema.ts"],"sourcesContent":["import type { OperationRegistry } from '@prisma-next/operations';\nimport { planInvalid } from '@prisma-next/plan';\nimport type {\n  ExtractCodecTypes,\n  ExtractOperationTypes,\n  SqlContract,\n  SqlStorage,\n  StorageColumn,\n} from '@prisma-next/sql-contract/types';\nimport type { BinaryOp, ColumnRef, ExpressionSource, TableRef } from './ast/types';\nimport { attachOperationsToColumnBuilder } from './operations-registry';\nimport type { QueryLaneContext } from './query-lane-context';\nimport type {\n  BinaryBuilder,\n  CodecTypes as CodecTypesType,\n  ColumnBuilder,\n  ComputeColumnJsType,\n  OperationTypeSignature,\n  OperationTypes,\n  OrderBuilder,\n  ParamPlaceholder,\n} from './types';\n\ntype TableColumns<Table extends { columns: Record<string, StorageColumn> }> = Table['columns'];\n\ntype ColumnBuilders<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  Columns extends Record<string, StorageColumn>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n> = {\n  readonly [K in keyof Columns]: ColumnBuilder<\n    K & string,\n    Columns[K],\n    ComputeColumnJsType<Contract, TableName, K & string, Columns[K], CodecTypes>,\n    Operations\n  >;\n};\n\nexport class ColumnBuilderImpl<\n  ColumnName extends string,\n  ColumnMeta extends StorageColumn,\n  JsType = unknown,\n> implements ExpressionSource\n{\n  readonly kind = 'column' as const;\n\n  constructor(\n    readonly table: string,\n    readonly column: ColumnName,\n    private readonly storageColumn: ColumnMeta,\n  ) {}\n\n  get columnMeta(): ColumnMeta {\n    return this.storageColumn;\n  }\n\n  // Type-level helper property (not used at runtime)\n  get __jsType(): JsType {\n    return undefined as unknown as JsType;\n  }\n\n  /**\n   * Converts this column builder to a ColumnRef expression.\n   * This is the canonical way to get an AST node from a builder.\n   */\n  toExpr(): ColumnRef {\n    return Object.freeze({\n      kind: 'col' as const,\n      table: this.table,\n      column: this.column,\n    });\n  }\n\n  private createBinaryBuilder(\n    op: BinaryOp,\n    value: ParamPlaceholder | ExpressionSource,\n  ): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    if (value == null) {\n      throw planInvalid(\n        'Parameter placeholder or expression source required for column comparison',\n      );\n    }\n    // Check for ExpressionSource first (has toExpr method)\n    if ('toExpr' in value && typeof value.toExpr === 'function') {\n      return Object.freeze({\n        kind: 'binary' as const,\n        op,\n        left: this.toExpr(),\n        right: value,\n      }) as BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n    }\n    // Must be a ParamPlaceholder\n    if ('kind' in value && value.kind === 'param-placeholder') {\n      return Object.freeze({\n        kind: 'binary' as const,\n        op,\n        left: this.toExpr(),\n        right: value,\n      }) as BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n    }\n    throw planInvalid('Parameter placeholder or expression source required for column comparison');\n  }\n\n  eq(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('eq', value);\n  }\n\n  neq(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('neq', value);\n  }\n\n  gt(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('gt', value);\n  }\n\n  lt(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('lt', value);\n  }\n\n  gte(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('gte', value);\n  }\n\n  lte(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('lte', value);\n  }\n\n  asc(): OrderBuilder<ColumnName, ColumnMeta, JsType> {\n    return Object.freeze({\n      kind: 'order' as const,\n      expr: this.toExpr(),\n      dir: 'asc' as const,\n    }) as OrderBuilder<ColumnName, ColumnMeta, JsType>;\n  }\n\n  desc(): OrderBuilder<ColumnName, ColumnMeta, JsType> {\n    return Object.freeze({\n      kind: 'order' as const,\n      expr: this.toExpr(),\n      dir: 'desc' as const,\n    }) as OrderBuilder<ColumnName, ColumnMeta, JsType>;\n  }\n}\n\nexport class TableBuilderImpl<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  Columns extends Record<string, StorageColumn>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n> implements TableRef\n{\n  readonly kind = 'table' as const;\n  readonly columns: ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>;\n  private readonly _name: TableName;\n\n  constructor(\n    name: TableName,\n    columns: ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>,\n  ) {\n    this._name = name;\n    this.columns = columns;\n  }\n\n  get name(): string {\n    return this._name;\n  }\n}\n\nfunction buildColumns<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends keyof Contract['storage']['tables'] & string,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n>(\n  tableName: TableName,\n  storage: SqlStorage,\n  _contract: Contract,\n  operationRegistry?: OperationRegistry,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ColumnBuilders<\n  Contract,\n  TableName,\n  Contract['storage']['tables'][TableName]['columns'],\n  CodecTypes,\n  Operations\n> {\n  const table = storage.tables[tableName];\n\n  if (!table) {\n    throw planInvalid(`Unknown table ${tableName}`);\n  }\n\n  type Columns = Contract['storage']['tables'][TableName]['columns'];\n  const tableColumns = table.columns as Columns;\n\n  const result = {} as {\n    [K in keyof Columns]: ColumnBuilder<\n      K & string,\n      Columns[K],\n      ComputeColumnJsType<Contract, TableName, K & string, Columns[K], CodecTypes>,\n      Operations\n    >;\n  };\n\n  const assignColumn = <ColumnKey extends keyof Columns & string>(\n    columnName: ColumnKey,\n    columnDef: Columns[ColumnKey],\n  ) => {\n    type JsType = ComputeColumnJsType<\n      Contract,\n      TableName,\n      ColumnKey,\n      Columns[ColumnKey],\n      CodecTypes\n    >;\n\n    const columnBuilder = new ColumnBuilderImpl<ColumnKey, Columns[ColumnKey], JsType>(\n      tableName,\n      columnName,\n      columnDef,\n    );\n\n    const builderWithOps = attachOperationsToColumnBuilder<\n      ColumnKey,\n      Columns[ColumnKey],\n      JsType,\n      Operations\n    >(\n      columnBuilder as unknown as ColumnBuilder<\n        ColumnKey,\n        Columns[ColumnKey],\n        JsType,\n        Record<string, never>\n      >,\n      columnDef,\n      operationRegistry,\n      contractCapabilities,\n    );\n\n    (result as Record<string, unknown>)[columnName] = builderWithOps;\n  };\n\n  for (const columnName of Object.keys(tableColumns) as Array<keyof Columns & string>) {\n    const columnDef = tableColumns[columnName];\n    if (!columnDef) continue;\n    assignColumn(columnName, columnDef);\n  }\n\n  return result as ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>;\n}\n\n/**\n * Creates a Proxy that enables accessing table columns directly on the table object,\n * in addition to the standard `table.columns.columnName` syntax.\n *\n * This allows both access patterns:\n * - `tables.user.columns.id` (standard access)\n * - `tables.user.id` (convenience access via proxy)\n *\n * The proxy intercepts property access and routes column name lookups to\n * `table.columns[prop]`, while preserving direct access to table properties\n * like `name`, `kind`, and `columns`.\n */\nfunction createTableProxy<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  Columns extends Record<string, StorageColumn>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n>(\n  table: TableBuilderImpl<Contract, TableName, Columns, CodecTypes, Operations>,\n): TableBuilderImpl<Contract, TableName, Columns, CodecTypes, Operations> {\n  return new Proxy(table, {\n    get(target, prop) {\n      if (prop === 'name' || prop === 'kind' || prop === 'columns') {\n        return Reflect.get(target, prop);\n      }\n      if (typeof prop === 'string' && prop in target.columns) {\n        return target.columns[prop as keyof typeof target.columns];\n      }\n      return undefined;\n    },\n  });\n}\n\ntype ExtractSchemaTables<\n  Contract extends SqlContract<SqlStorage>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n> = {\n  readonly [TableName in keyof Contract['storage']['tables']]: TableBuilderImpl<\n    Contract,\n    TableName & string,\n    TableColumns<Contract['storage']['tables'][TableName]>,\n    CodecTypes,\n    Operations\n  > &\n    TableRef;\n};\n\nexport type SchemaHandle<\n  Contract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>,\n  CodecTypes extends CodecTypesType = CodecTypesType,\n  Operations extends OperationTypes = Record<string, never>,\n> = {\n  readonly tables: ExtractSchemaTables<Contract, CodecTypes, Operations>;\n};\n\ntype SchemaReturnType<Contract extends SqlContract<SqlStorage>> = SchemaHandle<\n  Contract,\n  ExtractCodecTypes<Contract>,\n  ToOperationTypes<ExtractOperationTypes<Contract>>\n>;\n\ntype NormalizeOperationTypes<T> = {\n  [TypeId in keyof T]: {\n    [Method in keyof T[TypeId]]: T[TypeId][Method] extends OperationTypeSignature\n      ? T[TypeId][Method]\n      : OperationTypeSignature;\n  };\n};\n\ntype ToOperationTypes<T> = T extends OperationTypes ? T : NormalizeOperationTypes<T>;\n\n/**\n * Creates a schema handle for building SQL queries.\n *\n * @param context - Query lane context containing contract, codec and operation registries\n * @returns A schema handle with typed table builders\n *\n * @example\n * ```typescript\n * const schemaHandle = schema<Contract>(context);\n * const userTable = schemaHandle.tables.user;\n * ```\n */\nexport function schema<Contract extends SqlContract<SqlStorage>>(\n  context: QueryLaneContext<Contract>,\n): SchemaReturnType<Contract> {\n  const contract = context.contract;\n  const storage = contract.storage;\n  type CodecTypes = ExtractCodecTypes<Contract>;\n  type Operations = ToOperationTypes<ExtractOperationTypes<Contract>>;\n  const tables = {} as ExtractSchemaTables<Contract, CodecTypes, Operations>;\n  const contractCapabilities = contract.capabilities;\n\n  const operationRegistry = context.operations;\n\n  for (const tableName of Object.keys(storage.tables) as Array<\n    keyof Contract['storage']['tables'] & string\n  >) {\n    const columns = buildColumns<Contract, typeof tableName, CodecTypes, Operations>(\n      tableName,\n      storage,\n      contract,\n      operationRegistry,\n      contractCapabilities,\n    );\n    const table = new TableBuilderImpl<\n      Contract,\n      typeof tableName & string,\n      Contract['storage']['tables'][typeof tableName]['columns'],\n      CodecTypes,\n      Operations\n    >(tableName, columns);\n    const proxiedTable = createTableProxy<\n      Contract,\n      typeof tableName & string,\n      Contract['storage']['tables'][typeof tableName]['columns'],\n      CodecTypes,\n      Operations\n    >(table);\n    (tables as Record<string, unknown>)[tableName] = Object.freeze(\n      proxiedTable,\n    ) as ExtractSchemaTables<Contract, CodecTypes, Operations>[typeof tableName];\n  }\n\n  return Object.freeze({ tables }) as SchemaReturnType<Contract>;\n}\n\nexport type { ColumnBuilderImpl as Column, TableBuilderImpl as Table };\n"],"mappings":"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"}
+{"version":3,"file":"schema-BsY2EXAf.mjs","names":["table: string","column: ColumnName","storageColumn: ColumnMeta"],"sources":["../src/schema.ts"],"sourcesContent":["import type { OperationRegistry } from '@prisma-next/operations';\nimport { planInvalid } from '@prisma-next/plan';\nimport type {\n  ExtractCodecTypes,\n  ExtractOperationTypes,\n  SqlContract,\n  SqlStorage,\n  StorageColumn,\n} from '@prisma-next/sql-contract/types';\nimport type { BinaryOp, ColumnRef, ExpressionSource, TableRef } from './ast/types.ts';\nimport { attachOperationsToColumnBuilder } from './operations-registry.ts';\nimport type { QueryLaneContext } from './query-lane-context.ts';\nimport type {\n  BinaryBuilder,\n  CodecTypes as CodecTypesType,\n  ColumnBuilder,\n  ComputeColumnJsType,\n  OperationTypeSignature,\n  OperationTypes,\n  OrderBuilder,\n  ParamPlaceholder,\n} from './types.ts';\n\ntype TableColumns<Table extends { columns: Record<string, StorageColumn> }> = Table['columns'];\n\ntype ColumnBuilders<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  Columns extends Record<string, StorageColumn>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n> = {\n  readonly [K in keyof Columns]: ColumnBuilder<\n    K & string,\n    Columns[K],\n    ComputeColumnJsType<Contract, TableName, K & string, Columns[K], CodecTypes>,\n    Operations\n  >;\n};\n\nexport class ColumnBuilderImpl<\n  ColumnName extends string,\n  ColumnMeta extends StorageColumn,\n  JsType = unknown,\n> implements ExpressionSource\n{\n  readonly kind = 'column' as const;\n\n  constructor(\n    readonly table: string,\n    readonly column: ColumnName,\n    private readonly storageColumn: ColumnMeta,\n  ) {}\n\n  get columnMeta(): ColumnMeta {\n    return this.storageColumn;\n  }\n\n  // Type-level helper property (not used at runtime)\n  get __jsType(): JsType {\n    return undefined as unknown as JsType;\n  }\n\n  /**\n   * Converts this column builder to a ColumnRef expression.\n   * This is the canonical way to get an AST node from a builder.\n   */\n  toExpr(): ColumnRef {\n    return Object.freeze({\n      kind: 'col' as const,\n      table: this.table,\n      column: this.column,\n    });\n  }\n\n  private createBinaryBuilder(\n    op: BinaryOp,\n    value: ParamPlaceholder | ExpressionSource,\n  ): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    if (value == null) {\n      throw planInvalid(\n        'Parameter placeholder or expression source required for column comparison',\n      );\n    }\n    // Check for ExpressionSource first (has toExpr method)\n    if ('toExpr' in value && typeof value.toExpr === 'function') {\n      return Object.freeze({\n        kind: 'binary' as const,\n        op,\n        left: this.toExpr(),\n        right: value,\n      }) as BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n    }\n    // Must be a ParamPlaceholder\n    if ('kind' in value && value.kind === 'param-placeholder') {\n      return Object.freeze({\n        kind: 'binary' as const,\n        op,\n        left: this.toExpr(),\n        right: value,\n      }) as BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n    }\n    throw planInvalid('Parameter placeholder or expression source required for column comparison');\n  }\n\n  eq(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('eq', value);\n  }\n\n  neq(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('neq', value);\n  }\n\n  gt(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('gt', value);\n  }\n\n  lt(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('lt', value);\n  }\n\n  gte(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('gte', value);\n  }\n\n  lte(value: ParamPlaceholder | ExpressionSource): BinaryBuilder<ColumnName, ColumnMeta, JsType> {\n    return this.createBinaryBuilder('lte', value);\n  }\n\n  asc(): OrderBuilder<ColumnName, ColumnMeta, JsType> {\n    return Object.freeze({\n      kind: 'order' as const,\n      expr: this.toExpr(),\n      dir: 'asc' as const,\n    }) as OrderBuilder<ColumnName, ColumnMeta, JsType>;\n  }\n\n  desc(): OrderBuilder<ColumnName, ColumnMeta, JsType> {\n    return Object.freeze({\n      kind: 'order' as const,\n      expr: this.toExpr(),\n      dir: 'desc' as const,\n    }) as OrderBuilder<ColumnName, ColumnMeta, JsType>;\n  }\n}\n\nexport class TableBuilderImpl<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  Columns extends Record<string, StorageColumn>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n> implements TableRef\n{\n  readonly kind = 'table' as const;\n  readonly columns: ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>;\n  private readonly _name: TableName;\n\n  constructor(\n    name: TableName,\n    columns: ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>,\n  ) {\n    this._name = name;\n    this.columns = columns;\n  }\n\n  get name(): string {\n    return this._name;\n  }\n}\n\nfunction buildColumns<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends keyof Contract['storage']['tables'] & string,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n>(\n  tableName: TableName,\n  storage: SqlStorage,\n  _contract: Contract,\n  operationRegistry?: OperationRegistry,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ColumnBuilders<\n  Contract,\n  TableName,\n  Contract['storage']['tables'][TableName]['columns'],\n  CodecTypes,\n  Operations\n> {\n  const table = storage.tables[tableName];\n\n  if (!table) {\n    throw planInvalid(`Unknown table ${tableName}`);\n  }\n\n  type Columns = Contract['storage']['tables'][TableName]['columns'];\n  const tableColumns = table.columns as Columns;\n\n  const result = {} as {\n    [K in keyof Columns]: ColumnBuilder<\n      K & string,\n      Columns[K],\n      ComputeColumnJsType<Contract, TableName, K & string, Columns[K], CodecTypes>,\n      Operations\n    >;\n  };\n\n  const assignColumn = <ColumnKey extends keyof Columns & string>(\n    columnName: ColumnKey,\n    columnDef: Columns[ColumnKey],\n  ) => {\n    type JsType = ComputeColumnJsType<\n      Contract,\n      TableName,\n      ColumnKey,\n      Columns[ColumnKey],\n      CodecTypes\n    >;\n\n    const columnBuilder = new ColumnBuilderImpl<ColumnKey, Columns[ColumnKey], JsType>(\n      tableName,\n      columnName,\n      columnDef,\n    );\n\n    const builderWithOps = attachOperationsToColumnBuilder<\n      ColumnKey,\n      Columns[ColumnKey],\n      JsType,\n      Operations\n    >(\n      columnBuilder as unknown as ColumnBuilder<\n        ColumnKey,\n        Columns[ColumnKey],\n        JsType,\n        Record<string, never>\n      >,\n      columnDef,\n      operationRegistry,\n      contractCapabilities,\n    );\n\n    (result as Record<string, unknown>)[columnName] = builderWithOps;\n  };\n\n  for (const columnName of Object.keys(tableColumns) as Array<keyof Columns & string>) {\n    const columnDef = tableColumns[columnName];\n    if (!columnDef) continue;\n    assignColumn(columnName, columnDef);\n  }\n\n  return result as ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>;\n}\n\n/**\n * Creates a Proxy that enables accessing table columns directly on the table object,\n * in addition to the standard `table.columns.columnName` syntax.\n *\n * This allows both access patterns:\n * - `tables.user.columns.id` (standard access)\n * - `tables.user.id` (convenience access via proxy)\n *\n * The proxy intercepts property access and routes column name lookups to\n * `table.columns[prop]`, while preserving direct access to table properties\n * like `name`, `kind`, and `columns`.\n */\nfunction createTableProxy<\n  Contract extends SqlContract<SqlStorage>,\n  TableName extends string,\n  Columns extends Record<string, StorageColumn>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n>(\n  table: TableBuilderImpl<Contract, TableName, Columns, CodecTypes, Operations>,\n): TableBuilderImpl<Contract, TableName, Columns, CodecTypes, Operations> {\n  return new Proxy(table, {\n    get(target, prop) {\n      if (prop === 'name' || prop === 'kind' || prop === 'columns') {\n        return Reflect.get(target, prop);\n      }\n      if (typeof prop === 'string' && prop in target.columns) {\n        return target.columns[prop as keyof typeof target.columns];\n      }\n      return undefined;\n    },\n  });\n}\n\ntype ExtractSchemaTables<\n  Contract extends SqlContract<SqlStorage>,\n  CodecTypes extends CodecTypesType,\n  Operations extends OperationTypes,\n> = {\n  readonly [TableName in keyof Contract['storage']['tables']]: TableBuilderImpl<\n    Contract,\n    TableName & string,\n    TableColumns<Contract['storage']['tables'][TableName]>,\n    CodecTypes,\n    Operations\n  > &\n    TableRef;\n};\n\nexport type SchemaHandle<\n  Contract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>,\n  CodecTypes extends CodecTypesType = CodecTypesType,\n  Operations extends OperationTypes = Record<string, never>,\n> = {\n  readonly tables: ExtractSchemaTables<Contract, CodecTypes, Operations>;\n};\n\ntype SchemaReturnType<Contract extends SqlContract<SqlStorage>> = SchemaHandle<\n  Contract,\n  ExtractCodecTypes<Contract>,\n  ToOperationTypes<ExtractOperationTypes<Contract>>\n>;\n\ntype NormalizeOperationTypes<T> = {\n  [TypeId in keyof T]: {\n    [Method in keyof T[TypeId]]: T[TypeId][Method] extends OperationTypeSignature\n      ? T[TypeId][Method]\n      : OperationTypeSignature;\n  };\n};\n\ntype ToOperationTypes<T> = T extends OperationTypes ? T : NormalizeOperationTypes<T>;\n\n/**\n * Creates a schema handle for building SQL queries.\n *\n * @param context - Query lane context containing contract, codec and operation registries\n * @returns A schema handle with typed table builders\n *\n * @example\n * ```typescript\n * const schemaHandle = schema<Contract>(context);\n * const userTable = schemaHandle.tables.user;\n * ```\n */\nexport function schema<Contract extends SqlContract<SqlStorage>>(\n  context: QueryLaneContext<Contract>,\n): SchemaReturnType<Contract> {\n  const contract = context.contract;\n  const storage = contract.storage;\n  type CodecTypes = ExtractCodecTypes<Contract>;\n  type Operations = ToOperationTypes<ExtractOperationTypes<Contract>>;\n  const tables = {} as ExtractSchemaTables<Contract, CodecTypes, Operations>;\n  const contractCapabilities = contract.capabilities;\n\n  const operationRegistry = context.operations;\n\n  for (const tableName of Object.keys(storage.tables) as Array<\n    keyof Contract['storage']['tables'] & string\n  >) {\n    const columns = buildColumns<Contract, typeof tableName, CodecTypes, Operations>(\n      tableName,\n      storage,\n      contract,\n      operationRegistry,\n      contractCapabilities,\n    );\n    const table = new TableBuilderImpl<\n      Contract,\n      typeof tableName & string,\n      Contract['storage']['tables'][typeof tableName]['columns'],\n      CodecTypes,\n      Operations\n    >(tableName, columns);\n    const proxiedTable = createTableProxy<\n      Contract,\n      typeof tableName & string,\n      Contract['storage']['tables'][typeof tableName]['columns'],\n      CodecTypes,\n      Operations\n    >(table);\n    (tables as Record<string, unknown>)[tableName] = Object.freeze(\n      proxiedTable,\n    ) as ExtractSchemaTables<Contract, CodecTypes, Operations>[typeof tableName];\n  }\n\n  return Object.freeze({ tables }) as SchemaReturnType<Contract>;\n}\n\nexport type { ColumnBuilderImpl as Column, TableBuilderImpl as Table };\n"],"mappings":"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"}

package/dist/schema-Dse48uyP.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-Dse48uyP.d.mts","names":[],"sources":["../src/schema.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"schema-Dse48uyP.d.mts","names":[],"sources":["../src/schema.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/types-D_FRJvm0.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"types-D_FRJvm0.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["import type {\n  ResultType as CoreResultType,\n  ExecutionPlan,\n  PlanRefs,\n} from '@prisma-next/contract/types';\nimport type { ArgSpec, ReturnSpec } from '@prisma-next/operations';\nimport type { SqlContract, SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';\nimport type { SqlLoweringSpec } from '@prisma-next/sql-operations';\nimport type {\n  BinaryOp,\n  ColumnRef,\n  Direction,\n  Expression,\n  ExpressionSource,\n  OperationExpr,\n  ParamRef,\n  QueryAst,\n} from './ast/types';\nimport type { SqlQueryPlan } from './plan';\nimport type { QueryLaneContext } from './query-lane-context';\n\nexport interface ParamPlaceholder {\n  readonly kind: 'param-placeholder';\n  readonly name: string;\n}\n\n/**\n * ValueSource represents any value that can appear in a comparison or as an argument.\n * This includes:\n * - ParamPlaceholder: A parameter placeholder (e.g., `param('userId')`)\n * - ExpressionSource: Something that can be converted to an Expression (ColumnBuilder, ExpressionBuilder)\n */\nexport type ValueSource = ParamPlaceholder | ExpressionSource;\n\nexport interface OrderBuilder<\n  _ColumnName extends string = string,\n  _ColumnMeta extends StorageColumn = StorageColumn,\n  _JsType = unknown,\n> {\n  readonly kind: 'order';\n  readonly expr: Expression;\n  readonly dir: Direction;\n}\n\n/**\n * Creates an OrderBuilder for use in orderBy clauses.\n */\nexport function createOrderBuilder(\n  expr: AnyColumnBuilder | OperationExpr,\n  dir: Direction,\n): AnyOrderBuilder {\n  return { kind: 'order', expr, dir } as AnyOrderBuilder;\n}\n\n/**\n * ColumnBuilder with optional operation methods based on the column's typeId.\n * When Operations is provided and the column's typeId matches, operation methods are included.\n * Implements ExpressionSource to provide type-safe conversion to ColumnRef.\n */\nexport type ColumnBuilder<\n  ColumnName extends string = string,\n  ColumnMeta extends StorageColumn = StorageColumn,\n  JsType = unknown,\n  Operations extends OperationTypes = Record<string, never>,\n> = {\n  readonly kind: 'column';\n  readonly table: string;\n  readonly column: ColumnName;\n  readonly columnMeta: ColumnMeta;\n  // Methods accept ValueSource (ParamPlaceholder or ExpressionSource)\n  eq(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  neq(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  gt(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  lt(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  gte(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  lte(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  asc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;\n  desc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;\n  /** Converts this column builder to a ColumnRef expression */\n  toExpr(): ColumnRef;\n  // Helper property for type extraction (not used at runtime)\n  readonly __jsType: JsType;\n} & (ColumnMeta['codecId'] extends string\n  ? ColumnMeta['codecId'] extends keyof Operations\n    ? OperationMethods<\n        OperationsForTypeId<ColumnMeta['codecId'] & string, Operations>,\n        ColumnName,\n        StorageColumn,\n        JsType\n      >\n    : Record<string, never>\n  : Record<string, never>);\n\nexport interface BinaryBuilder<\n  _ColumnName extends string = string,\n  _ColumnMeta extends StorageColumn = StorageColumn,\n  _JsType = unknown,\n> {\n  readonly kind: 'binary';\n  readonly op: BinaryOp;\n  readonly left: Expression;\n  readonly right: ValueSource;\n}\n\n// Forward declare AnyBinaryBuilder and AnyOrderBuilder for use in ExpressionBuilder\nexport type AnyBinaryBuilder = BinaryBuilder;\nexport type AnyOrderBuilder = OrderBuilder;\n\n/**\n * ExpressionBuilder represents the result of an operation (e.g., col.distance(...)).\n * Unlike ColumnBuilder (which represents a column), ExpressionBuilder represents\n * an operation expression and provides the same DSL methods for chaining.\n *\n * Implements ExpressionSource to provide type-safe conversion to OperationExpr.\n */\nexport interface ExpressionBuilder<JsType = unknown> extends ExpressionSource {\n  readonly kind: 'expression';\n  readonly expr: OperationExpr;\n  readonly columnMeta: StorageColumn;\n\n  // Methods accept ValueSource (ParamPlaceholder or ExpressionSource)\n  eq(value: ValueSource): AnyBinaryBuilder;\n  neq(value: ValueSource): AnyBinaryBuilder;\n  gt(value: ValueSource): AnyBinaryBuilder;\n  lt(value: ValueSource): AnyBinaryBuilder;\n  gte(value: ValueSource): AnyBinaryBuilder;\n  lte(value: ValueSource): AnyBinaryBuilder;\n  asc(): AnyOrderBuilder;\n  desc(): AnyOrderBuilder;\n\n  /** Converts this expression builder to the underlying OperationExpr */\n  toExpr(): OperationExpr;\n\n  // Helper property for type extraction (not used at runtime)\n  readonly __jsType: JsType;\n}\n\n// Helper aliases for usage sites where the specific column parameters are irrelevant\n// Accepts any ColumnBuilder regardless of its Operations parameter\n// Note: We use `any` here because TypeScript's variance rules don't allow us to express\n// \"any type that extends OperationTypes\" in a way that works for assignment.\n// Contract-specific OperationTypes (e.g., PgVectorOperationTypes) are not assignable\n// to the base OperationTypes in generic parameter position, even though they extend it structurally.\n// Helper type that accepts any ColumnBuilder regardless of its generic parameters\n// This is needed because conditional types in ColumnBuilder create incompatible intersection types\n// when Operations differs, even though structurally they're compatible\nexport type AnyColumnBuilderBase = {\n  readonly kind: 'column';\n  readonly table: string;\n  readonly column: string;\n  readonly columnMeta: StorageColumn;\n  // Methods accept ValueSource (ParamPlaceholder or ExpressionSource)\n  eq(value: ValueSource): AnyBinaryBuilder;\n  neq(value: ValueSource): AnyBinaryBuilder;\n  gt(value: ValueSource): AnyBinaryBuilder;\n  lt(value: ValueSource): AnyBinaryBuilder;\n  gte(value: ValueSource): AnyBinaryBuilder;\n  lte(value: ValueSource): AnyBinaryBuilder;\n  asc(): AnyOrderBuilder;\n  desc(): AnyOrderBuilder;\n  toExpr(): ColumnRef;\n  readonly __jsType: unknown;\n  // Allow any operation methods (from conditional type)\n  readonly [key: string]: unknown;\n};\n\nexport type AnyColumnBuilder =\n  | ColumnBuilder<\n      string,\n      StorageColumn,\n      unknown,\n      // biome-ignore lint/suspicious/noExplicitAny: AnyColumnBuilder must accept column builders with any operation types\n      any\n    >\n  | AnyColumnBuilderBase;\n\n/**\n * Union type for any builder that can produce an Expression.\n * Used in DSL method signatures where either a column or operation result can be passed.\n */\nexport type AnyExpressionSource = AnyColumnBuilder | ExpressionBuilder;\n\nexport function isColumnBuilder(value: unknown): value is AnyColumnBuilder {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'kind' in value &&\n    (value as { kind: unknown }).kind === 'column'\n  );\n}\n\nexport interface JoinOnBuilder {\n  eqCol(left: AnyColumnBuilder, right: AnyColumnBuilder): JoinOnPredicate;\n}\n\nexport interface JoinOnPredicate {\n  readonly kind: 'join-on';\n  readonly left: AnyColumnBuilder;\n  readonly right: AnyColumnBuilder;\n}\n\nexport type Expr = ColumnRef | ParamRef;\n\n/**\n * Helper type to extract codec output type from CodecTypes.\n * Returns never if the codecId is not found in CodecTypes.\n */\ntype ExtractCodecOutputType<\n  CodecId extends string,\n  CodecTypes extends Record<string, { readonly output: unknown }>,\n> = CodecId extends keyof CodecTypes\n  ? CodecTypes[CodecId] extends { readonly output: infer Output }\n    ? Output\n    : never\n  : never;\n\n/**\n * Type-level operation signature.\n * Represents an operation at the type level, similar to OperationSignature at runtime.\n */\nexport type OperationTypeSignature = {\n  readonly args: ReadonlyArray<ArgSpec>;\n  readonly returns: ReturnSpec;\n  readonly lowering: SqlLoweringSpec;\n  readonly capabilities?: ReadonlyArray<string>;\n};\n\n/**\n * Type-level operation registry.\n * Maps typeId → operations, where operations is a record of method name → operation signature.\n *\n * Example:\n * ```typescript\n * type MyOperations: OperationTypes = {\n *   'pg/vector@1': {\n *     cosineDistance: {\n *       args: [{ kind: 'typeId'; type: 'pg/vector@1' }];\n *       returns: { kind: 'builtin'; type: 'number' };\n *       lowering: { targetFamily: 'sql'; strategy: 'function'; template: '...' };\n *     };\n *   };\n * };\n * ```\n */\nexport type OperationTypes = Record<string, Record<string, OperationTypeSignature>>;\n\n/**\n * CodecTypes represents a map of typeId to codec definitions.\n * Each codec definition must have an `output` property indicating the JavaScript type.\n *\n * Example:\n * ```typescript\n * type MyCodecTypes: CodecTypes = {\n *   'pg/int4@1': { output: number };\n *   'pg/text@1': { output: string };\n * };\n * ```\n */\nexport type CodecTypes = Record<string, { readonly output: unknown }>;\n\n/**\n * Extracts operations for a given typeId from the operation registry.\n * Returns an empty record if the typeId is not found.\n *\n * @example\n * ```typescript\n * type Ops = OperationsForTypeId<'pg/vector@1', MyOperations>;\n * // Ops = { cosineDistance: { ... }, l2Distance: { ... } }\n * ```\n */\nexport type OperationsForTypeId<\n  TypeId extends string,\n  Operations extends OperationTypes,\n> = Operations extends Record<string, never>\n  ? Record<string, never>\n  : TypeId extends keyof Operations\n    ? Operations[TypeId]\n    : Record<string, never>;\n\n/**\n * Maps operation signatures to method signatures on ColumnBuilder.\n * Each operation becomes a method that returns a ColumnBuilder or BinaryBuilder\n * based on the return type.\n */\ntype OperationMethods<\n  Ops extends Record<string, OperationTypeSignature>,\n  ColumnName extends string,\n  ColumnMeta extends StorageColumn,\n  JsType,\n> = {\n  [K in keyof Ops]: Ops[K] extends OperationTypeSignature\n    ? (\n        ...args: OperationArgs<Ops[K]['args']>\n      ) => OperationReturn<Ops[K]['returns'], ColumnName, ColumnMeta, JsType>\n    : never;\n};\n\n/**\n * Maps operation argument specs to TypeScript argument types.\n * - typeId args: ColumnBuilder (accepts base columns or operation results)\n * - param args: ParamPlaceholder\n * - literal args: unknown (could be more specific in future)\n */\ntype OperationArgs<Args extends ReadonlyArray<ArgSpec>> = Args extends readonly [\n  infer First,\n  ...infer Rest,\n]\n  ? First extends ArgSpec\n    ? [ArgToType<First>, ...(Rest extends ReadonlyArray<ArgSpec> ? OperationArgs<Rest> : [])]\n    : []\n  : [];\n\ntype ArgToType<Arg extends ArgSpec> = Arg extends { kind: 'typeId' }\n  ? AnyExpressionSource\n  : Arg extends { kind: 'param' }\n    ? ParamPlaceholder\n    : Arg extends { kind: 'literal' }\n      ? unknown\n      : never;\n\n/**\n * Maps operation return spec to return type.\n * Operations return ExpressionBuilder, not ColumnBuilder, because the result\n * represents an expression (OperationExpr) rather than a column reference.\n */\ntype OperationReturn<\n  Returns extends ReturnSpec,\n  _ColumnName extends string,\n  _ColumnMeta extends StorageColumn,\n  _JsType,\n> = Returns extends { kind: 'builtin'; type: infer T }\n  ? T extends 'number'\n    ? ExpressionBuilder<number>\n    : T extends 'boolean'\n      ? ExpressionBuilder<boolean>\n      : T extends 'string'\n        ? ExpressionBuilder<string>\n        : ExpressionBuilder<unknown>\n  : Returns extends { kind: 'typeId' }\n    ? ExpressionBuilder<unknown>\n    : ExpressionBuilder<unknown>;\n\n/**\n * Computes JavaScript type for a column at column creation time.\n *\n * Type inference:\n * - Read columnMeta.codecId as typeId string literal\n * - Look up CodecTypes[typeId].output\n * - Apply nullability: nullable ? Output | null : Output\n */\ntype ColumnMetaTypeId<ColumnMeta> = ColumnMeta extends { codecId: infer CodecId extends string }\n  ? CodecId\n  : ColumnMeta extends { type: infer TypeId extends string }\n    ? TypeId\n    : never;\n\nexport type ComputeColumnJsType<\n  _Contract extends SqlContract<SqlStorage>,\n  _TableName extends string,\n  _ColumnName extends string,\n  ColumnMeta extends StorageColumn,\n  CodecTypes extends Record<string, { readonly output: unknown }>,\n> = ColumnMeta extends { nullable: infer Nullable }\n  ? ColumnMetaTypeId<ColumnMeta> extends infer TypeId\n    ? TypeId extends string\n      ? ExtractCodecOutputType<TypeId, CodecTypes> extends infer CodecOutput\n        ? [CodecOutput] extends [never]\n          ? unknown // Codec not found in CodecTypes\n          : Nullable extends true\n            ? CodecOutput | null\n            : CodecOutput\n        : unknown\n      : unknown\n    : unknown\n  : unknown;\n\n/**\n * Infers Row type from a projection object.\n * Maps Record<string, ColumnBuilder> to Record<string, JSType>\n *\n * Extracts the pre-computed JsType from each ColumnBuilder in the projection.\n */\n/**\n * Extracts the inferred JsType carried by a ColumnBuilder.\n */\ntype ExtractJsTypeFromColumnBuilder<CB extends AnyColumnBuilder> =\n  CB extends ColumnBuilder<\n    infer _ColumnName extends string,\n    infer _ColumnMeta extends StorageColumn,\n    infer JsType,\n    infer _Ops\n  >\n    ? JsType\n    : never;\n\nexport type InferProjectionRow<P extends Record<string, AnyColumnBuilder>> = {\n  [K in keyof P]: ExtractJsTypeFromColumnBuilder<P[K]>;\n};\n\n/**\n * Nested projection type - allows recursive nesting of ColumnBuilder, ExpressionBuilder, or nested objects.\n */\nexport type NestedProjection = Record<\n  string,\n  | AnyExpressionSource\n  | Record<\n      string,\n      | AnyExpressionSource\n      | Record<\n          string,\n          | AnyExpressionSource\n          | Record<string, AnyExpressionSource | Record<string, AnyExpressionSource>>\n        >\n    >\n>;\n\n/**\n * Helper type to extract include type from Includes map.\n * Returns the value type if K is a key of Includes, otherwise returns unknown.\n */\ntype ExtractIncludeType<\n  K extends string,\n  Includes extends Record<string, unknown>,\n> = K extends keyof Includes ? Includes[K] : unknown;\n\n/**\n * Infers Row type from a nested projection object.\n * Recursively maps Record<string, ColumnBuilder | boolean | NestedProjection> to nested object types.\n *\n * Extracts the pre-computed JsType from each ColumnBuilder at leaves.\n * When a value is `true`, it represents an include reference and infers `Array<ChildShape>`\n * by looking up the include alias in the Includes type map.\n */\nexport type InferNestedProjectionRow<\n  P extends Record<string, AnyExpressionSource | boolean | NestedProjection>,\n  CodecTypes extends Record<string, { readonly output: unknown }> = Record<string, never>,\n  Includes extends Record<string, unknown> = Record<string, never>,\n> = {\n  [K in keyof P]: P[K] extends ExpressionBuilder<infer JsType>\n    ? JsType\n    : P[K] extends AnyColumnBuilder\n      ? ExtractJsTypeFromColumnBuilder<P[K]>\n      : P[K] extends true\n        ? Array<ExtractIncludeType<K & string, Includes>> // Include reference - infers Array<ChildShape> from Includes map\n        : P[K] extends NestedProjection\n          ? InferNestedProjectionRow<P[K], CodecTypes, Includes>\n          : never;\n};\n\n/**\n * Infers Row type from a tuple of ColumnBuilders used in returning() clause.\n * Extracts column name and JsType from each ColumnBuilder and creates a Record.\n */\nexport type InferReturningRow<Columns extends readonly AnyColumnBuilder[]> =\n  Columns extends readonly [infer First, ...infer Rest]\n    ? First extends ColumnBuilder<\n        infer Name,\n        infer _Meta,\n        infer JsType,\n        infer _Ops extends OperationTypes\n      >\n      ? Name extends string\n        ? Rest extends readonly AnyColumnBuilder[]\n          ? { [K in Name]: JsType } & InferReturningRow<Rest>\n          : { [K in Name]: JsType }\n        : never\n      : never\n    : Record<string, never>;\n\n/**\n * Utility type to check if a contract has the required capabilities for includeMany.\n * Requires both `lateral` and `jsonAgg` to be `true` in the contract's capabilities for the target.\n * Capabilities are nested by target: `{ [target]: { lateral: true, jsonAgg: true } }`\n */\nexport type HasIncludeManyCapabilities<TContract extends SqlContract<SqlStorage>> =\n  TContract extends { capabilities: infer C; target: infer T }\n    ? T extends string\n      ? C extends Record<string, Record<string, boolean>>\n        ? C extends { [K in T]: infer TargetCaps }\n          ? TargetCaps extends { lateral: true; jsonAgg: true }\n            ? true\n            : false\n          : false\n        : false\n      : false\n    : false;\n\n/**\n * SQL-specific Plan type that refines the ast field to use QueryAst.\n * This is the type used by SQL query builders.\n */\nexport type SqlPlan<Row = unknown> = ExecutionPlan<Row, QueryAst>;\n\n/**\n * Helper types for extracting contract structure.\n */\nexport type TablesOf<TContract> = TContract extends {\n  storage: { tables: infer U };\n}\n  ? U\n  : never;\n\nexport type TableKey<TContract> = Extract<keyof TablesOf<TContract>, string>;\n\n// Common types for contract.d.ts generation (SQL-specific)\n// These types are used by emitted contract.d.ts files to provide type-safe DSL/ORM types\n\n/**\n * Unique symbol for metadata property to avoid collisions with user-defined properties\n */\nexport declare const META: unique symbol;\n\n/**\n * Extracts metadata from a type that has a META property\n */\nexport type Meta<T extends { [META]: unknown }> = T[typeof META];\n\n/**\n * Metadata interface for table definitions\n */\nexport interface TableMetadata<Name extends string> {\n  name: Name;\n}\n\n/**\n * Metadata interface for model definitions\n */\nexport interface ModelMetadata<Name extends string> {\n  name: Name;\n}\n\n/**\n * Base interface for table definitions with metadata\n * Used in contract.d.ts to define storage-level table types\n */\nexport interface TableDef<Name extends string> {\n  readonly [META]: TableMetadata<Name>;\n}\n\n/**\n * Base interface for model definitions with metadata\n * Used in contract.d.ts to define application-level model types\n */\nexport interface ModelDef<Name extends string> {\n  readonly [META]: ModelMetadata<Name>;\n}\n\nexport type ColumnsOf<\n  TContract,\n  K extends TableKey<TContract>,\n> = K extends keyof TablesOf<TContract>\n  ? TablesOf<TContract>[K] extends { columns: infer C }\n    ? C\n    : never\n  : never;\n\nexport interface RawTemplateOptions {\n  readonly refs?: PlanRefs;\n  readonly annotations?: Record<string, unknown>;\n  readonly projection?: ReadonlyArray<string>;\n}\n\nexport interface RawFunctionOptions extends RawTemplateOptions {\n  readonly params: ReadonlyArray<unknown>;\n}\n\nexport type RawTemplateFactory = (\n  strings: TemplateStringsArray,\n  ...values: readonly unknown[]\n) => ExecutionPlan;\n\nexport interface RawFactory extends RawTemplateFactory {\n  (text: string, options: RawFunctionOptions): ExecutionPlan;\n  with(options: RawTemplateOptions): RawTemplateFactory;\n}\n\nexport type { RuntimeError } from '@prisma-next/plan';\n\nexport interface BuildParamsMap {\n  readonly [name: string]: unknown;\n}\n\nexport interface BuildOptions {\n  readonly params?: BuildParamsMap;\n}\n\nexport interface SqlBuilderOptions<\n  TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>,\n> {\n  readonly context: QueryLaneContext<TContract>;\n}\n\n/**\n * SQL-specific ResultType that works with both Plan and SqlQueryPlan.\n * This extends the core ResultType to also handle SqlQueryPlan.\n * Example: `type Row = ResultType<typeof plan>`\n */\nexport type ResultType<P> = P extends SqlQueryPlan<infer R> ? R : CoreResultType<P>;\n"],"mappings":";;;;AA+CA,SAAgB,mBACd,MACA,KACiB;AACjB,QAAO;EAAE,MAAM;EAAS;EAAM;EAAK;;AAmIrC,SAAgB,gBAAgB,OAA2C;AACzE,QACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS"}
+{"version":3,"file":"types-D_FRJvm0.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["import type {\n  ResultType as CoreResultType,\n  ExecutionPlan,\n  PlanRefs,\n} from '@prisma-next/contract/types';\nimport type { ArgSpec, ReturnSpec } from '@prisma-next/operations';\nimport type { SqlContract, SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';\nimport type { SqlLoweringSpec } from '@prisma-next/sql-operations';\nimport type {\n  BinaryOp,\n  ColumnRef,\n  Direction,\n  Expression,\n  ExpressionSource,\n  OperationExpr,\n  ParamRef,\n  QueryAst,\n} from './ast/types.ts';\nimport type { SqlQueryPlan } from './plan.ts';\nimport type { QueryLaneContext } from './query-lane-context.ts';\n\nexport interface ParamPlaceholder {\n  readonly kind: 'param-placeholder';\n  readonly name: string;\n}\n\n/**\n * ValueSource represents any value that can appear in a comparison or as an argument.\n * This includes:\n * - ParamPlaceholder: A parameter placeholder (e.g., `param('userId')`)\n * - ExpressionSource: Something that can be converted to an Expression (ColumnBuilder, ExpressionBuilder)\n */\nexport type ValueSource = ParamPlaceholder | ExpressionSource;\n\nexport interface OrderBuilder<\n  _ColumnName extends string = string,\n  _ColumnMeta extends StorageColumn = StorageColumn,\n  _JsType = unknown,\n> {\n  readonly kind: 'order';\n  readonly expr: Expression;\n  readonly dir: Direction;\n}\n\n/**\n * Creates an OrderBuilder for use in orderBy clauses.\n */\nexport function createOrderBuilder(\n  expr: AnyColumnBuilder | OperationExpr,\n  dir: Direction,\n): AnyOrderBuilder {\n  return { kind: 'order', expr, dir } as AnyOrderBuilder;\n}\n\n/**\n * ColumnBuilder with optional operation methods based on the column's typeId.\n * When Operations is provided and the column's typeId matches, operation methods are included.\n * Implements ExpressionSource to provide type-safe conversion to ColumnRef.\n */\nexport type ColumnBuilder<\n  ColumnName extends string = string,\n  ColumnMeta extends StorageColumn = StorageColumn,\n  JsType = unknown,\n  Operations extends OperationTypes = Record<string, never>,\n> = {\n  readonly kind: 'column';\n  readonly table: string;\n  readonly column: ColumnName;\n  readonly columnMeta: ColumnMeta;\n  // Methods accept ValueSource (ParamPlaceholder or ExpressionSource)\n  eq(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  neq(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  gt(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  lt(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  gte(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  lte(value: ValueSource): BinaryBuilder<ColumnName, ColumnMeta, JsType>;\n  asc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;\n  desc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;\n  /** Converts this column builder to a ColumnRef expression */\n  toExpr(): ColumnRef;\n  // Helper property for type extraction (not used at runtime)\n  readonly __jsType: JsType;\n} & (ColumnMeta['codecId'] extends string\n  ? ColumnMeta['codecId'] extends keyof Operations\n    ? OperationMethods<\n        OperationsForTypeId<ColumnMeta['codecId'] & string, Operations>,\n        ColumnName,\n        StorageColumn,\n        JsType\n      >\n    : Record<string, never>\n  : Record<string, never>);\n\nexport interface BinaryBuilder<\n  _ColumnName extends string = string,\n  _ColumnMeta extends StorageColumn = StorageColumn,\n  _JsType = unknown,\n> {\n  readonly kind: 'binary';\n  readonly op: BinaryOp;\n  readonly left: Expression;\n  readonly right: ValueSource;\n}\n\n// Forward declare AnyBinaryBuilder and AnyOrderBuilder for use in ExpressionBuilder\nexport type AnyBinaryBuilder = BinaryBuilder;\nexport type AnyOrderBuilder = OrderBuilder;\n\n/**\n * ExpressionBuilder represents the result of an operation (e.g., col.distance(...)).\n * Unlike ColumnBuilder (which represents a column), ExpressionBuilder represents\n * an operation expression and provides the same DSL methods for chaining.\n *\n * Implements ExpressionSource to provide type-safe conversion to OperationExpr.\n */\nexport interface ExpressionBuilder<JsType = unknown> extends ExpressionSource {\n  readonly kind: 'expression';\n  readonly expr: OperationExpr;\n  readonly columnMeta: StorageColumn;\n\n  // Methods accept ValueSource (ParamPlaceholder or ExpressionSource)\n  eq(value: ValueSource): AnyBinaryBuilder;\n  neq(value: ValueSource): AnyBinaryBuilder;\n  gt(value: ValueSource): AnyBinaryBuilder;\n  lt(value: ValueSource): AnyBinaryBuilder;\n  gte(value: ValueSource): AnyBinaryBuilder;\n  lte(value: ValueSource): AnyBinaryBuilder;\n  asc(): AnyOrderBuilder;\n  desc(): AnyOrderBuilder;\n\n  /** Converts this expression builder to the underlying OperationExpr */\n  toExpr(): OperationExpr;\n\n  // Helper property for type extraction (not used at runtime)\n  readonly __jsType: JsType;\n}\n\n// Helper aliases for usage sites where the specific column parameters are irrelevant\n// Accepts any ColumnBuilder regardless of its Operations parameter\n// Note: We use `any` here because TypeScript's variance rules don't allow us to express\n// \"any type that extends OperationTypes\" in a way that works for assignment.\n// Contract-specific OperationTypes (e.g., PgVectorOperationTypes) are not assignable\n// to the base OperationTypes in generic parameter position, even though they extend it structurally.\n// Helper type that accepts any ColumnBuilder regardless of its generic parameters\n// This is needed because conditional types in ColumnBuilder create incompatible intersection types\n// when Operations differs, even though structurally they're compatible\nexport type AnyColumnBuilderBase = {\n  readonly kind: 'column';\n  readonly table: string;\n  readonly column: string;\n  readonly columnMeta: StorageColumn;\n  // Methods accept ValueSource (ParamPlaceholder or ExpressionSource)\n  eq(value: ValueSource): AnyBinaryBuilder;\n  neq(value: ValueSource): AnyBinaryBuilder;\n  gt(value: ValueSource): AnyBinaryBuilder;\n  lt(value: ValueSource): AnyBinaryBuilder;\n  gte(value: ValueSource): AnyBinaryBuilder;\n  lte(value: ValueSource): AnyBinaryBuilder;\n  asc(): AnyOrderBuilder;\n  desc(): AnyOrderBuilder;\n  toExpr(): ColumnRef;\n  readonly __jsType: unknown;\n  // Allow any operation methods (from conditional type)\n  readonly [key: string]: unknown;\n};\n\nexport type AnyColumnBuilder =\n  | ColumnBuilder<\n      string,\n      StorageColumn,\n      unknown,\n      // biome-ignore lint/suspicious/noExplicitAny: AnyColumnBuilder must accept column builders with any operation types\n      any\n    >\n  | AnyColumnBuilderBase;\n\n/**\n * Union type for any builder that can produce an Expression.\n * Used in DSL method signatures where either a column or operation result can be passed.\n */\nexport type AnyExpressionSource = AnyColumnBuilder | ExpressionBuilder;\n\nexport function isColumnBuilder(value: unknown): value is AnyColumnBuilder {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'kind' in value &&\n    (value as { kind: unknown }).kind === 'column'\n  );\n}\n\nexport interface JoinOnBuilder {\n  eqCol(left: AnyColumnBuilder, right: AnyColumnBuilder): JoinOnPredicate;\n}\n\nexport interface JoinOnPredicate {\n  readonly kind: 'join-on';\n  readonly left: AnyColumnBuilder;\n  readonly right: AnyColumnBuilder;\n}\n\nexport type Expr = ColumnRef | ParamRef;\n\n/**\n * Helper type to extract codec output type from CodecTypes.\n * Returns never if the codecId is not found in CodecTypes.\n */\ntype ExtractCodecOutputType<\n  CodecId extends string,\n  CodecTypes extends Record<string, { readonly output: unknown }>,\n> = CodecId extends keyof CodecTypes\n  ? CodecTypes[CodecId] extends { readonly output: infer Output }\n    ? Output\n    : never\n  : never;\n\n/**\n * Type-level operation signature.\n * Represents an operation at the type level, similar to OperationSignature at runtime.\n */\nexport type OperationTypeSignature = {\n  readonly args: ReadonlyArray<ArgSpec>;\n  readonly returns: ReturnSpec;\n  readonly lowering: SqlLoweringSpec;\n  readonly capabilities?: ReadonlyArray<string>;\n};\n\n/**\n * Type-level operation registry.\n * Maps typeId → operations, where operations is a record of method name → operation signature.\n *\n * Example:\n * ```typescript\n * type MyOperations: OperationTypes = {\n *   'pg/vector@1': {\n *     cosineDistance: {\n *       args: [{ kind: 'typeId'; type: 'pg/vector@1' }];\n *       returns: { kind: 'builtin'; type: 'number' };\n *       lowering: { targetFamily: 'sql'; strategy: 'function'; template: '...' };\n *     };\n *   };\n * };\n * ```\n */\nexport type OperationTypes = Record<string, Record<string, OperationTypeSignature>>;\n\n/**\n * CodecTypes represents a map of typeId to codec definitions.\n * Each codec definition must have an `output` property indicating the JavaScript type.\n *\n * Example:\n * ```typescript\n * type MyCodecTypes: CodecTypes = {\n *   'pg/int4@1': { output: number };\n *   'pg/text@1': { output: string };\n * };\n * ```\n */\nexport type CodecTypes = Record<string, { readonly output: unknown }>;\n\n/**\n * Extracts operations for a given typeId from the operation registry.\n * Returns an empty record if the typeId is not found.\n *\n * @example\n * ```typescript\n * type Ops = OperationsForTypeId<'pg/vector@1', MyOperations>;\n * // Ops = { cosineDistance: { ... }, l2Distance: { ... } }\n * ```\n */\nexport type OperationsForTypeId<\n  TypeId extends string,\n  Operations extends OperationTypes,\n> = Operations extends Record<string, never>\n  ? Record<string, never>\n  : TypeId extends keyof Operations\n    ? Operations[TypeId]\n    : Record<string, never>;\n\n/**\n * Maps operation signatures to method signatures on ColumnBuilder.\n * Each operation becomes a method that returns a ColumnBuilder or BinaryBuilder\n * based on the return type.\n */\ntype OperationMethods<\n  Ops extends Record<string, OperationTypeSignature>,\n  ColumnName extends string,\n  ColumnMeta extends StorageColumn,\n  JsType,\n> = {\n  [K in keyof Ops]: Ops[K] extends OperationTypeSignature\n    ? (\n        ...args: OperationArgs<Ops[K]['args']>\n      ) => OperationReturn<Ops[K]['returns'], ColumnName, ColumnMeta, JsType>\n    : never;\n};\n\n/**\n * Maps operation argument specs to TypeScript argument types.\n * - typeId args: ColumnBuilder (accepts base columns or operation results)\n * - param args: ParamPlaceholder\n * - literal args: unknown (could be more specific in future)\n */\ntype OperationArgs<Args extends ReadonlyArray<ArgSpec>> = Args extends readonly [\n  infer First,\n  ...infer Rest,\n]\n  ? First extends ArgSpec\n    ? [ArgToType<First>, ...(Rest extends ReadonlyArray<ArgSpec> ? OperationArgs<Rest> : [])]\n    : []\n  : [];\n\ntype ArgToType<Arg extends ArgSpec> = Arg extends { kind: 'typeId' }\n  ? AnyExpressionSource\n  : Arg extends { kind: 'param' }\n    ? ParamPlaceholder\n    : Arg extends { kind: 'literal' }\n      ? unknown\n      : never;\n\n/**\n * Maps operation return spec to return type.\n * Operations return ExpressionBuilder, not ColumnBuilder, because the result\n * represents an expression (OperationExpr) rather than a column reference.\n */\ntype OperationReturn<\n  Returns extends ReturnSpec,\n  _ColumnName extends string,\n  _ColumnMeta extends StorageColumn,\n  _JsType,\n> = Returns extends { kind: 'builtin'; type: infer T }\n  ? T extends 'number'\n    ? ExpressionBuilder<number>\n    : T extends 'boolean'\n      ? ExpressionBuilder<boolean>\n      : T extends 'string'\n        ? ExpressionBuilder<string>\n        : ExpressionBuilder<unknown>\n  : Returns extends { kind: 'typeId' }\n    ? ExpressionBuilder<unknown>\n    : ExpressionBuilder<unknown>;\n\n/**\n * Computes JavaScript type for a column at column creation time.\n *\n * Type inference:\n * - Read columnMeta.codecId as typeId string literal\n * - Look up CodecTypes[typeId].output\n * - Apply nullability: nullable ? Output | null : Output\n */\ntype ColumnMetaTypeId<ColumnMeta> = ColumnMeta extends { codecId: infer CodecId extends string }\n  ? CodecId\n  : ColumnMeta extends { type: infer TypeId extends string }\n    ? TypeId\n    : never;\n\nexport type ComputeColumnJsType<\n  _Contract extends SqlContract<SqlStorage>,\n  _TableName extends string,\n  _ColumnName extends string,\n  ColumnMeta extends StorageColumn,\n  CodecTypes extends Record<string, { readonly output: unknown }>,\n> = ColumnMeta extends { nullable: infer Nullable }\n  ? ColumnMetaTypeId<ColumnMeta> extends infer TypeId\n    ? TypeId extends string\n      ? ExtractCodecOutputType<TypeId, CodecTypes> extends infer CodecOutput\n        ? [CodecOutput] extends [never]\n          ? unknown // Codec not found in CodecTypes\n          : Nullable extends true\n            ? CodecOutput | null\n            : CodecOutput\n        : unknown\n      : unknown\n    : unknown\n  : unknown;\n\n/**\n * Infers Row type from a projection object.\n * Maps Record<string, ColumnBuilder> to Record<string, JSType>\n *\n * Extracts the pre-computed JsType from each ColumnBuilder in the projection.\n */\n/**\n * Extracts the inferred JsType carried by a ColumnBuilder.\n */\ntype ExtractJsTypeFromColumnBuilder<CB extends AnyColumnBuilder> =\n  CB extends ColumnBuilder<\n    infer _ColumnName extends string,\n    infer _ColumnMeta extends StorageColumn,\n    infer JsType,\n    infer _Ops\n  >\n    ? JsType\n    : never;\n\nexport type InferProjectionRow<P extends Record<string, AnyColumnBuilder>> = {\n  [K in keyof P]: ExtractJsTypeFromColumnBuilder<P[K]>;\n};\n\n/**\n * Nested projection type - allows recursive nesting of ColumnBuilder, ExpressionBuilder, or nested objects.\n */\nexport type NestedProjection = Record<\n  string,\n  | AnyExpressionSource\n  | Record<\n      string,\n      | AnyExpressionSource\n      | Record<\n          string,\n          | AnyExpressionSource\n          | Record<string, AnyExpressionSource | Record<string, AnyExpressionSource>>\n        >\n    >\n>;\n\n/**\n * Helper type to extract include type from Includes map.\n * Returns the value type if K is a key of Includes, otherwise returns unknown.\n */\ntype ExtractIncludeType<\n  K extends string,\n  Includes extends Record<string, unknown>,\n> = K extends keyof Includes ? Includes[K] : unknown;\n\n/**\n * Infers Row type from a nested projection object.\n * Recursively maps Record<string, ColumnBuilder | boolean | NestedProjection> to nested object types.\n *\n * Extracts the pre-computed JsType from each ColumnBuilder at leaves.\n * When a value is `true`, it represents an include reference and infers `Array<ChildShape>`\n * by looking up the include alias in the Includes type map.\n */\nexport type InferNestedProjectionRow<\n  P extends Record<string, AnyExpressionSource | boolean | NestedProjection>,\n  CodecTypes extends Record<string, { readonly output: unknown }> = Record<string, never>,\n  Includes extends Record<string, unknown> = Record<string, never>,\n> = {\n  [K in keyof P]: P[K] extends ExpressionBuilder<infer JsType>\n    ? JsType\n    : P[K] extends AnyColumnBuilder\n      ? ExtractJsTypeFromColumnBuilder<P[K]>\n      : P[K] extends true\n        ? Array<ExtractIncludeType<K & string, Includes>> // Include reference - infers Array<ChildShape> from Includes map\n        : P[K] extends NestedProjection\n          ? InferNestedProjectionRow<P[K], CodecTypes, Includes>\n          : never;\n};\n\n/**\n * Infers Row type from a tuple of ColumnBuilders used in returning() clause.\n * Extracts column name and JsType from each ColumnBuilder and creates a Record.\n */\nexport type InferReturningRow<Columns extends readonly AnyColumnBuilder[]> =\n  Columns extends readonly [infer First, ...infer Rest]\n    ? First extends ColumnBuilder<\n        infer Name,\n        infer _Meta,\n        infer JsType,\n        infer _Ops extends OperationTypes\n      >\n      ? Name extends string\n        ? Rest extends readonly AnyColumnBuilder[]\n          ? { [K in Name]: JsType } & InferReturningRow<Rest>\n          : { [K in Name]: JsType }\n        : never\n      : never\n    : Record<string, never>;\n\n/**\n * Utility type to check if a contract has the required capabilities for includeMany.\n * Requires both `lateral` and `jsonAgg` to be `true` in the contract's capabilities for the target.\n * Capabilities are nested by target: `{ [target]: { lateral: true, jsonAgg: true } }`\n */\nexport type HasIncludeManyCapabilities<TContract extends SqlContract<SqlStorage>> =\n  TContract extends { capabilities: infer C; target: infer T }\n    ? T extends string\n      ? C extends Record<string, Record<string, boolean>>\n        ? C extends { [K in T]: infer TargetCaps }\n          ? TargetCaps extends { lateral: true; jsonAgg: true }\n            ? true\n            : false\n          : false\n        : false\n      : false\n    : false;\n\n/**\n * SQL-specific Plan type that refines the ast field to use QueryAst.\n * This is the type used by SQL query builders.\n */\nexport type SqlPlan<Row = unknown> = ExecutionPlan<Row, QueryAst>;\n\n/**\n * Helper types for extracting contract structure.\n */\nexport type TablesOf<TContract> = TContract extends {\n  storage: { tables: infer U };\n}\n  ? U\n  : never;\n\nexport type TableKey<TContract> = Extract<keyof TablesOf<TContract>, string>;\n\n// Common types for contract.d.ts generation (SQL-specific)\n// These types are used by emitted contract.d.ts files to provide type-safe DSL/ORM types\n\n/**\n * Unique symbol for metadata property to avoid collisions with user-defined properties\n */\nexport declare const META: unique symbol;\n\n/**\n * Extracts metadata from a type that has a META property\n */\nexport type Meta<T extends { [META]: unknown }> = T[typeof META];\n\n/**\n * Metadata interface for table definitions\n */\nexport interface TableMetadata<Name extends string> {\n  name: Name;\n}\n\n/**\n * Metadata interface for model definitions\n */\nexport interface ModelMetadata<Name extends string> {\n  name: Name;\n}\n\n/**\n * Base interface for table definitions with metadata\n * Used in contract.d.ts to define storage-level table types\n */\nexport interface TableDef<Name extends string> {\n  readonly [META]: TableMetadata<Name>;\n}\n\n/**\n * Base interface for model definitions with metadata\n * Used in contract.d.ts to define application-level model types\n */\nexport interface ModelDef<Name extends string> {\n  readonly [META]: ModelMetadata<Name>;\n}\n\nexport type ColumnsOf<\n  TContract,\n  K extends TableKey<TContract>,\n> = K extends keyof TablesOf<TContract>\n  ? TablesOf<TContract>[K] extends { columns: infer C }\n    ? C\n    : never\n  : never;\n\nexport interface RawTemplateOptions {\n  readonly refs?: PlanRefs;\n  readonly annotations?: Record<string, unknown>;\n  readonly projection?: ReadonlyArray<string>;\n}\n\nexport interface RawFunctionOptions extends RawTemplateOptions {\n  readonly params: ReadonlyArray<unknown>;\n}\n\nexport type RawTemplateFactory = (\n  strings: TemplateStringsArray,\n  ...values: readonly unknown[]\n) => ExecutionPlan;\n\nexport interface RawFactory extends RawTemplateFactory {\n  (text: string, options: RawFunctionOptions): ExecutionPlan;\n  with(options: RawTemplateOptions): RawTemplateFactory;\n}\n\nexport type { RuntimeError } from '@prisma-next/plan';\n\nexport interface BuildParamsMap {\n  readonly [name: string]: unknown;\n}\n\nexport interface BuildOptions {\n  readonly params?: BuildParamsMap;\n}\n\nexport interface SqlBuilderOptions<\n  TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>,\n> {\n  readonly context: QueryLaneContext<TContract>;\n}\n\n/**\n * SQL-specific ResultType that works with both Plan and SqlQueryPlan.\n * This extends the core ResultType to also handle SqlQueryPlan.\n * Example: `type Row = ResultType<typeof plan>`\n */\nexport type ResultType<P> = P extends SqlQueryPlan<infer R> ? R : CoreResultType<P>;\n"],"mappings":";;;;AA+CA,SAAgB,mBACd,MACA,KACiB;AACjB,QAAO;EAAE,MAAM;EAAS;EAAM;EAAK;;AAmIrC,SAAgB,gBAAgB,OAA2C;AACzE,QACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA4B,SAAS"}

package/package.json

@@ -1,25 +1,25 @@
 {
   "name": "@prisma-next/sql-relational-core",
-  "version": "0.3.0-pr.94.3",
+  "version": "0.3.0-pr.94.4",
   "type": "module",
   "sideEffects": false,
   "description": "Schema and column builders, operation attachment, and AST types for Prisma Next",
   "dependencies": {
     "ts-toolbelt": "^9.6.0",
-    "@prisma-next/contract": "0.3.0-pr.94.3",
-    "@prisma-next/operations": "0.3.0-pr.94.3",
-    "@prisma-next/plan": "0.3.0-pr.94.3",
-    "@prisma-next/sql-contract": "0.3.0-pr.94.3",
-    "@prisma-next/sql-operations": "0.3.0-pr.94.3"
+    "@prisma-next/contract": "0.3.0-pr.94.4",
+    "@prisma-next/operations": "0.3.0-pr.94.4",
+    "@prisma-next/plan": "0.3.0-pr.94.4",
+    "@prisma-next/sql-contract": "0.3.0-pr.94.4",
+    "@prisma-next/sql-operations": "0.3.0-pr.94.4"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.16",
-    "@prisma-next/sql-contract-ts": "0.3.0-pr.94.3",
-    "@prisma-next/test-utils": "0.0.1",
+    "@prisma-next/sql-contract-ts": "0.3.0-pr.94.4",
     "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/tsdown": "0.0.0"
+    "@prisma-next/tsdown": "0.0.0",
+    "@prisma-next/test-utils": "0.0.1"
   },
   "files": [
     "dist",

package/src/ast/adapter-types.ts

@@ -1,4 +1,4 @@
-import type { CodecRegistry } from './codec-types';
+import type { CodecRegistry } from './codec-types.ts';
 
 export type AdapterTarget = string;
 

package/src/ast/common.ts

@@ -1,5 +1,5 @@
-import type { ColumnRef, LiteralExpr, OperationExpr, ParamRef, TableRef } from './types';
-import { compact } from './util';
+import type { ColumnRef, LiteralExpr, OperationExpr, ParamRef, TableRef } from './types.ts';
+import { compact } from './util.ts';
 
 export function createTableRef(name: string): TableRef {
   return {

package/src/ast/delete.ts

@@ -1,5 +1,5 @@
-import type { BinaryExpr, ColumnRef, DeleteAst, TableRef } from './types';
-import { compact } from './util';
+import type { BinaryExpr, ColumnRef, DeleteAst, TableRef } from './types.ts';
+import { compact } from './util.ts';
 
 export interface CreateDeleteAstOptions {
   readonly table: TableRef;

package/src/ast/insert.ts

@@ -1,5 +1,5 @@
-import type { ColumnRef, InsertAst, ParamRef, TableRef } from './types';
-import { compact } from './util';
+import type { ColumnRef, InsertAst, ParamRef, TableRef } from './types.ts';
+import { compact } from './util.ts';
 
 export interface CreateInsertAstOptions {
   readonly table: TableRef;

package/src/ast/join.ts

@@ -1,7 +1,7 @@
 import { planInvalid } from '@prisma-next/plan';
-import type { AnyColumnBuilder, JoinOnBuilder, JoinOnPredicate } from '../types';
-import { isColumnBuilder } from '../types';
-import type { ColumnRef, JoinAst, JoinOnExpr, TableRef } from './types';
+import type { AnyColumnBuilder, JoinOnBuilder, JoinOnPredicate } from '../types.ts';
+import { isColumnBuilder } from '../types.ts';
+import type { ColumnRef, JoinAst, JoinOnExpr, TableRef } from './types.ts';
 
 export function createJoin(
   joinType: 'inner' | 'left' | 'right' | 'full',

package/src/ast/order.ts

@@ -1,4 +1,4 @@
-import type { ColumnRef, Direction, OperationExpr } from './types';
+import type { ColumnRef, Direction, OperationExpr } from './types.ts';
 
 export function createOrderByItem(
   expr: ColumnRef | OperationExpr,

package/src/ast/predicate.ts

@@ -1,4 +1,4 @@
-import type { BinaryExpr, BinaryOp, ExistsExpr, Expression, ParamRef, SelectAst } from './types';
+import type { BinaryExpr, BinaryOp, ExistsExpr, Expression, ParamRef, SelectAst } from './types.ts';
 
 export function createBinaryExpr(
   op: BinaryOp,

package/src/ast/select.ts

@@ -9,8 +9,8 @@ import type {
   OperationExpr,
   SelectAst,
   TableRef,
-} from './types';
-import { compact } from './util';
+} from './types.ts';
+import { compact } from './util.ts';
 
 export interface CreateSelectAstOptions {
   readonly from: TableRef;

package/src/ast/update.ts

@@ -1,5 +1,5 @@
-import type { BinaryExpr, ColumnRef, ParamRef, TableRef, UpdateAst } from './types';
-import { compact } from './util';
+import type { BinaryExpr, ColumnRef, ParamRef, TableRef, UpdateAst } from './types.ts';
+import { compact } from './util.ts';
 
 export interface CreateUpdateAstOptions {
   readonly table: TableRef;

package/src/exports/ast.ts

@@ -1,13 +1,13 @@
-export * from '../ast/adapter-types';
-export * from '../ast/codec-types';
-export * from '../ast/common';
-export * from '../ast/delete';
-export * from '../ast/driver-types';
-export * from '../ast/insert';
-export * from '../ast/join';
-export * from '../ast/order';
-export * from '../ast/predicate';
-export * from '../ast/select';
-export * from '../ast/types';
-export * from '../ast/update';
-export * from '../ast/util';
+export * from '../ast/adapter-types.ts';
+export * from '../ast/codec-types.ts';
+export * from '../ast/common.ts';
+export * from '../ast/delete.ts';
+export * from '../ast/driver-types.ts';
+export * from '../ast/insert.ts';
+export * from '../ast/join.ts';
+export * from '../ast/order.ts';
+export * from '../ast/predicate.ts';
+export * from '../ast/select.ts';
+export * from '../ast/types.ts';
+export * from '../ast/update.ts';
+export * from '../ast/util.ts';

package/src/exports/errors.ts

@@ -1 +1 @@
-export { planInvalid, planUnsupported } from '../errors';
+export { planInvalid, planUnsupported } from '../errors.ts';

package/src/exports/guards.ts

@@ -12,4 +12,4 @@ export {
   isParamPlaceholder,
   isValueSource,
   toExpression,
-} from '../utils/guards';
+} from '../utils/guards.ts';

package/src/exports/operations-registry.ts

@@ -1 +1 @@
-export { attachOperationsToColumnBuilder } from '../operations-registry';
+export { attachOperationsToColumnBuilder } from '../operations-registry.ts';

package/src/exports/param.ts

@@ -1,2 +1,2 @@
-export type { Parameter } from '../param';
-export { param } from '../param';
+export type { Parameter } from '../param.ts';
+export { param } from '../param.ts';

package/src/exports/plan.ts

@@ -1 +1 @@
-export * from '../plan';
+export * from '../plan.ts';

package/src/exports/query-lane-context.ts

@@ -1 +1 @@
-export * from '../query-lane-context';
+export * from '../query-lane-context.ts';

package/src/exports/schema.ts

@@ -2,5 +2,5 @@ export type {
   ColumnBuilderImpl as Column,
   SchemaHandle,
   TableBuilderImpl as Table,
-} from '../schema';
-export { ColumnBuilderImpl, schema, TableBuilderImpl } from '../schema';
+} from '../schema.ts';
+export { ColumnBuilderImpl, schema, TableBuilderImpl } from '../schema.ts';

package/src/exports/types.ts

@@ -1 +1 @@
-export * from '../types';
+export * from '../types.ts';

package/src/index.ts

@@ -1,8 +1,8 @@
-export * from './exports/ast';
-export * from './exports/errors';
-export * from './exports/operations-registry';
-export * from './exports/param';
-export * from './exports/plan';
-export * from './exports/query-lane-context';
-export * from './exports/schema';
-export * from './exports/types';
+export * from './exports/ast.ts';
+export * from './exports/errors.ts';
+export * from './exports/operations-registry.ts';
+export * from './exports/param.ts';
+export * from './exports/plan.ts';
+export * from './exports/query-lane-context.ts';
+export * from './exports/schema.ts';
+export * from './exports/types.ts';

package/src/operations-registry.ts

@@ -10,7 +10,7 @@ import type {
   LiteralExpr,
   OperationExpr,
   ParamRef,
-} from './ast/types';
+} from './ast/types.ts';
 import type {
   AnyBinaryBuilder,
   AnyOrderBuilder,
@@ -18,8 +18,8 @@ import type {
   ExpressionBuilder,
   OperationTypes,
   ParamPlaceholder,
-} from './types';
-import { isParamPlaceholder } from './utils/guards';
+} from './types.ts';
+import { isParamPlaceholder } from './utils/guards.ts';
 
 /**
  * Type guard to check if a value is an ExpressionSource (has toExpr method).

package/src/param.ts

@@ -1,5 +1,5 @@
 import { planInvalid } from '@prisma-next/plan';
-import type { ParamPlaceholder } from './types';
+import type { ParamPlaceholder } from './types.ts';
 
 export type Parameter = ParamPlaceholder;
 

package/src/plan.ts

@@ -1,6 +1,6 @@
 import type { ExecutionPlan, ParamDescriptor } from '@prisma-next/contract/types';
 import type { StorageColumn } from '@prisma-next/sql-contract/types';
-import type { QueryAst } from './ast/types';
+import type { QueryAst } from './ast/types.ts';
 
 /**
  * SQL query plan produced by lanes before lowering.

package/src/query-lane-context.ts

@@ -1,6 +1,6 @@
 import type { OperationRegistry } from '@prisma-next/operations';
 import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
-import type { CodecRegistry } from './ast/codec-types';
+import type { CodecRegistry } from './ast/codec-types.ts';
 
 /**
  * Minimal context interface for SQL query lanes.

package/src/schema.ts

@@ -7,9 +7,9 @@ import type {
   SqlStorage,
   StorageColumn,
 } from '@prisma-next/sql-contract/types';
-import type { BinaryOp, ColumnRef, ExpressionSource, TableRef } from './ast/types';
-import { attachOperationsToColumnBuilder } from './operations-registry';
-import type { QueryLaneContext } from './query-lane-context';
+import type { BinaryOp, ColumnRef, ExpressionSource, TableRef } from './ast/types.ts';
+import { attachOperationsToColumnBuilder } from './operations-registry.ts';
+import type { QueryLaneContext } from './query-lane-context.ts';
 import type {
   BinaryBuilder,
   CodecTypes as CodecTypesType,
@@ -19,7 +19,7 @@ import type {
   OperationTypes,
   OrderBuilder,
   ParamPlaceholder,
-} from './types';
+} from './types.ts';
 
 type TableColumns<Table extends { columns: Record<string, StorageColumn> }> = Table['columns'];
 

package/src/types.ts

@@ -15,9 +15,9 @@ import type {
   OperationExpr,
   ParamRef,
   QueryAst,
-} from './ast/types';
-import type { SqlQueryPlan } from './plan';
-import type { QueryLaneContext } from './query-lane-context';
+} from './ast/types.ts';
+import type { SqlQueryPlan } from './plan.ts';
+import type { QueryLaneContext } from './query-lane-context.ts';
 
 export interface ParamPlaceholder {
   readonly kind: 'param-placeholder';

package/src/utils/guards.ts

@@ -6,14 +6,14 @@ import type {
   LiteralExpr,
   OperationExpr,
   ParamRef,
-} from '../ast/types';
+} from '../ast/types.ts';
 import type {
   AnyColumnBuilder,
   AnyExpressionSource,
   ExpressionBuilder,
   ParamPlaceholder,
   ValueSource,
-} from '../types';
+} from '../types.ts';
 
 /**
  * Helper to extract columnMeta from a ColumnBuilder or ExpressionBuilder.