@prisma-next/sql-relational-core 0.3.0-dev.4 → 0.3.0-dev.5

package/dist/exports/guards.d.ts

@@ -1,63 +1,2 @@
-import { StorageColumn } from '@prisma-next/sql-contract/types';
-import { C as ColumnRef, P as ParamRef, L as LiteralExpr, O as OperationExpr } from '../plan-D0OG5qzy.js';
-import { AnyColumnBuilder, ParamPlaceholder } from './types.js';
-import '@prisma-next/contract/types';
-import '@prisma-next/operations';
-import '@prisma-next/sql-operations';
-import '../query-lane-context-BhOMmb_K.js';
-import 'ts-toolbelt';
-import '@prisma-next/plan';
-
-/**
- * Helper to extract columnMeta from a ColumnBuilder.
- * Returns StorageColumn if present, undefined otherwise.
- * AnyColumnBuilder is a union that includes types with columnMeta property,
- * so we can safely access it after checking for existence.
- */
-declare function getColumnMeta(expr: AnyColumnBuilder): StorageColumn | undefined;
-/**
- * Type predicate to check if a value is a ParamPlaceholder.
- */
-declare function isParamPlaceholder(value: unknown): value is ParamPlaceholder;
-/**
- * Recursively extracts the base ColumnRef from an OperationExpr.
- * If the expression is already a ColumnRef, it is returned directly.
- */
-declare function extractBaseColumnRef(expr: ColumnRef | OperationExpr): ColumnRef;
-/**
- * Recursively collects all ColumnRef nodes from an expression tree.
- * Handles nested OperationExpr structures by traversing both self and args.
- */
-declare function collectColumnRefs(expr: ColumnRef | ParamRef | LiteralExpr | OperationExpr): ColumnRef[];
-/**
- * Type predicate to check if an expression is an OperationExpr.
- */
-declare function isOperationExpr(expr: AnyColumnBuilder | OperationExpr): expr is OperationExpr;
-/**
- * Helper to extract table and column from a ColumnBuilder or OperationExpr.
- * For OperationExpr, recursively unwraps to find the base ColumnRef.
- */
-declare function getColumnInfo(expr: AnyColumnBuilder | OperationExpr): {
-    table: string;
-    column: string;
-};
-/**
- * Type predicate to check if a value is a ColumnBuilder.
- */
-declare function isColumnBuilder(value: unknown): value is AnyColumnBuilder;
-/**
- * Extracts and returns an OperationExpr from a builder.
- * Returns the OperationExpr if the builder is an OperationExpr or has an _operationExpr property,
- * otherwise returns undefined.
- *
- * @design-note: This function accesses the hidden `_operationExpr` property, which is a code smell.
- * The issue is that `executeOperation()` in relational-core returns a ColumnBuilder-shaped object
- * with a hidden `_operationExpr` property, creating coupling between lanes and relational-core
- * implementation details. A cleaner design would be to have operation results be a separate
- * type (e.g., `OperationResultBuilder`) that properly represents expression nodes rather than
- * pretending to be a ColumnBuilder. This would require refactoring the operation execution
- * system in relational-core to return proper expression types.
- */
-declare function getOperationExpr(builder: AnyColumnBuilder | OperationExpr): OperationExpr | undefined;
-
-export { collectColumnRefs, extractBaseColumnRef, getColumnInfo, getColumnMeta, getOperationExpr, isColumnBuilder, isOperationExpr, isParamPlaceholder };
+export { collectColumnRefs, extractBaseColumnRef, getColumnInfo, getColumnMeta, getOperationExpr, isColumnBuilder, isOperationExpr, isParamPlaceholder, } from '../utils/guards';
+//# sourceMappingURL=guards.d.ts.map

package/dist/exports/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/exports/guards.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,kBAAkB,GACnB,MAAM,iBAAiB,CAAC"}

package/dist/exports/operations-registry.d.ts

@@ -1,13 +1,2 @@
-import { OperationRegistry } from '@prisma-next/operations';
-import { StorageColumn } from '@prisma-next/sql-contract/types';
-import { OperationTypes, ColumnBuilder } from './types.js';
-import '@prisma-next/contract/types';
-import '@prisma-next/sql-operations';
-import '../plan-D0OG5qzy.js';
-import '../query-lane-context-BhOMmb_K.js';
-import 'ts-toolbelt';
-import '@prisma-next/plan';
-
-declare function attachOperationsToColumnBuilder<ColumnName extends string, ColumnMeta extends StorageColumn, JsType = unknown, Operations extends OperationTypes = Record<string, never>>(columnBuilder: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>, columnMeta: ColumnMeta, registry: OperationRegistry | undefined, contractCapabilities?: Record<string, Record<string, boolean>>): ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;
-
-export { attachOperationsToColumnBuilder };
+export { attachOperationsToColumnBuilder } from '../operations-registry';
+//# sourceMappingURL=operations-registry.d.ts.map

package/dist/exports/operations-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations-registry.d.ts","sourceRoot":"","sources":["../../src/exports/operations-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/exports/param.d.ts

@@ -1,14 +1,3 @@
-import { ParamPlaceholder } from './types.js';
-import '@prisma-next/contract/types';
-import '@prisma-next/operations';
-import '@prisma-next/sql-contract/types';
-import '@prisma-next/sql-operations';
-import '../plan-D0OG5qzy.js';
-import '../query-lane-context-BhOMmb_K.js';
-import 'ts-toolbelt';
-import '@prisma-next/plan';
-
-type Parameter = ParamPlaceholder;
-declare function param(name: string): Parameter;
-
-export { type Parameter, param };
+export type { Parameter } from '../param';
+export { param } from '../param';
+//# sourceMappingURL=param.d.ts.map

package/dist/exports/param.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"param.d.ts","sourceRoot":"","sources":["../../src/exports/param.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC"}

package/dist/exports/plan.d.ts

@@ -1,5 +1,2 @@
-export { g as SqlQueryPlan, h as augmentDescriptorWithColumnMeta } from '../plan-D0OG5qzy.js';
-import '@prisma-next/contract/types';
-import '@prisma-next/sql-contract/types';
-import '@prisma-next/operations';
-import '@prisma-next/sql-operations';
+export * from '../plan';
+//# sourceMappingURL=plan.d.ts.map

package/dist/exports/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../src/exports/plan.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

package/dist/exports/query-lane-context.d.ts

@@ -1,4 +1,2 @@
-export { Q as QueryLaneContext } from '../query-lane-context-BhOMmb_K.js';
-import '@prisma-next/operations';
-import '@prisma-next/sql-contract/types';
-import 'ts-toolbelt';
+export * from '../query-lane-context';
+//# sourceMappingURL=query-lane-context.d.ts.map

package/dist/exports/query-lane-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-lane-context.d.ts","sourceRoot":"","sources":["../../src/exports/query-lane-context.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/exports/schema.d.ts

@@ -1,69 +1,3 @@
-import { StorageColumn, SqlContract, SqlStorage, ExtractCodecTypes, ExtractOperationTypes } from '@prisma-next/sql-contract/types';
-import { T as TableRef } from '../plan-D0OG5qzy.js';
-import { Q as QueryLaneContext } from '../query-lane-context-BhOMmb_K.js';
-import { ParamPlaceholder, AnyColumnBuilderBase, BinaryBuilder, OrderBuilder, CodecTypes, OperationTypes, ColumnBuilder, ComputeColumnJsType, OperationTypeSignature } from './types.js';
-import '@prisma-next/contract/types';
-import '@prisma-next/operations';
-import '@prisma-next/sql-operations';
-import 'ts-toolbelt';
-import '@prisma-next/plan';
-
-type TableColumns<Table extends {
-    columns: Record<string, StorageColumn>;
-}> = Table['columns'];
-type ColumnBuilders<Contract extends SqlContract<SqlStorage>, TableName extends string, Columns extends Record<string, StorageColumn>, CodecTypes extends CodecTypes, Operations extends OperationTypes> = {
-    readonly [K in keyof Columns]: ColumnBuilder<K & string, Columns[K], ComputeColumnJsType<Contract, TableName, K & string, Columns[K], CodecTypes>, Operations>;
-};
-declare class ColumnBuilderImpl<ColumnName extends string, ColumnMeta extends StorageColumn, JsType = unknown> {
-    readonly table: string;
-    readonly column: ColumnName;
-    private readonly storageColumn;
-    readonly kind: "column";
-    constructor(table: string, column: ColumnName, storageColumn: ColumnMeta);
-    get columnMeta(): ColumnMeta;
-    get __jsType(): JsType;
-    private createBinaryBuilder;
-    eq(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-    neq(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-    gt(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-    lt(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-    gte(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-    lte(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-    asc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;
-    desc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;
-}
-declare class TableBuilderImpl<Contract extends SqlContract<SqlStorage>, TableName extends string, Columns extends Record<string, StorageColumn>, CodecTypes extends CodecTypes, Operations extends OperationTypes> implements TableRef {
-    readonly kind: "table";
-    readonly columns: ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>;
-    private readonly _name;
-    constructor(name: TableName, columns: ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>);
-    get name(): string;
-}
-type ExtractSchemaTables<Contract extends SqlContract<SqlStorage>, CodecTypes extends CodecTypes, Operations extends OperationTypes> = {
-    readonly [TableName in keyof Contract['storage']['tables']]: TableBuilderImpl<Contract, TableName & string, TableColumns<Contract['storage']['tables'][TableName]>, CodecTypes, Operations> & TableRef;
-};
-type SchemaHandle<Contract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>, CodecTypes extends CodecTypes = CodecTypes, Operations extends OperationTypes = Record<string, never>> = {
-    readonly tables: ExtractSchemaTables<Contract, CodecTypes, Operations>;
-};
-type SchemaReturnType<Contract extends SqlContract<SqlStorage>> = SchemaHandle<Contract, ExtractCodecTypes<Contract>, ToOperationTypes<ExtractOperationTypes<Contract>>>;
-type NormalizeOperationTypes<T> = {
-    [TypeId in keyof T]: {
-        [Method in keyof T[TypeId]]: T[TypeId][Method] extends OperationTypeSignature ? T[TypeId][Method] : OperationTypeSignature;
-    };
-};
-type ToOperationTypes<T> = T extends OperationTypes ? T : NormalizeOperationTypes<T>;
-/**
- * Creates a schema handle for building SQL queries.
- *
- * @param context - Query lane context containing contract, codec and operation registries
- * @returns A schema handle with typed table builders
- *
- * @example
- * ```typescript
- * const schemaHandle = schema<Contract>(context);
- * const userTable = schemaHandle.tables.user;
- * ```
- */
-declare function schema<Contract extends SqlContract<SqlStorage>>(context: QueryLaneContext<Contract>): SchemaReturnType<Contract>;
-
-export { ColumnBuilderImpl as Column, ColumnBuilderImpl, type SchemaHandle, TableBuilderImpl as Table, TableBuilderImpl, schema };
+export type { ColumnBuilderImpl as Column, SchemaHandle, TableBuilderImpl as Table, } from '../schema';
+export { ColumnBuilderImpl, schema, TableBuilderImpl } from '../schema';
+//# sourceMappingURL=schema.d.ts.map

package/dist/exports/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/exports/schema.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,iBAAiB,IAAI,MAAM,EAC3B,YAAY,EACZ,gBAAgB,IAAI,KAAK,GAC1B,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC"}

package/dist/exports/types.d.ts

@@ -1,335 +1,2 @@
-import { ExecutionPlan, PlanRefs, ResultType as ResultType$1 } from '@prisma-next/contract/types';
-import { ArgSpec, ReturnSpec } from '@prisma-next/operations';
-import { StorageColumn, SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
-import { SqlLoweringSpec } from '@prisma-next/sql-operations';
-import { B as BinaryOp, O as OperationExpr, D as Direction, C as ColumnRef, P as ParamRef, Q as QueryAst, g as SqlQueryPlan } from '../plan-D0OG5qzy.js';
-import { Q as QueryLaneContext } from '../query-lane-context-BhOMmb_K.js';
-export { RuntimeError } from '@prisma-next/plan';
-import 'ts-toolbelt';
-
-interface ParamPlaceholder {
-    readonly kind: 'param-placeholder';
-    readonly name: string;
-}
-interface OrderBuilder<ColumnName extends string = string, ColumnMeta extends StorageColumn = StorageColumn, JsType = unknown> {
-    readonly kind: 'order';
-    readonly expr: ColumnBuilder<ColumnName, ColumnMeta, JsType> | OperationExpr;
-    readonly dir: Direction;
-}
-/**
- * Creates an OrderBuilder for use in orderBy clauses.
- */
-declare function createOrderBuilder(expr: AnyColumnBuilder | OperationExpr, dir: Direction): AnyOrderBuilder;
-/**
- * ColumnBuilder with optional operation methods based on the column's typeId.
- * When Operations is provided and the column's typeId matches, operation methods are included.
- */
-type ColumnBuilder<ColumnName extends string = string, ColumnMeta extends StorageColumn = StorageColumn, JsType = unknown, Operations extends OperationTypes = Record<string, never>> = {
-    readonly kind: 'column';
-    readonly table: string;
-    readonly column: ColumnName;
-    readonly columnMeta: ColumnMeta;
-    eq(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-    neq(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-    gt(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-    lt(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-    gte(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-    lte(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-    asc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;
-    desc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;
-    readonly __jsType: JsType;
-} & (ColumnMeta['codecId'] extends string ? ColumnMeta['codecId'] extends keyof Operations ? OperationMethods<OperationsForTypeId<ColumnMeta['codecId'] & string, Operations>, ColumnName, StorageColumn, JsType> : Record<string, never> : Record<string, never>);
-interface BinaryBuilder<ColumnName extends string = string, ColumnMeta extends StorageColumn = StorageColumn, JsType = unknown> {
-    readonly kind: 'binary';
-    readonly op: BinaryOp;
-    readonly left: ColumnBuilder<ColumnName, ColumnMeta, JsType> | OperationExpr;
-    readonly right: ParamPlaceholder | AnyColumnBuilderBase;
-}
-type AnyColumnBuilderBase = {
-    readonly kind: 'column';
-    readonly table: string;
-    readonly column: string;
-    readonly columnMeta: StorageColumn;
-    eq(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
-    neq(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
-    gt(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
-    lt(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
-    gte(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
-    lte(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
-    asc(): AnyOrderBuilder;
-    desc(): AnyOrderBuilder;
-    readonly __jsType: unknown;
-    readonly [key: string]: unknown;
-};
-type AnyColumnBuilder = ColumnBuilder<string, StorageColumn, unknown, any> | AnyColumnBuilderBase;
-type AnyBinaryBuilder = BinaryBuilder<string, StorageColumn, unknown>;
-type AnyOrderBuilder = OrderBuilder<string, StorageColumn, unknown>;
-declare function isColumnBuilder(value: unknown): value is AnyColumnBuilder;
-interface JoinOnBuilder {
-    eqCol(left: AnyColumnBuilder, right: AnyColumnBuilder): JoinOnPredicate;
-}
-interface JoinOnPredicate {
-    readonly kind: 'join-on';
-    readonly left: AnyColumnBuilder;
-    readonly right: AnyColumnBuilder;
-}
-type Expr = ColumnRef | ParamRef;
-/**
- * Helper type to extract codec output type from CodecTypes.
- * Returns never if the codecId is not found in CodecTypes.
- */
-type ExtractCodecOutputType<CodecId extends string, CodecTypes extends Record<string, {
-    readonly output: unknown;
-}>> = CodecId extends keyof CodecTypes ? CodecTypes[CodecId] extends {
-    readonly output: infer Output;
-} ? Output : never : never;
-/**
- * Type-level operation signature.
- * Represents an operation at the type level, similar to OperationSignature at runtime.
- */
-type OperationTypeSignature = {
-    readonly args: ReadonlyArray<ArgSpec>;
-    readonly returns: ReturnSpec;
-    readonly lowering: SqlLoweringSpec;
-    readonly capabilities?: ReadonlyArray<string>;
-};
-/**
- * Type-level operation registry.
- * Maps typeId → operations, where operations is a record of method name → operation signature.
- *
- * Example:
- * ```typescript
- * type MyOperations: OperationTypes = {
- *   'pg/vector@1': {
- *     cosineDistance: {
- *       args: [{ kind: 'typeId'; type: 'pg/vector@1' }];
- *       returns: { kind: 'builtin'; type: 'number' };
- *       lowering: { targetFamily: 'sql'; strategy: 'function'; template: '...' };
- *     };
- *   };
- * };
- * ```
- */
-type OperationTypes = Record<string, Record<string, OperationTypeSignature>>;
-/**
- * CodecTypes represents a map of typeId to codec definitions.
- * Each codec definition must have an `output` property indicating the JavaScript type.
- *
- * Example:
- * ```typescript
- * type MyCodecTypes: CodecTypes = {
- *   'pg/int4@1': { output: number };
- *   'pg/text@1': { output: string };
- * };
- * ```
- */
-type CodecTypes = Record<string, {
-    readonly output: unknown;
-}>;
-/**
- * Extracts operations for a given typeId from the operation registry.
- * Returns an empty record if the typeId is not found.
- *
- * @example
- * ```typescript
- * type Ops = OperationsForTypeId<'pg/vector@1', MyOperations>;
- * // Ops = { cosineDistance: { ... }, l2Distance: { ... } }
- * ```
- */
-type OperationsForTypeId<TypeId extends string, Operations extends OperationTypes> = Operations extends Record<string, never> ? Record<string, never> : TypeId extends keyof Operations ? Operations[TypeId] : Record<string, never>;
-/**
- * Maps operation signatures to method signatures on ColumnBuilder.
- * Each operation becomes a method that returns a ColumnBuilder or BinaryBuilder
- * based on the return type.
- */
-type OperationMethods<Ops extends Record<string, OperationTypeSignature>, ColumnName extends string, ColumnMeta extends StorageColumn, JsType> = {
-    [K in keyof Ops]: Ops[K] extends OperationTypeSignature ? (...args: OperationArgs<Ops[K]['args']>) => OperationReturn<Ops[K]['returns'], ColumnName, ColumnMeta, JsType> : never;
-};
-/**
- * Maps operation argument specs to TypeScript argument types.
- * - typeId args: ColumnBuilder (accepts base columns or operation results)
- * - param args: ParamPlaceholder
- * - literal args: unknown (could be more specific in future)
- */
-type OperationArgs<Args extends ReadonlyArray<ArgSpec>> = Args extends readonly [
-    infer First,
-    ...infer Rest
-] ? First extends ArgSpec ? [ArgToType<First>, ...(Rest extends ReadonlyArray<ArgSpec> ? OperationArgs<Rest> : [])] : [] : [];
-type ArgToType<Arg extends ArgSpec> = Arg extends {
-    kind: 'typeId';
-} ? AnyColumnBuilder : Arg extends {
-    kind: 'param';
-} ? ParamPlaceholder : Arg extends {
-    kind: 'literal';
-} ? unknown : never;
-/**
- * Maps operation return spec to return type.
- * - builtin types: ColumnBuilder with appropriate JsType (matches runtime behavior)
- * - typeId types: ColumnBuilder (for now, could be more specific in future)
- */
-type OperationReturn<Returns extends ReturnSpec, ColumnName extends string, ColumnMeta extends StorageColumn, _JsType> = Returns extends {
-    kind: 'builtin';
-    type: infer T;
-} ? T extends 'number' ? ColumnBuilder<ColumnName, ColumnMeta, number> : T extends 'boolean' ? ColumnBuilder<ColumnName, ColumnMeta, boolean> : T extends 'string' ? ColumnBuilder<ColumnName, ColumnMeta, string> : ColumnBuilder<ColumnName, ColumnMeta, unknown> : Returns extends {
-    kind: 'typeId';
-} ? AnyColumnBuilder : ColumnBuilder<ColumnName, ColumnMeta, unknown>;
-/**
- * Computes JavaScript type for a column at column creation time.
- *
- * Type inference:
- * - Read columnMeta.codecId as typeId string literal
- * - Look up CodecTypes[typeId].output
- * - Apply nullability: nullable ? Output | null : Output
- */
-type ColumnMetaTypeId<ColumnMeta> = ColumnMeta extends {
-    codecId: infer CodecId extends string;
-} ? CodecId : ColumnMeta extends {
-    type: infer TypeId extends string;
-} ? TypeId : never;
-type ComputeColumnJsType<_Contract extends SqlContract<SqlStorage>, _TableName extends string, _ColumnName extends string, ColumnMeta extends StorageColumn, CodecTypes extends Record<string, {
-    readonly output: unknown;
-}>> = ColumnMeta extends {
-    nullable: infer Nullable;
-} ? ColumnMetaTypeId<ColumnMeta> extends infer TypeId ? TypeId extends string ? ExtractCodecOutputType<TypeId, CodecTypes> extends infer CodecOutput ? [CodecOutput] extends [never] ? unknown : Nullable extends true ? CodecOutput | null : CodecOutput : unknown : unknown : unknown : unknown;
-/**
- * Infers Row type from a projection object.
- * Maps Record<string, ColumnBuilder> to Record<string, JSType>
- *
- * Extracts the pre-computed JsType from each ColumnBuilder in the projection.
- */
-/**
- * Extracts the inferred JsType carried by a ColumnBuilder.
- */
-type ExtractJsTypeFromColumnBuilder<CB extends AnyColumnBuilder> = CB extends ColumnBuilder<infer _ColumnName extends string, infer _ColumnMeta extends StorageColumn, infer JsType, infer _Ops> ? JsType : never;
-type InferProjectionRow<P extends Record<string, AnyColumnBuilder>> = {
-    [K in keyof P]: ExtractJsTypeFromColumnBuilder<P[K]>;
-};
-/**
- * Nested projection type - allows recursive nesting of ColumnBuilder or nested objects.
- */
-type NestedProjection = Record<string, AnyColumnBuilder | Record<string, AnyColumnBuilder | Record<string, AnyColumnBuilder | Record<string, AnyColumnBuilder | Record<string, AnyColumnBuilder>>>>>;
-/**
- * Helper type to extract include type from Includes map.
- * Returns the value type if K is a key of Includes, otherwise returns unknown.
- */
-type ExtractIncludeType<K extends string, Includes extends Record<string, unknown>> = K extends keyof Includes ? Includes[K] : unknown;
-/**
- * Infers Row type from a nested projection object.
- * Recursively maps Record<string, ColumnBuilder | boolean | NestedProjection> to nested object types.
- *
- * Extracts the pre-computed JsType from each ColumnBuilder at leaves.
- * When a value is `true`, it represents an include reference and infers `Array<ChildShape>`
- * by looking up the include alias in the Includes type map.
- */
-type InferNestedProjectionRow<P extends Record<string, AnyColumnBuilder | boolean | NestedProjection>, CodecTypes extends Record<string, {
-    readonly output: unknown;
-}> = Record<string, never>, Includes extends Record<string, unknown> = Record<string, never>> = {
-    [K in keyof P]: P[K] extends AnyColumnBuilder ? ExtractJsTypeFromColumnBuilder<P[K]> : P[K] extends true ? Array<ExtractIncludeType<K & string, Includes>> : P[K] extends NestedProjection ? InferNestedProjectionRow<P[K], CodecTypes, Includes> : never;
-};
-/**
- * Infers Row type from a tuple of ColumnBuilders used in returning() clause.
- * Extracts column name and JsType from each ColumnBuilder and creates a Record.
- */
-type InferReturningRow<Columns extends readonly AnyColumnBuilder[]> = Columns extends readonly [infer First, ...infer Rest] ? First extends ColumnBuilder<infer Name, infer _Meta, infer JsType, infer _Ops extends OperationTypes> ? Name extends string ? Rest extends readonly AnyColumnBuilder[] ? {
-    [K in Name]: JsType;
-} & InferReturningRow<Rest> : {
-    [K in Name]: JsType;
-} : never : never : Record<string, never>;
-/**
- * Utility type to check if a contract has the required capabilities for includeMany.
- * Requires both `lateral` and `jsonAgg` to be `true` in the contract's capabilities for the target.
- * Capabilities are nested by target: `{ [target]: { lateral: true, jsonAgg: true } }`
- */
-type HasIncludeManyCapabilities<TContract extends SqlContract<SqlStorage>> = TContract extends {
-    capabilities: infer C;
-    target: infer T;
-} ? T extends string ? C extends Record<string, Record<string, boolean>> ? C extends {
-    [K in T]: infer TargetCaps;
-} ? TargetCaps extends {
-    lateral: true;
-    jsonAgg: true;
-} ? true : false : false : false : false : false;
-/**
- * SQL-specific Plan type that refines the ast field to use QueryAst.
- * This is the type used by SQL query builders.
- */
-type SqlPlan<Row = unknown> = ExecutionPlan<Row, QueryAst>;
-/**
- * Helper types for extracting contract structure.
- */
-type TablesOf<TContract> = TContract extends {
-    storage: {
-        tables: infer U;
-    };
-} ? U : never;
-type TableKey<TContract> = Extract<keyof TablesOf<TContract>, string>;
-/**
- * Unique symbol for metadata property to avoid collisions with user-defined properties
- */
-declare const META: unique symbol;
-/**
- * Extracts metadata from a type that has a META property
- */
-type Meta<T extends {
-    [META]: unknown;
-}> = T[typeof META];
-/**
- * Metadata interface for table definitions
- */
-interface TableMetadata<Name extends string> {
-    name: Name;
-}
-/**
- * Metadata interface for model definitions
- */
-interface ModelMetadata<Name extends string> {
-    name: Name;
-}
-/**
- * Base interface for table definitions with metadata
- * Used in contract.d.ts to define storage-level table types
- */
-interface TableDef<Name extends string> {
-    readonly [META]: TableMetadata<Name>;
-}
-/**
- * Base interface for model definitions with metadata
- * Used in contract.d.ts to define application-level model types
- */
-interface ModelDef<Name extends string> {
-    readonly [META]: ModelMetadata<Name>;
-}
-type ColumnsOf<TContract, K extends TableKey<TContract>> = K extends keyof TablesOf<TContract> ? TablesOf<TContract>[K] extends {
-    columns: infer C;
-} ? C : never : never;
-interface RawTemplateOptions {
-    readonly refs?: PlanRefs;
-    readonly annotations?: Record<string, unknown>;
-    readonly projection?: ReadonlyArray<string>;
-}
-interface RawFunctionOptions extends RawTemplateOptions {
-    readonly params: ReadonlyArray<unknown>;
-}
-type RawTemplateFactory = (strings: TemplateStringsArray, ...values: readonly unknown[]) => ExecutionPlan;
-interface RawFactory extends RawTemplateFactory {
-    (text: string, options: RawFunctionOptions): ExecutionPlan;
-    with(options: RawTemplateOptions): RawTemplateFactory;
-}
-
-interface BuildParamsMap {
-    readonly [name: string]: unknown;
-}
-interface BuildOptions {
-    readonly params?: BuildParamsMap;
-}
-interface SqlBuilderOptions<TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>> {
-    readonly context: QueryLaneContext<TContract>;
-}
-/**
- * SQL-specific ResultType that works with both Plan and SqlQueryPlan.
- * This extends the core ResultType to also handle SqlQueryPlan.
- * Example: `type Row = ResultType<typeof plan>`
- */
-type ResultType<P> = P extends SqlQueryPlan<infer R> ? R : ResultType$1<P>;
-
-export { type AnyBinaryBuilder, type AnyColumnBuilder, type AnyColumnBuilderBase, type AnyOrderBuilder, type BinaryBuilder, type BuildOptions, type BuildParamsMap, type CodecTypes, type ColumnBuilder, type ColumnsOf, type ComputeColumnJsType, type Expr, type HasIncludeManyCapabilities, type InferNestedProjectionRow, type InferProjectionRow, type InferReturningRow, type JoinOnBuilder, type JoinOnPredicate, META, type Meta, type ModelDef, type ModelMetadata, type NestedProjection, type OperationTypeSignature, type OperationTypes, type OperationsForTypeId, type OrderBuilder, type ParamPlaceholder, type RawFactory, type RawFunctionOptions, type RawTemplateFactory, type RawTemplateOptions, type ResultType, type SqlBuilderOptions, type SqlPlan, type TableDef, type TableKey, type TableMetadata, type TablesOf, createOrderBuilder, isColumnBuilder };
+export * from '../types';
+//# sourceMappingURL=types.d.ts.map

package/dist/exports/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/exports/types.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/dist/index.d.ts

@@ -1,13 +1,9 @@
-export { Adapter, AdapterProfile, AdapterTarget, CreateDeleteAstOptions, CreateInsertAstOptions, CreateSelectAstOptions, CreateUpdateAstOptions, LoweredPayload, Lowerer, LowererContext, SqlDriver, SqlExecuteRequest, SqlExplainResult, SqlQueryResult, compact, createBinaryExpr, createColumnRef, createDeleteAst, createExistsExpr, createInsertAst, createJoin, createJoinOnBuilder, createJoinOnExpr, createLiteralExpr, createOperationExpr, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst } from './exports/ast.js';
-export { a as Codec, h as CodecDefBuilder, d as CodecId, e as CodecInput, C as CodecMeta, f as CodecOutput, b as CodecRegistry, E as ExtractCodecTypes, g as ExtractDataTypes, Q as QueryLaneContext, c as codec, i as createCodecRegistry, j as defineCodecs } from './query-lane-context-BhOMmb_K.js';
-export { a as BinaryExpr, B as BinaryOp, C as ColumnRef, e as DeleteAst, D as Direction, E as ExistsExpr, c as IncludeAst, I as IncludeRef, d as InsertAst, b as JoinAst, J as JoinOnExpr, L as LiteralExpr, f as LoweredStatement, O as OperationExpr, P as ParamRef, Q as QueryAst, S as SelectAst, g as SqlQueryPlan, T as TableRef, U as UpdateAst, h as augmentDescriptorWithColumnMeta, i as isOperationExpr } from './plan-D0OG5qzy.js';
-export { RuntimeError, planInvalid, planUnsupported } from '@prisma-next/plan';
-export { attachOperationsToColumnBuilder } from './exports/operations-registry.js';
-export { Parameter, param } from './exports/param.js';
-export { Column, Column as ColumnBuilderImpl, SchemaHandle, Table, Table as TableBuilderImpl, schema } from './exports/schema.js';
-export { AnyBinaryBuilder, AnyColumnBuilder, AnyColumnBuilderBase, AnyOrderBuilder, BinaryBuilder, BuildOptions, BuildParamsMap, CodecTypes, ColumnBuilder, ColumnsOf, ComputeColumnJsType, Expr, HasIncludeManyCapabilities, InferNestedProjectionRow, InferProjectionRow, InferReturningRow, JoinOnBuilder, JoinOnPredicate, META, Meta, ModelDef, ModelMetadata, NestedProjection, OperationTypeSignature, OperationTypes, OperationsForTypeId, OrderBuilder, ParamPlaceholder, RawFactory, RawFunctionOptions, RawTemplateFactory, RawTemplateOptions, ResultType, SqlBuilderOptions, SqlPlan, TableDef, TableKey, TableMetadata, TablesOf, createOrderBuilder, isColumnBuilder } from './exports/types.js';
-import '@prisma-next/operations';
-import '@prisma-next/sql-contract/types';
-import 'ts-toolbelt';
-import '@prisma-next/contract/types';
-import '@prisma-next/sql-operations';
+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';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC"}

package/dist/operations-registry.d.ts

@@ -0,0 +1,5 @@
+import type { OperationRegistry } from '@prisma-next/operations';
+import type { StorageColumn } from '@prisma-next/sql-contract/types';
+import type { ColumnBuilder, OperationTypes } from './types';
+export declare function attachOperationsToColumnBuilder<ColumnName extends string, ColumnMeta extends StorageColumn, JsType = unknown, Operations extends OperationTypes = Record<string, never>>(columnBuilder: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>, columnMeta: ColumnMeta, registry: OperationRegistry | undefined, contractCapabilities?: Record<string, Record<string, boolean>>): ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;
+//# sourceMappingURL=operations-registry.d.ts.map

package/dist/operations-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations-registry.d.ts","sourceRoot":"","sources":["../src/operations-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAGjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAGrE,OAAO,KAAK,EAAoB,aAAa,EAAE,cAAc,EAAoB,MAAM,SAAS,CAAC;AA0KjG,wBAAgB,+BAA+B,CAC7C,UAAU,SAAS,MAAM,EACzB,UAAU,SAAS,aAAa,EAChC,MAAM,GAAG,OAAO,EAChB,UAAU,SAAS,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAEzD,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,EACnF,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,iBAAiB,GAAG,SAAS,EACvC,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC7D,aAAa,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,CAkD3D"}

package/dist/param.d.ts

@@ -0,0 +1,4 @@
+import type { ParamPlaceholder } from './types';
+export type Parameter = ParamPlaceholder;
+export declare function param(name: string): Parameter;
+//# sourceMappingURL=param.d.ts.map

package/dist/param.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"param.d.ts","sourceRoot":"","sources":["../src/param.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,MAAM,MAAM,SAAS,GAAG,gBAAgB,CAAC;AAEzC,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAS7C"}

package/dist/plan.d.ts

@@ -0,0 +1,23 @@
+import type { ExecutionPlan, ParamDescriptor } from '@prisma-next/contract/types';
+import type { StorageColumn } from '@prisma-next/sql-contract/types';
+import type { QueryAst } from './ast/types';
+/**
+ * SQL query plan produced by lanes before lowering.
+ *
+ * Lanes build ASTs and metadata but do not perform SQL lowering.
+ * The `sql` field is absent - lowering happens in the runtime executor.
+ *
+ * Structurally aligns with ExecutionPlan<Row, QueryAst> (without sql field) to maintain
+ * compatibility with ExecutionPlan/Plan-based utilities.
+ * The generic parameter `_Row` is preserved for type extraction via ResultType.
+ */
+export interface SqlQueryPlan<_Row = unknown> extends Pick<ExecutionPlan<_Row, QueryAst>, 'params' | 'meta'> {
+    readonly ast: QueryAst;
+    readonly _Row?: _Row;
+}
+/**
+ * Augments the last ParamDescriptor in the array with codecId and nativeType from columnMeta.
+ * This is used when building WHERE expressions to ensure param descriptors have type information.
+ */
+export declare function augmentDescriptorWithColumnMeta(descriptors: ParamDescriptor[], columnMeta: StorageColumn | undefined): void;
+//# sourceMappingURL=plan.d.ts.map

package/dist/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../src/plan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAClF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY,CAAC,IAAI,GAAG,OAAO,CAC1C,SAAQ,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC9D,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IAGvB,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,WAAW,EAAE,eAAe,EAAE,EAC9B,UAAU,EAAE,aAAa,GAAG,SAAS,GACpC,IAAI,CASN"}