@prisma-next/sql-relational-core 0.3.0-dev.6 → 0.3.0-dev.63

package/dist/exports/ast.mjs

@@ -0,0 +1,361 @@
+import { n as isColumnBuilder } from "../types-Cdi4Whda.mjs";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { planInvalid } from "@prisma-next/plan";
+import { type } from "arktype";
+
+//#region src/ast/codec-types.ts
+/**
+* Implementation of CodecRegistry.
+*/
+var CodecRegistryImpl = class {
+	_byId = /* @__PURE__ */ new Map();
+	_byScalar = /* @__PURE__ */ new Map();
+	/**
+	* Map-like interface for codec lookup by ID.
+	* Example: registry.get('pg/text@1')
+	*/
+	get(id) {
+		return this._byId.get(id);
+	}
+	/**
+	* Check if a codec with the given ID is registered.
+	*/
+	has(id) {
+		return this._byId.has(id);
+	}
+	/**
+	* Get all codecs that handle a given scalar type.
+	* Returns an empty frozen array if no codecs are found.
+	* Example: registry.getByScalar('text') → [codec1, codec2, ...]
+	*/
+	getByScalar(scalar) {
+		return this._byScalar.get(scalar) ?? Object.freeze([]);
+	}
+	/**
+	* Get the default codec for a scalar type (first registered codec).
+	* Returns undefined if no codec handles this scalar type.
+	*/
+	getDefaultCodec(scalar) {
+		return this._byScalar.get(scalar)?.[0];
+	}
+	/**
+	* Register a codec in the registry.
+	* Throws an error if a codec with the same ID is already registered.
+	*
+	* @param codec - The codec to register
+	* @throws Error if a codec with the same ID already exists
+	*/
+	register(codec$1) {
+		if (this._byId.has(codec$1.id)) throw new Error(`Codec with ID '${codec$1.id}' is already registered`);
+		this._byId.set(codec$1.id, codec$1);
+		for (const scalarType of codec$1.targetTypes) {
+			const existing = this._byScalar.get(scalarType);
+			if (existing) existing.push(codec$1);
+			else this._byScalar.set(scalarType, [codec$1]);
+		}
+	}
+	/**
+	* Returns an iterator over all registered codecs.
+	* Useful for iterating through codecs from another registry.
+	*/
+	*[Symbol.iterator]() {
+		for (const codec$1 of this._byId.values()) yield codec$1;
+	}
+	/**
+	* Returns an iterable of all registered codecs.
+	*/
+	values() {
+		return this._byId.values();
+	}
+};
+/**
+* Codec factory - creates a codec with typeId and encode/decode functions.
+*/
+function codec(config) {
+	return {
+		id: config.typeId,
+		targetTypes: config.targetTypes,
+		...ifDefined("meta", config.meta),
+		...ifDefined("paramsSchema", config.paramsSchema),
+		...ifDefined("init", config.init),
+		encode: config.encode,
+		decode: config.decode
+	};
+}
+/**
+* Implementation of CodecDefBuilder.
+*/
+var CodecDefBuilderImpl = class CodecDefBuilderImpl {
+	_codecs;
+	CodecTypes;
+	dataTypes;
+	constructor(codecs$1) {
+		this._codecs = codecs$1;
+		const codecTypes = {};
+		for (const [, codecImpl] of Object.entries(this._codecs)) {
+			const codecImplTyped = codecImpl;
+			codecTypes[codecImplTyped.id] = {
+				input: void 0,
+				output: void 0
+			};
+		}
+		this.CodecTypes = codecTypes;
+		const dataTypes = {};
+		for (const key in this._codecs) if (Object.hasOwn(this._codecs, key)) dataTypes[key] = this._codecs[key].id;
+		this.dataTypes = dataTypes;
+	}
+	add(scalarName, codecImpl) {
+		return new CodecDefBuilderImpl({
+			...this._codecs,
+			[scalarName]: codecImpl
+		});
+	}
+	/**
+	* Derive codecDefinitions structure.
+	*/
+	get codecDefinitions() {
+		const result = {};
+		for (const [scalarName, codecImpl] of Object.entries(this._codecs)) {
+			const codec$1 = codecImpl;
+			result[scalarName] = {
+				typeId: codec$1.id,
+				scalar: scalarName,
+				codec: codec$1,
+				input: void 0,
+				output: void 0,
+				jsType: void 0
+			};
+		}
+		return result;
+	}
+};
+/**
+* Create a new codec registry.
+*/
+function createCodecRegistry() {
+	return new CodecRegistryImpl();
+}
+/**
+* Create a new codec definition builder.
+*/
+function defineCodecs() {
+	return new CodecDefBuilderImpl({});
+}
+
+//#endregion
+//#region src/ast/util.ts
+function compact(o) {
+	const out = {};
+	for (const [k, v] of Object.entries(o)) {
+		if (v === void 0 || v === null) continue;
+		if (Array.isArray(v) && v.length === 0) continue;
+		out[k] = v;
+	}
+	return out;
+}
+
+//#endregion
+//#region src/ast/common.ts
+function createTableRef(name) {
+	return {
+		kind: "table",
+		name
+	};
+}
+function createColumnRef(table, column) {
+	return {
+		kind: "col",
+		table,
+		column
+	};
+}
+function createParamRef(index, name) {
+	return compact({
+		kind: "param",
+		index,
+		name
+	});
+}
+function createOperationExpr(operation) {
+	return operation;
+}
+function createLiteralExpr(value) {
+	return {
+		kind: "literal",
+		value
+	};
+}
+
+//#endregion
+//#region src/ast/delete.ts
+function createDeleteAst(options) {
+	return compact({
+		kind: "delete",
+		table: options.table,
+		where: options.where,
+		returning: options.returning
+	});
+}
+
+//#endregion
+//#region src/ast/insert.ts
+function createInsertAst(options) {
+	return compact({
+		kind: "insert",
+		table: options.table,
+		values: options.values,
+		returning: options.returning
+	});
+}
+
+//#endregion
+//#region src/ast/join.ts
+function createJoin(joinType, table, on) {
+	return {
+		kind: "join",
+		joinType,
+		table,
+		on
+	};
+}
+function createJoinOnExpr(left, right) {
+	return {
+		kind: "eqCol",
+		left,
+		right
+	};
+}
+var JoinOnBuilderImpl = class {
+	eqCol(left, right) {
+		if (!left || !isColumnBuilder(left)) throw planInvalid("Join ON left operand must be a column");
+		if (!right || !isColumnBuilder(right)) throw planInvalid("Join ON right operand must be a column");
+		const leftCol = left;
+		const rightCol = right;
+		if (leftCol.table === rightCol.table) throw planInvalid("Self-joins are not supported in MVP");
+		return {
+			kind: "join-on",
+			left,
+			right
+		};
+	}
+};
+function createJoinOnBuilder() {
+	return new JoinOnBuilderImpl();
+}
+
+//#endregion
+//#region src/ast/order.ts
+function createOrderByItem(expr, dir) {
+	return {
+		expr,
+		dir
+	};
+}
+
+//#endregion
+//#region src/ast/predicate.ts
+function createBinaryExpr(op, left, right) {
+	return {
+		kind: "bin",
+		op,
+		left,
+		right
+	};
+}
+function createExistsExpr(not, subquery) {
+	return {
+		kind: "exists",
+		not,
+		subquery
+	};
+}
+function createNullCheckExpr(expr, isNull) {
+	return {
+		kind: "nullCheck",
+		expr,
+		isNull
+	};
+}
+
+//#endregion
+//#region src/ast/select.ts
+function createSelectAst(options) {
+	return compact({
+		kind: "select",
+		from: options.from,
+		joins: options.joins,
+		includes: options.includes,
+		project: options.project,
+		where: options.where,
+		orderBy: options.orderBy,
+		limit: options.limit,
+		selectAllIntent: options.selectAllIntent
+	});
+}
+
+//#endregion
+//#region src/ast/sql-codecs.ts
+const SQL_CHAR_CODEC_ID = "sql/char@1";
+const SQL_VARCHAR_CODEC_ID = "sql/varchar@1";
+const SQL_INT_CODEC_ID = "sql/int@1";
+const SQL_FLOAT_CODEC_ID = "sql/float@1";
+const lengthParamsSchema = type({ length: "number.integer > 0" });
+function createLengthTypeHelper(kind) {
+	return (params) => ({
+		kind,
+		maxLength: params["length"]
+	});
+}
+const sqlCharCodec = codec({
+	typeId: SQL_CHAR_CODEC_ID,
+	targetTypes: ["char"],
+	encode: (value) => value,
+	decode: (wire) => wire.trimEnd(),
+	paramsSchema: lengthParamsSchema,
+	init: createLengthTypeHelper("fixed")
+});
+const sqlVarcharCodec = codec({
+	typeId: SQL_VARCHAR_CODEC_ID,
+	targetTypes: ["varchar"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	paramsSchema: lengthParamsSchema,
+	init: createLengthTypeHelper("variable")
+});
+const sqlIntCodec = codec({
+	typeId: SQL_INT_CODEC_ID,
+	targetTypes: ["int"],
+	encode: (value) => value,
+	decode: (wire) => wire
+});
+const sqlFloatCodec = codec({
+	typeId: SQL_FLOAT_CODEC_ID,
+	targetTypes: ["float"],
+	encode: (value) => value,
+	decode: (wire) => wire
+});
+const codecs = defineCodecs().add("char", sqlCharCodec).add("varchar", sqlVarcharCodec).add("int", sqlIntCodec).add("float", sqlFloatCodec);
+const sqlCodecDefinitions = codecs.codecDefinitions;
+const sqlDataTypes = codecs.dataTypes;
+
+//#endregion
+//#region src/ast/types.ts
+function isOperationExpr(expr) {
+	return expr.kind === "operation";
+}
+
+//#endregion
+//#region src/ast/update.ts
+function createUpdateAst(options) {
+	return compact({
+		kind: "update",
+		table: options.table,
+		set: options.set,
+		where: options.where,
+		returning: options.returning
+	});
+}
+
+//#endregion
+export { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_VARCHAR_CODEC_ID, codec, compact, createBinaryExpr, createCodecRegistry, createColumnRef, createDeleteAst, createExistsExpr, createInsertAst, createJoin, createJoinOnBuilder, createJoinOnExpr, createLiteralExpr, createNullCheckExpr, createOperationExpr, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst, defineCodecs, isOperationExpr, sqlCodecDefinitions, sqlDataTypes };
+//# sourceMappingURL=ast.mjs.map

package/dist/exports/ast.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.mjs","names":["codec","codecs","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>","arktype"],"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/sql-codecs.ts","../../src/ast/types.ts","../../src/ast/update.ts"],"sourcesContent":["import { ifDefined } from '@prisma-next/utils/defined';\nimport type { Type } from 'arktype';\nimport type { O } from 'ts-toolbelt';\n\n/**\n * Descriptor for parameterized codecs that require type parameter validation.\n * Shared between adapter (compile-time) and runtime layers to avoid duplication.\n *\n * @template TParams - The shape of the type parameters (e.g., `{ length: number }`)\n * @template THelper - The type returned by the optional `init` hook\n */\nexport interface CodecParamsDescriptor<TParams = Record<string, unknown>, THelper = unknown> {\n  /** The codec ID this descriptor applies to (e.g., 'pg/vector@1') */\n  readonly codecId: string;\n\n  /**\n   * Arktype schema for validating typeParams.\n   * Used to validate both storage.types entries and inline column typeParams.\n   */\n  readonly paramsSchema: Type<TParams>;\n\n  /**\n   * Optional init hook called during runtime context creation.\n   * Receives validated params and returns a helper object to be stored in context.types.\n   * If not provided, the validated params are stored directly.\n   */\n  readonly init?: (params: TParams) => THelper;\n}\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<\n  Id extends string = string,\n  TWire = unknown,\n  TJs = unknown,\n  TParams = Record<string, unknown>,\n  THelper = unknown,\n> {\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   * Optional params schema for parameterized codecs.\n   * If provided, typeParams are validated against this schema.\n   */\n  readonly paramsSchema?: Type<TParams>;\n\n  /**\n   * Optional init hook for building runtime helper state from validated params.\n   *\n   * Useful when parameterized types need derived data at runtime, for example:\n   * - normalize typeParams into a stable helper shape consumed by lanes/adapters\n   * - precompute reusable values once during context creation\n   * - avoid repeating typeParams parsing logic during query execution\n   *\n   * Example:\n   *   { length: 255 } -> { kind: 'variable', maxLength: 255 }\n   *\n   * **Convention for JSON/JSONB codecs**: When the helper includes a `validate`\n   * property of type `JsonSchemaValidateFn`, the runtime will use it to enforce\n   * JSON Schema conformance during encoding and decoding. The property is\n   * discovered via duck typing (`helper?.validate`) for flexibility across\n   * different codec types.\n   */\n  readonly init?: (params: TParams) => THelper;\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<\n  Id extends string,\n  TWire,\n  TJs,\n  TParams = Record<string, unknown>,\n  THelper = unknown,\n>(config: {\n  typeId: Id;\n  targetTypes: readonly string[];\n  encode: (value: TJs) => TWire;\n  decode: (wire: TWire) => TJs;\n  meta?: CodecMeta;\n  paramsSchema?: Type<TParams>;\n  init?: (params: TParams) => THelper;\n}): Codec<Id, TWire, TJs, TParams, THelper> {\n  return {\n    id: config.typeId,\n    targetTypes: config.targetTypes,\n    ...ifDefined('meta', config.meta),\n    ...ifDefined('paramsSchema', config.paramsSchema),\n    ...ifDefined('init', config.init),\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 { ColumnRef, DeleteAst, TableRef, WhereExpr } from './types';\nimport { compact } from './util';\n\nexport interface CreateDeleteAstOptions {\n  readonly table: TableRef;\n  readonly where: WhereExpr;\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 {\n  BinaryExpr,\n  BinaryOp,\n  ExistsExpr,\n  Expression,\n  ListLiteralExpr,\n  LiteralExpr,\n  NullCheckExpr,\n  ParamRef,\n  SelectAst,\n} from './types';\n\nexport function createBinaryExpr(\n  op: BinaryOp,\n  left: Expression,\n  right: Expression | ParamRef | LiteralExpr | ListLiteralExpr,\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\nexport function createNullCheckExpr(expr: Expression, isNull: boolean): NullCheckExpr {\n  return {\n    kind: 'nullCheck',\n    expr,\n    isNull,\n  };\n}\n","import type {\n  ColumnRef,\n  Direction,\n  IncludeAst,\n  IncludeRef,\n  JoinAst,\n  OperationExpr,\n  SelectAst,\n  TableRef,\n  WhereExpr,\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?: WhereExpr;\n  readonly orderBy?: ReadonlyArray<{ expr: ColumnRef | OperationExpr; dir: Direction }>;\n  readonly limit?: number;\n  readonly selectAllIntent?: { table?: string };\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    selectAllIntent: options.selectAllIntent,\n  }) as SelectAst;\n}\n","import { type as arktype } from 'arktype';\nimport { codec, defineCodecs } from './codec-types';\n\nexport const SQL_CHAR_CODEC_ID = 'sql/char@1' as const;\nexport const SQL_VARCHAR_CODEC_ID = 'sql/varchar@1' as const;\nexport const SQL_INT_CODEC_ID = 'sql/int@1' as const;\nexport const SQL_FLOAT_CODEC_ID = 'sql/float@1' as const;\n\nconst lengthParamsSchema = arktype({\n  length: 'number.integer > 0',\n});\n\ntype LengthTypeHelper = {\n  readonly kind: 'fixed' | 'variable';\n  readonly maxLength: number;\n};\n\nfunction createLengthTypeHelper(\n  kind: LengthTypeHelper['kind'],\n): (params: Record<string, unknown>) => LengthTypeHelper {\n  return (params) => ({\n    kind,\n    maxLength: params['length'] as number,\n  });\n}\n\nconst sqlCharCodec = codec<typeof SQL_CHAR_CODEC_ID, string, string>({\n  typeId: SQL_CHAR_CODEC_ID,\n  targetTypes: ['char'],\n  encode: (value: string): string => value,\n  decode: (wire: string): string => wire.trimEnd(),\n  paramsSchema: lengthParamsSchema,\n  init: createLengthTypeHelper('fixed'),\n});\n\nconst sqlVarcharCodec = codec<typeof SQL_VARCHAR_CODEC_ID, string, string>({\n  typeId: SQL_VARCHAR_CODEC_ID,\n  targetTypes: ['varchar'],\n  encode: (value: string): string => value,\n  decode: (wire: string): string => wire,\n  paramsSchema: lengthParamsSchema,\n  init: createLengthTypeHelper('variable'),\n});\n\nconst sqlIntCodec = codec<typeof SQL_INT_CODEC_ID, number, number>({\n  typeId: SQL_INT_CODEC_ID,\n  targetTypes: ['int'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n});\n\nconst sqlFloatCodec = codec<typeof SQL_FLOAT_CODEC_ID, number, number>({\n  typeId: SQL_FLOAT_CODEC_ID,\n  targetTypes: ['float'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n});\n\nconst codecs = defineCodecs()\n  .add('char', sqlCharCodec)\n  .add('varchar', sqlVarcharCodec)\n  .add('int', sqlIntCodec)\n  .add('float', sqlFloatCodec);\n\nexport const sqlCodecDefinitions = codecs.codecDefinitions;\nexport const sqlDataTypes = codecs.dataTypes;\nexport type SqlCodecTypes = typeof codecs.CodecTypes;\n","import type { ParamDescriptor } from '@prisma-next/contract/types';\nimport 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 =\n  | 'eq'\n  | 'neq'\n  | 'gt'\n  | 'lt'\n  | 'gte'\n  | 'lte'\n  | 'like'\n  | 'ilike'\n  | 'in'\n  | 'notIn';\n\nexport interface BinaryExpr {\n  readonly kind: 'bin';\n  readonly op: BinaryOp;\n  readonly left: Expression;\n  readonly right: Expression | ParamRef | LiteralExpr | ListLiteralExpr;\n}\n\nexport interface ListLiteralExpr {\n  readonly kind: 'listLiteral';\n  readonly values: ReadonlyArray<ParamRef | LiteralExpr>;\n}\n\nexport interface AndExpr {\n  readonly kind: 'and';\n  readonly exprs: ReadonlyArray<WhereExpr>;\n}\n\nexport interface OrExpr {\n  readonly kind: 'or';\n  readonly exprs: ReadonlyArray<WhereExpr>;\n}\n\nexport interface ExistsExpr {\n  readonly kind: 'exists';\n  readonly not: boolean;\n  readonly subquery: SelectAst;\n}\n\n/**\n * Unary expression for IS NULL / IS NOT NULL checks.\n * Used in WHERE clauses to check for null values.\n */\nexport interface NullCheckExpr {\n  readonly kind: 'nullCheck';\n  readonly expr: Expression;\n  readonly isNull: boolean;\n}\n\n/**\n * Union type for WHERE clause expressions.\n */\nexport type WhereExpr = BinaryExpr | ExistsExpr | NullCheckExpr | AndExpr | OrExpr;\n\nexport interface BoundWhereExpr {\n  readonly expr: WhereExpr;\n  readonly params: readonly unknown[];\n  readonly paramDescriptors: ReadonlyArray<ParamDescriptor>;\n}\n\nexport interface ToWhereExpr {\n  toWhereExpr(): BoundWhereExpr;\n}\n\nexport type WhereArg = WhereExpr | ToWhereExpr;\n\nexport type JoinOnExpr =\n  | {\n      readonly kind: 'eqCol';\n      readonly left: ColumnRef;\n      readonly right: ColumnRef;\n    }\n  | WhereExpr;\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?: WhereExpr;\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?: WhereExpr;\n  readonly orderBy?: ReadonlyArray<{ expr: Expression; dir: Direction }>;\n  readonly limit?: number;\n  readonly selectAllIntent?: { table?: string };\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?: WhereExpr;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport interface DeleteAst {\n  readonly kind: 'delete';\n  readonly table: TableRef;\n  readonly where?: WhereExpr;\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 { ColumnRef, ParamRef, TableRef, UpdateAst, WhereExpr } from './types';\nimport { compact } from './util';\n\nexport interface CreateUpdateAstOptions {\n  readonly table: TableRef;\n  readonly set: Record<string, ColumnRef | ParamRef>;\n  readonly where?: WhereExpr;\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/errors.d.mts

@@ -0,0 +1,2 @@
+import { n as planUnsupported, t as planInvalid } from "../errors-DVufq9PT.mjs";
+export { planInvalid, planUnsupported };

package/dist/exports/errors.mjs

@@ -0,0 +1,3 @@
+import { n as planUnsupported, t as planInvalid } from "../errors-7_V3El9I.mjs";
+
+export { planInvalid, planUnsupported };

package/dist/exports/guards.d.mts

@@ -0,0 +1,5 @@
+import "../query-lane-context-CgkPuKaR.mjs";
+import "../plan-BhSWuTfw.mjs";
+import "../types-CEUzDuDC.mjs";
+import { a as getColumnMeta, c as isExpressionBuilder, d as isParamPlaceholder, f as isValueSource, i as getColumnInfo, l as isExpressionSource, n as expressionFromSource, o as getOperationExpr, p as toExpression, r as extractBaseColumnRef, s as isColumnBuilder, t as collectColumnRefs, u as isOperationExpr } from "../guards-DCCpAlOL.mjs";
+export { collectColumnRefs, expressionFromSource, extractBaseColumnRef, getColumnInfo, getColumnMeta, getOperationExpr, isColumnBuilder, isExpressionBuilder, isExpressionSource, isOperationExpr, isParamPlaceholder, isValueSource, toExpression };

package/dist/exports/guards.mjs

@@ -0,0 +1,3 @@
+import { a as getColumnMeta, c as isExpressionBuilder, d as isParamPlaceholder, f as isValueSource, i as getColumnInfo, l as isExpressionSource, n as expressionFromSource, o as getOperationExpr, p as toExpression, r as extractBaseColumnRef, s as isColumnBuilder, t as collectColumnRefs, u as isOperationExpr } from "../guards-0ycyntYX.mjs";
+
+export { collectColumnRefs, expressionFromSource, extractBaseColumnRef, getColumnInfo, getColumnMeta, getOperationExpr, isColumnBuilder, isExpressionBuilder, isExpressionSource, isOperationExpr, isParamPlaceholder, isValueSource, toExpression };

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

@@ -0,0 +1,5 @@
+import "../query-lane-context-CgkPuKaR.mjs";
+import "../plan-BhSWuTfw.mjs";
+import "../types-CEUzDuDC.mjs";
+import { t as attachOperationsToColumnBuilder } from "../operations-registry-wVEaiLyt.mjs";
+export { attachOperationsToColumnBuilder };

package/dist/exports/operations-registry.mjs

@@ -0,0 +1,3 @@
+import { t as attachOperationsToColumnBuilder } from "../operations-registry-DPZ5aElH.mjs";
+
+export { attachOperationsToColumnBuilder };

package/dist/exports/param.d.mts

@@ -0,0 +1,5 @@
+import "../query-lane-context-CgkPuKaR.mjs";
+import "../plan-BhSWuTfw.mjs";
+import "../types-CEUzDuDC.mjs";
+import { n as param, t as Parameter } from "../param-C4n0OW59.mjs";
+export { Parameter, param };

package/dist/exports/param.mjs

@@ -0,0 +1,3 @@
+import { t as param } from "../param-DMU3OWfI.mjs";
+
+export { param };

package/dist/exports/plan.d.mts

@@ -0,0 +1,2 @@
+import { n as augmentDescriptorWithColumnMeta, t as SqlQueryPlan } from "../plan-BhSWuTfw.mjs";
+export { SqlQueryPlan, augmentDescriptorWithColumnMeta };

package/dist/exports/plan.mjs

@@ -0,0 +1,17 @@
+//#region src/plan.ts
+/**
+* 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.
+*/
+function augmentDescriptorWithColumnMeta(descriptors, columnMeta) {
+	const descriptor = descriptors[descriptors.length - 1];
+	if (descriptor && columnMeta) descriptors[descriptors.length - 1] = {
+		...descriptor,
+		codecId: columnMeta.codecId,
+		nativeType: columnMeta.nativeType
+	};
+}
+
+//#endregion
+export { augmentDescriptorWithColumnMeta };
+//# sourceMappingURL=plan.mjs.map

package/dist/exports/plan.mjs.map

@@ -0,0 +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"}

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

@@ -0,0 +1,2 @@
+import { a as JsonSchemaValidationResult, c as MutationDefaultsOptions, i as JsonSchemaValidationError, l as TypeHelperRegistry, n as ExecutionContext, o as JsonSchemaValidatorRegistry, r as JsonSchemaValidateFn, s as MutationDefaultsOp, t as AppliedMutationDefault } from "../query-lane-context-CgkPuKaR.mjs";
+export { AppliedMutationDefault, ExecutionContext, JsonSchemaValidateFn, JsonSchemaValidationError, JsonSchemaValidationResult, JsonSchemaValidatorRegistry, MutationDefaultsOp, MutationDefaultsOptions, TypeHelperRegistry };

package/dist/exports/query-lane-context.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/exports/schema.d.mts

@@ -0,0 +1,5 @@
+import "../query-lane-context-CgkPuKaR.mjs";
+import "../plan-BhSWuTfw.mjs";
+import "../types-CEUzDuDC.mjs";
+import { i as schema, n as SchemaHandle, r as TableBuilderImpl, t as ColumnBuilderImpl } from "../schema-CgrEMqEd.mjs";
+export { ColumnBuilderImpl as Column, ColumnBuilderImpl, SchemaHandle, TableBuilderImpl as Table, TableBuilderImpl, schema };

package/dist/exports/schema.mjs

@@ -0,0 +1,4 @@
+import "../operations-registry-DPZ5aElH.mjs";
+import { n as TableBuilderImpl, r as schema, t as ColumnBuilderImpl } from "../schema-Bi5p4aAc.mjs";
+
+export { ColumnBuilderImpl, TableBuilderImpl, schema };

package/dist/exports/types.d.mts

@@ -0,0 +1,4 @@
+import "../query-lane-context-CgkPuKaR.mjs";
+import "../plan-BhSWuTfw.mjs";
+import { A as OperationTypes, B as SqlBuilderOptions, C as Meta, D as NullCheckBuilder, E as NestedProjection, F as RawFunctionOptions, G as TablesOf, H as TableDef, I as RawTemplateFactory, J as createOrderBuilder, K as UnaryBuilder, L as RawTemplateOptions, M as OrderBuilder, N as ParamPlaceholder, O as NullableMethods, P as RawFactory, R as ResultType, S as META, T as ModelMetadata, U as TableKey, V as SqlPlan, W as TableMetadata, Y as isColumnBuilder, _ as InferNestedProjectionRow, a as AnyOrderBuilder, b as JoinOnBuilder, c as BuildOptions, d as ColumnBuilder, f as ColumnsOf, g as HasIncludeManyCapabilities, h as ExpressionBuilder, i as AnyExpressionSource, j as OperationsForTypeId, k as OperationTypeSignature, l as BuildParamsMap, m as Expr, n as AnyColumnBuilder, o as AnyUnaryBuilder, p as ComputeColumnJsType, q as ValueSource, r as AnyColumnBuilderBase, s as BinaryBuilder, t as AnyBinaryBuilder, u as CodecTypes, v as InferProjectionRow, w as ModelDef, x as JoinOnPredicate, y as InferReturningRow, z as RuntimeError } from "../types-CEUzDuDC.mjs";
+export { AnyBinaryBuilder, AnyColumnBuilder, AnyColumnBuilderBase, AnyExpressionSource, AnyOrderBuilder, AnyUnaryBuilder, BinaryBuilder, BuildOptions, BuildParamsMap, CodecTypes, ColumnBuilder, ColumnsOf, ComputeColumnJsType, Expr, ExpressionBuilder, HasIncludeManyCapabilities, InferNestedProjectionRow, InferProjectionRow, InferReturningRow, JoinOnBuilder, JoinOnPredicate, META, Meta, ModelDef, ModelMetadata, NestedProjection, NullCheckBuilder, NullableMethods, OperationTypeSignature, OperationTypes, OperationsForTypeId, OrderBuilder, ParamPlaceholder, RawFactory, RawFunctionOptions, RawTemplateFactory, RawTemplateOptions, ResultType, RuntimeError, SqlBuilderOptions, SqlPlan, TableDef, TableKey, TableMetadata, TablesOf, UnaryBuilder, ValueSource, createOrderBuilder, isColumnBuilder };

package/dist/exports/types.mjs

@@ -0,0 +1,3 @@
+import { n as isColumnBuilder, t as createOrderBuilder } from "../types-Cdi4Whda.mjs";
+
+export { createOrderBuilder, isColumnBuilder };

package/dist/exports/utils/guards.d.mts

@@ -0,0 +1,5 @@
+import "../../query-lane-context-CgkPuKaR.mjs";
+import "../../plan-BhSWuTfw.mjs";
+import "../../types-CEUzDuDC.mjs";
+import { a as getColumnMeta, c as isExpressionBuilder, d as isParamPlaceholder, f as isValueSource, i as getColumnInfo, l as isExpressionSource, n as expressionFromSource, o as getOperationExpr, p as toExpression, r as extractBaseColumnRef, s as isColumnBuilder, t as collectColumnRefs, u as isOperationExpr } from "../../guards-DCCpAlOL.mjs";
+export { collectColumnRefs, expressionFromSource, extractBaseColumnRef, getColumnInfo, getColumnMeta, getOperationExpr, isColumnBuilder, isExpressionBuilder, isExpressionSource, isOperationExpr, isParamPlaceholder, isValueSource, toExpression };

package/dist/exports/utils/guards.mjs

@@ -0,0 +1,4 @@
+import { a as getColumnMeta, c as isExpressionBuilder, d as isParamPlaceholder, f as isValueSource, i as getColumnInfo, l as isExpressionSource, n as expressionFromSource, o as getOperationExpr, p as toExpression, r as extractBaseColumnRef, s as isColumnBuilder, t as collectColumnRefs, u as isOperationExpr } from "../../guards-0ycyntYX.mjs";
+import "../guards.mjs";
+
+export { collectColumnRefs, expressionFromSource, extractBaseColumnRef, getColumnInfo, getColumnMeta, getOperationExpr, isColumnBuilder, isExpressionBuilder, isExpressionSource, isOperationExpr, isParamPlaceholder, isValueSource, toExpression };