@vibeorm/sql 3.0.0 → 4.1.0

package/dist/query/index.js

@@ -0,0 +1,1080 @@
+// @bun
+// packages/sql/src/query/select.ts
+import { assertSqlParamBuilding as assertSqlParamBuilding2, createSqlQuery, isSqlParam as isSqlParam2, recordSqlBinding as recordSqlBinding2, sameResultDecoder, sqlParamContract as sqlParamContract2 } from "@vibeorm/sql";
+
+// packages/sql/src/query/state.ts
+import { VibeError } from "@vibeorm/schema";
+import { registerSqlHandleCheck } from "@vibeorm/sql";
+var expressionStates = new WeakMap;
+var sourceStates = new WeakMap;
+var readStates = new WeakMap;
+var builderTerminals = new WeakSet;
+registerSqlHandleCheck({ check: (value) => expressionStates.has(value) || sourceStates.has(value) || builderTerminals.has(value) });
+function columnContract(definition) {
+  return JSON.stringify({ scalar: definition.scalar, nullable: definition.nullable === true, list: definition.list === true, enumType: definition.enumType, enumValues: definition.enumValues, nativeType: definition.nativeType, transport: definition.transport });
+}
+function invalid(message) {
+  throw new VibeError({ code: "VIBE_VALIDATION", message });
+}
+function invalidData(message) {
+  throw new VibeError({ code: "VIBE_DATA_INVALID", message });
+}
+function unsupported(message) {
+  throw new VibeError({ code: "VIBE_UNSUPPORTED_CAPABILITY", message });
+}
+function identifier(name) {
+  if (typeof name !== "string" || name.length === 0 || name.includes("\x00"))
+    invalid("SQL names must be non-empty and NUL-free");
+}
+function expressionState(expression) {
+  if (typeof expression !== "object" || expression === null)
+    invalid("Expected an authentic SQL expression");
+  return expressionStates.get(expression) ?? invalid("Expected an authentic SQL expression");
+}
+function sourceState(source) {
+  if (typeof source !== "object" || source === null)
+    invalid("Expected an authentic SQL source");
+  return sourceStates.get(source) ?? invalid("Expected an authentic SQL source");
+}
+function readState(query) {
+  if (typeof query !== "object" || query === null)
+    invalid("Expected a builder read query");
+  return readStates.get(query) ?? invalid("Derived sources and unions require builder SELECT queries, not raw or write plans");
+}
+function makeExpression(state) {
+  const expression = Object.freeze(Object.create(null));
+  expressionStates.set(expression, Object.freeze(state));
+  return expression;
+}
+function checkScope(params) {
+  const state = expressionState(params.expression);
+  if (state.default === true)
+    invalid("SQL DEFAULT is only valid in write values");
+  const available = new Set(params.bindings.map((binding) => binding.token));
+  for (const token of state.references)
+    if (!available.has(token))
+      invalid("SQL expression belongs to a different source scope");
+  if (params.nullableContracts === true && state.column !== undefined && state.definition?.nullable !== true && params.bindings.some((binding) => binding.token === state.column.binding && binding.nullable))
+    invalid("A captured pre-join column cannot bypass outer-join nullability; use the output scope");
+  if (params.aggregates === false && state.aggregate)
+    invalid("Aggregate expressions are not valid in this clause");
+}
+
+// packages/sql/src/query/sources.ts
+import { assertSqlNamespace } from "@vibeorm/schema";
+
+// packages/sql/src/query/expressions.ts
+import { assertSqlParamBuilding, decode, float32Codec, isSqlBindingCollector, isSqlFragment, isSqlParam, jsonListParameter, nativeEnumArrayParameter, parsePgArrayLiteral, recordSqlBinding, renderSqlFragment, resultScalarContract, snapshotSqlValue, sqlParamContract, timeOfDayCodec, toPgArrayLiteral } from "@vibeorm/sql";
+var nullableFloat = decode.nullable({ decoder: decode.float });
+var countDefinition = Object.freeze({ name: "", scalar: "BigInt", decoder: decode.bigInt });
+var floatDefinition = Object.freeze({ name: "", scalar: "Float", nullable: true, decoder: nullableFloat });
+var nullableDecoders = new WeakMap;
+function nullableDecoder(decoder) {
+  let lifted = nullableDecoders.get(decoder);
+  if (lifted === undefined) {
+    lifted = Object.freeze({ decode: (params) => params.value === null ? null : decoder.decode(params) });
+    nullableDecoders.set(decoder, lifted);
+  }
+  return lifted;
+}
+function assertDecoder(decoder) {
+  if (typeof decoder?.decode !== "function")
+    invalid("SQL expressions require an explicit result decoder");
+}
+function inputDecoder(definition) {
+  const decoder = definition.inputDecoder ?? definition.decoder;
+  if (!("encode" in decoder) || typeof decoder.encode !== "function")
+    invalid("A decode-only projection requires a separate inputDecoder for parameters and writes");
+  return decoder;
+}
+function nativeColumnDefinition(definition) {
+  const contract = resultScalarContract({ decoder: definition.decoder });
+  if (contract === undefined || contract.scalar !== definition.scalar)
+    return definition;
+  const codec = definition.scalar === "DateTime" ? timeOfDayCodec({ nativeType: definition.nativeType }) : definition.scalar === "Float" && /^(real|float4)$/i.test(definition.nativeType ?? "") ? float32Codec : undefined;
+  if (codec === undefined)
+    return definition;
+  const original = definition.decoder;
+  const list = definition.list === true;
+  let decoders = nativeDecoders.get(original);
+  if (decoders === undefined) {
+    decoders = new Map;
+    nativeDecoders.set(original, decoders);
+  }
+  const key = `${definition.nativeType}|${list}`;
+  let decoder = decoders.get(key);
+  if (decoder === undefined) {
+    decoder = Object.freeze({
+      decode: (params) => {
+        const raw = params.value;
+        const convert = (value) => value === null ? null : codec.decode(value);
+        const elements = typeof raw === "string" && list && params.dialect === "postgres" ? parsePgArrayLiteral({ literal: raw }) : ArrayBuffer.isView(raw) && ("length" in raw) ? Array.from(raw) : raw;
+        const value = raw === null ? null : list && Array.isArray(elements) ? elements.map(convert) : convert(raw);
+        return original.decode({ ...params, value });
+      },
+      encode: (params) => {
+        const encoded = original.encode(params);
+        const convert = (value) => value === null ? null : codec.encode(value);
+        return list && Array.isArray(encoded) ? encoded.map(convert) : convert(encoded);
+      }
+    });
+    decoders.set(key, decoder);
+  }
+  return { ...definition, decoder };
+}
+var nativeDecoders = new WeakMap;
+function transportProjection(params) {
+  const { context, expression, definition } = params;
+  if (definition.transport === "text" || definition.scalar === "Json" || definition.scalar === "BigInt" || definition.list === true && definition.scalar === "Float") {
+    return `CAST(${expression} AS ${context.dialect.name === "mysql" ? "CHAR" : "TEXT"})`;
+  }
+  return expression;
+}
+function columnInputContract(definition) {
+  const encoder = inputDecoder(definition);
+  return {
+    encoder,
+    scalar: definition.scalar,
+    nullable: definition.nullable === true,
+    list: definition.list === true,
+    nativeType: definition.nativeType,
+    enumValues: definition.enumValues,
+    enumType: definition.enumType,
+    jsonStorage: definition.jsonStorage,
+    ...definition.inputDecoder !== undefined && definition.inputDecoder !== definition.decoder ? { columnIdentity: encoder } : {}
+  };
+}
+function physicalInput(contract) {
+  return JSON.stringify({ scalar: contract.scalar, list: contract.list, nativeType: contract.nativeType, enumValues: contract.enumValues, enumType: contract.enumType === undefined ? undefined : [contract.enumType.namespace, contract.enumType.name], jsonStorage: contract.jsonStorage });
+}
+function parameterDefinition(params) {
+  const declared = sqlParamContract({ param: params.param });
+  const target = columnInputContract(params.definition);
+  if (declared.columnIdentity !== undefined || target.columnIdentity !== undefined) {
+    if (declared.encoder !== target.encoder || physicalInput(declared) !== physicalInput(target))
+      invalid("SQL input token does not match this column's write encoder and physical contract");
+    return { ...params.definition, nullable: declared.nullable && target.nullable, inputDecoder: declared.encoder };
+  }
+  if (declared.scalar !== "Unknown" && (declared.scalar !== target.scalar || declared.list !== target.list))
+    invalid("SQL input token has an incompatible scalar or list contract");
+  if (declared.scalar === "Unknown" && (target.nativeType !== undefined || target.scalar === "Enum" || target.scalar === "Json"))
+    invalid("Opaque SQL input decoders need qb.input for native, enum and JSON columns");
+  if (declared.nativeType !== undefined && physicalInput(declared) !== physicalInput(target))
+    invalid("SQL input token has an incompatible native column contract");
+  if (declared.scalar === "Enum" && physicalInput(declared) !== physicalInput(target))
+    invalid("SQL input token has an incompatible enum column contract");
+  if ("decode" in declared.encoder && typeof declared.encoder.decode === "function") {
+    return nativeColumnDefinition({ ...params.definition, nullable: declared.nullable && target.nullable, decoder: declared.encoder, inputDecoder: undefined });
+  }
+  if (declared.encoder !== target.encoder)
+    invalid("A write-only SQL input token must match its column encoder");
+  return { ...params.definition, nullable: declared.nullable && target.nullable, inputDecoder: declared.encoder };
+}
+function columnTransport(definition) {
+  if (definition.list === true && definition.scalar === "Enum" && definition.enumType !== undefined)
+    return { kind: "native-enum-array", type: definition.enumType };
+  if (definition.list === true && definition.scalar === "Json")
+    return { kind: "json-list", storage: definition.jsonStorage ?? "jsonb", whole: true };
+  return { kind: "plain" };
+}
+function encodeColumnValue(params) {
+  const { dialect, definition } = params;
+  if (params.value === null) {
+    if (definition.nullable !== true)
+      invalid("A non-null SQL column cannot receive SQL NULL");
+    return null;
+  }
+  const encoded = snapshotSqlValue(inputDecoder(definition).encode({ value: snapshotSqlValue(params.value), dialect: dialect.name }));
+  if (encoded === null) {
+    if (definition.nullable !== true)
+      invalid("A non-null SQL column cannot receive SQL NULL from its encoder");
+    return null;
+  }
+  if (definition.scalar === "BigInt" && definition.list !== true && dialect.name === "sqlite") {
+    const integer = decode.bigInt.decode({ value: encoded, dialect: "sqlite" });
+    if (integer < -9223372036854775808n || integer > 9223372036854775807n)
+      invalid("SQLite BigInt parameters must fit signed int64");
+  }
+  if (definition.list === true && definition.scalar === "Enum" && definition.enumType !== undefined) {
+    if (!Array.isArray(encoded))
+      invalid("Native enum list encoder must return an array");
+    return nativeEnumArrayParameter({ value: toPgArrayLiteral({ values: encoded }), type: definition.enumType });
+  }
+  if (definition.list === true && definition.scalar === "Json") {
+    if (!Array.isArray(encoded) || encoded.some((entry) => typeof entry !== "string"))
+      invalid("JSON list encoder must return encoded JSON text elements");
+    return jsonListParameter({ value: encoded, storage: definition.jsonStorage ?? "jsonb" });
+  }
+  return encoded;
+}
+function bindColumnValue(params) {
+  const { context, definition } = params;
+  if (definition.list === true && !context.dialect.capabilities.scalarArrays)
+    unsupported("Scalar array parameters require a dialect with native scalar arrays");
+  const token = isSqlParam(params.value) ? params.value : undefined;
+  const input = token !== undefined ? parameterDefinition({ definition, param: token }) : params.encoder === undefined ? definition : nativeColumnDefinition({ ...definition, decoder: params.encoder, inputDecoder: undefined });
+  let placeholder;
+  if (isSqlBindingCollector({ collector: context.collector })) {
+    placeholder = recordSqlBinding({
+      collector: context.collector,
+      source: token === undefined ? { kind: "literal", value: params.value } : { kind: "input", param: token },
+      contract: columnInputContract(input),
+      transport: columnTransport(definition),
+      rejectNull: params.rejectNull,
+      encode: ({ value, dialect }) => encodeColumnValue({ value, dialect, definition: input })
+    });
+  } else {
+    if (token !== undefined)
+      invalid("SQL input tokens require execution through their reusable template");
+    const encoded = encodeColumnValue({ dialect: context.dialect, definition: input, value: params.value });
+    placeholder = context.collector.add(encoded);
+    if (encoded === null)
+      return placeholder;
+  }
+  if (definition.scalar === "BigInt" && definition.list !== true && context.dialect.name === "sqlite")
+    return `CAST(${placeholder} AS INTEGER)`;
+  if (definition.scalar === "Json" && definition.list !== true)
+    return placeholder + (definition.jsonStorage === "json" && context.dialect.name === "postgres" ? "::text::json" : context.dialect.jsonParamCast);
+  return placeholder;
+}
+function predicateDefinition(expression) {
+  const state = expressionState(expression);
+  if (state.definition?.inputDecoder !== undefined && (!("encode" in state.definition.decoder) || typeof state.definition.decoder.encode !== "function"))
+    unsupported("Input tokens cannot infer predicates over read-transformed columns");
+  if (state.definition !== undefined)
+    return state.definition;
+  if (!("encode" in state.decoder) || typeof state.decoder.encode !== "function")
+    invalid("A decode-only expression cannot infer a parameter encoder");
+  const physical = resultScalarContract({ decoder: state.decoder });
+  return { name: "", scalar: physical?.scalar ?? "Unknown", nullable: physical?.nullable ?? true, list: physical?.list ?? false, decoder: state.decoder };
+}
+function bindPredicateParam(params) {
+  return bindColumnValue({ context: params.context, definition: predicateDefinition(params.expression), value: params.param, rejectNull: true });
+}
+function childrenState(params) {
+  const states = params.children.map(expressionState);
+  if (states.some((state) => state.default === true))
+    invalid("SQL DEFAULT cannot be used in expressions");
+  return {
+    decoder: params.decoder,
+    render: params.render,
+    contract: params.contract ?? params.decoder,
+    references: new Set(states.flatMap((state) => [...state.references])),
+    ungrouped: new Set(states.flatMap((state) => [...state.ungrouped])),
+    aggregate: params.aggregate === true || states.some((state) => state.aggregate)
+  };
+}
+function literal(params) {
+  assertDecoder(params.decoder);
+  if (typeof params.decoder.encode !== "function")
+    invalid("SQL values require a bidirectional decoder");
+  const decoder = params.decoder;
+  const physical = resultScalarContract({ decoder });
+  if (physical === undefined)
+    invalid("qb.value requires a built-in scalar decoder with a physical SQL type; use qb.raw with explicit SQL for custom decoders");
+  const value = snapshotSqlValue(params.value);
+  const definition = Object.freeze({ ...physical, name: "", decoder, inputDecoder: decoder });
+  const readDecoder = physical.scalar === "Json" ? Object.freeze({ decode: (result) => decoder.decode({ ...result, wire: { ...result.wire, json: "text" } }) }) : decoder;
+  const render = (context) => {
+    const operand = bindColumnValue({ context, definition, value });
+    if (physical.scalar === "Json" && context.dialect.name === "postgres")
+      return operand;
+    const type = context.dialect.valueCastTypes[physical.scalar];
+    return `CAST(${operand} AS ${type}${physical.list ? "[]" : ""})`;
+  };
+  return makeExpression({
+    decoder: readDecoder,
+    contract: decoder,
+    references: new Set,
+    ungrouped: new Set,
+    aggregate: false,
+    parameter: Object.freeze({ value, decoder }),
+    definition,
+    render,
+    projection: (context) => transportProjection({ context, expression: render(context), definition })
+  });
+}
+function comparedLiteral(params) {
+  const state = expressionState(params.expression);
+  const definition = state.definition;
+  if (definition?.inputDecoder !== undefined && (!("encode" in definition.decoder) || typeof definition.decoder.encode !== "function")) {
+    unsupported("Implicit literal predicates are unavailable for read-transformed columns; use an explicit trusted SQL input contract");
+  }
+  const value = snapshotSqlValue(params.value);
+  return makeExpression({
+    decoder: state.decoder,
+    contract: state.contract,
+    references: new Set,
+    ungrouped: new Set,
+    aggregate: false,
+    render: (context) => {
+      if (state.definition !== undefined)
+        return bindColumnValue({ context, definition: state.definition, value });
+      if (!("encode" in state.decoder) || typeof state.decoder.encode !== "function")
+        invalid("A decode-only expression cannot infer a parameter encoder; use qb.value with an explicit write decoder");
+      if (isSqlBindingCollector({ collector: context.collector }))
+        return recordSqlBinding({ collector: context.collector, source: { kind: "literal", value }, transport: { kind: "plain" }, encode: (input) => state.decoder.encode({ value: input.value, dialect: input.dialect.name }) });
+      return context.collector.add(snapshotSqlValue(state.decoder.encode({ value: snapshotSqlValue(value), dialect: context.dialect.name })));
+    }
+  });
+}
+function comparison(params) {
+  const initialLeft = expressionState(params.left);
+  if (isSqlParam(params.right)) {
+    const param = params.right;
+    assertSqlParamBuilding({ param });
+    predicateDefinition(params.left);
+    return makeExpression(childrenState({ children: [params.left], decoder: nullableDecoder(decode.boolean), render: (context) => {
+      if (context.dialect.name === "sqlite" && initialLeft.definition?.scalar === "Decimal")
+        unsupported("SQLite Decimal comparisons are not exact; use an explicit raw numeric contract");
+      return `(${initialLeft.render(context)} ${params.operator} ${bindPredicateParam({ context, expression: params.left, param })})`;
+    } }));
+  }
+  if (params.right === null)
+    invalid("Use isNull for SQL NULL predicates");
+  const right = typeof params.right === "object" && params.right !== null && expressionStates.has(params.right) ? params.right : comparedLiteral({ expression: params.left, value: params.right });
+  const leftState = expressionState(params.left);
+  const rightState = expressionState(right);
+  const unsafeDecimal = (state) => state.definition?.scalar === "Decimal";
+  return makeExpression(childrenState({
+    children: [params.left, right],
+    decoder: nullableDecoder(decode.boolean),
+    render: (context) => {
+      if (context.dialect.name === "sqlite" && (unsafeDecimal(leftState) || unsafeDecimal(rightState)))
+        unsupported("SQLite Decimal comparisons are not exact; use an explicit raw numeric contract");
+      const left = leftState.render(context);
+      const operand = leftState.parameter === undefined && leftState.definition !== undefined && rightState.parameter !== undefined ? bindColumnValue({ context, definition: leftState.definition, encoder: rightState.parameter.decoder, value: rightState.parameter.value }) : rightState.render(context);
+      return `(${left} ${params.operator} ${operand})`;
+    }
+  }));
+}
+function logic(params) {
+  const predicates = [...params.predicates];
+  return makeExpression(childrenState({
+    children: predicates,
+    decoder: nullableDecoder(decode.boolean),
+    render: (context) => predicates.length === 0 ? params.operator === "AND" ? "(1 = 1)" : "(1 = 0)" : `(${predicates.map((predicate) => expressionState(predicate).render(context)).join(` ${params.operator} `)})`
+  }));
+}
+function aggregate(params) {
+  const state = expressionState(params.expression);
+  const definition = state.definition;
+  if (state.aggregate)
+    invalid("Nested aggregate expressions are unsupported");
+  if (definition === undefined || definition.list === true || !["String", "Int", "BigInt", "Float", "DateTime"].includes(definition.scalar))
+    unsupported("MIN/MAX require a qualified ordered scalar column; use an explicit raw decoder otherwise");
+  if (definition.scalar === "String" && definition.nativeType !== undefined && !/^(text|varchar|char|bpchar|tinytext|mediumtext|longtext)(?:\s*\(.*\))?$/i.test(definition.nativeType))
+    unsupported("MIN/MAX do not support this native String type; UUID and other non-text types need explicit SQL");
+  return makeExpression({
+    ...state,
+    parameter: undefined,
+    column: undefined,
+    definition: { ...definition, nullable: true },
+    decoder: nullableDecoder(state.decoder),
+    contract: columnContract({ ...definition, nullable: true }),
+    ungrouped: new Set,
+    aggregate: true,
+    render: (context) => `${params.fn}(${state.render(context)})`,
+    projection: definition.scalar === "BigInt" ? (context) => `CAST(${params.fn}(${state.render(context)}) AS ${context.dialect.name === "mysql" ? "CHAR" : "TEXT"})` : undefined
+  });
+}
+function floatAggregate(params) {
+  const state = expressionState(params.expression);
+  const definition = state.definition;
+  if (state.aggregate)
+    invalid("Nested aggregate expressions are unsupported");
+  if (definition?.scalar !== "Float" || definition.list === true || definition.nativeType !== undefined && !["doubleprecision", "double", "float8"].includes(definition.nativeType.toLowerCase()))
+    unsupported("SUM/AVG support only qualified double-precision Float columns; Int, BigInt, Decimal and real/float4 require an explicit raw result contract");
+  return makeExpression({
+    ...state,
+    parameter: undefined,
+    column: undefined,
+    definition: floatDefinition,
+    projection: undefined,
+    decoder: nullableDecoder(decode.float),
+    contract: columnContract(floatDefinition),
+    ungrouped: new Set,
+    aggregate: true,
+    render: (context) => `${params.fn}(${state.render(context)})`
+  });
+}
+function rawExpression(params) {
+  if (!isSqlFragment(params.sql))
+    invalid("Raw expressions require an authentic core SQL fragment");
+  assertDecoder(params.decoder);
+  const fragment = params.sql;
+  return makeExpression(childrenState({ children: [...params.references ?? []], decoder: params.decoder, render: (context) => renderSqlFragment({ ...context, fragment }) }));
+}
+function nullTest(params) {
+  const { expression, not } = params;
+  return makeExpression(childrenState({ children: [expression], decoder: decode.boolean, render: (context) => `(${expressionState(expression).render(context)} IS ${not ? "NOT " : ""}NULL)` }));
+}
+function membership(params) {
+  if (!Array.isArray(params.values))
+    invalid("inList/notInList require an expression and a literal value array");
+  const { not } = params;
+  const values = [...params.values].map((value) => {
+    if (!isSqlParam(value))
+      return comparedLiteral({ expression: params.expression, value });
+    assertSqlParamBuilding({ param: value });
+    predicateDefinition(params.expression);
+    return value;
+  });
+  const renderValue = (value, context) => isSqlParam(value) ? bindPredicateParam({ context, expression: params.expression, param: value }) : expressionState(value).render(context);
+  const state = expressionState(params.expression);
+  return makeExpression(childrenState({
+    children: [params.expression, ...values.filter((value) => !isSqlParam(value))],
+    decoder: nullableDecoder(decode.boolean),
+    render: (context) => {
+      if (state.definition?.scalar === "Decimal" && context.dialect.name === "sqlite")
+        unsupported("SQLite Decimal membership is not exact");
+      if (values.length === 0)
+        return not ? "(1 = 1)" : "(1 = 0)";
+      if (state.definition?.scalar === "DateTime" && timeOfDayCodec({ nativeType: state.definition.nativeType }) !== undefined && context.dialect.timeOfDayInStrategy === "equalities") {
+        const equalities = values.map((value) => `(${state.render(context)} = ${renderValue(value, context)})`).join(" OR ");
+        return not ? `(NOT (${equalities}))` : `(${equalities})`;
+      }
+      return `(${state.render(context)} ${not ? "NOT " : ""}IN (${values.map((value) => renderValue(value, context)).join(", ")}))`;
+    }
+  }));
+}
+var eq = (left, right) => comparison({ left, right, operator: "=" });
+var ne = (left, right) => comparison({ left, right, operator: "<>" });
+var gt = (left, right) => comparison({ left, right, operator: ">" });
+var gte = (left, right) => comparison({ left, right, operator: ">=" });
+var lt = (left, right) => comparison({ left, right, operator: "<" });
+var lte = (left, right) => comparison({ left, right, operator: "<=" });
+var isNull = (expression) => nullTest({ expression, not: false });
+var isNotNull = (expression) => nullTest({ expression, not: true });
+var and = (...predicates) => logic({ predicates, operator: "AND" });
+var or = (...predicates) => logic({ predicates, operator: "OR" });
+var not = (predicate) => makeExpression(childrenState({ children: [predicate], decoder: nullableDecoder(decode.boolean), render: (context) => `(NOT ${expressionState(predicate).render(context)})` }));
+var inList = (expression, values) => membership({ expression, values, not: false });
+var notInList = (expression, values) => membership({ expression, values, not: true });
+var count = (expression, options) => {
+  const distinct = options?.distinct === true;
+  if (distinct && expression === undefined)
+    invalid("COUNT DISTINCT requires an expression");
+  const operand = expression === undefined ? undefined : expressionState(expression);
+  if (operand?.default === true)
+    invalid("COUNT cannot consume SQL DEFAULT");
+  if (operand?.aggregate === true)
+    invalid("Nested aggregate expressions are unsupported");
+  return makeExpression({
+    decoder: decode.bigInt,
+    contract: columnContract(countDefinition),
+    references: operand?.references ?? new Set,
+    ungrouped: new Set,
+    aggregate: true,
+    definition: countDefinition,
+    render: (context) => `COUNT(${distinct ? "DISTINCT " : ""}${operand === undefined ? "*" : operand.render(context)})`,
+    projection: (context) => {
+      const count = `COUNT(${distinct ? "DISTINCT " : ""}${operand === undefined ? "*" : operand.render(context)})`;
+      return `CAST(${count} AS ${context.dialect.name === "mysql" ? "CHAR" : "TEXT"})`;
+    }
+  });
+};
+var min = (expression) => aggregate({ expression, fn: "MIN" });
+var max = (expression) => aggregate({ expression, fn: "MAX" });
+var sum = (expression) => floatAggregate({ expression, fn: "SUM" });
+var avg = (expression) => floatAggregate({ expression, fn: "AVG" });
+
+// packages/sql/src/query/sources.ts
+function makeTable(params) {
+  identifier(params.name);
+  if (params.namespace !== undefined)
+    identifier(params.namespace);
+  const columns = Object.fromEntries(Object.entries(params.columns).map(([key, definition]) => {
+    identifier(key);
+    identifier(definition.name);
+    assertDecoder(definition.decoder);
+    if (definition.inputDecoder !== undefined && typeof definition.inputDecoder.encode !== "function")
+      invalid("SQL input decoders must have an encoder");
+    if (definition.enumType !== undefined) {
+      identifier(definition.enumType.name);
+      identifier(definition.enumType.namespace);
+    }
+    return [key, Object.freeze({ ...nativeColumnDefinition(definition), ...definition.enumValues === undefined ? {} : { enumValues: Object.freeze([...definition.enumValues]) }, ...definition.enumType === undefined ? {} : { enumType: Object.freeze({ ...definition.enumType }) } })];
+  }));
+  if (Object.keys(columns).length === 0)
+    invalid("SQL sources require at least one column");
+  const physical = Object.values(columns).map((column) => column.name);
+  if (new Set(physical).size !== physical.length)
+    invalid("Physical column names must be unique within a source");
+  const required = [...params.required ?? Object.entries(columns).filter(([, definition]) => definition.nullable !== true && definition.dbDefault !== true).map(([name]) => name)];
+  if (required.some((key) => !Object.hasOwn(columns, key)))
+    invalid("Required insert columns must belong to the table");
+  const source = Object.freeze(Object.create(null));
+  sourceStates.set(source, Object.freeze({ name: params.name, namespace: params.namespace, columns: Object.freeze(columns), required: Object.freeze(required), readOnly: params.readOnly === true }));
+  return source;
+}
+function makeDerived(params) {
+  const query = readState(params.query);
+  if (params.name !== undefined) {
+    identifier(params.name);
+    if (query.physicalNames.includes(params.name))
+      invalid("A read CTE cannot shadow a physical source table");
+  }
+  const columns = Object.fromEntries(query.entries.map(({ alias, expression }) => {
+    const state = expressionState(expression);
+    const decoder = state.definition?.inputDecoder ?? state.definition?.decoder ?? state.decoder;
+    const inputDecoder = "encode" in decoder && typeof decoder.encode === "function" ? decoder : undefined;
+    return [alias, Object.freeze({ ...state.definition, name: alias, decoder: state.decoder, inputDecoder, scalar: state.definition?.scalar ?? "Unknown", dbDefault: false })];
+  }));
+  const source = Object.freeze(Object.create(null));
+  sourceStates.set(source, Object.freeze({ columns: Object.freeze(columns), required: Object.freeze([]), query, cte: params.name, readOnly: true }));
+  return source;
+}
+function makeBinding(params) {
+  const state = sourceState(params.source);
+  identifier(params.alias);
+  const token = Object.freeze({});
+  const keys = Object.fromEntries(Object.keys(state.columns).map((name) => [name, Object.freeze({ binding: token, name })]));
+  return Object.freeze({ source: params.source, alias: params.alias, token, keys: Object.freeze(keys), nullable: params.nullable === true });
+}
+function bindingColumns(binding, qualified = true) {
+  const source = sourceState(binding.source);
+  return Object.freeze(Object.fromEntries(Object.entries(source.columns).map(([name, original]) => {
+    const definition = binding.nullable ? Object.freeze({ ...original, nullable: true }) : original;
+    const decoder = definition.nullable === true ? nullableDecoder(definition.decoder) : definition.decoder;
+    const readDecoder = definition.transport === "text" || definition.scalar === "Json" ? Object.freeze({ decode: (params) => decoder.decode({ ...params, wire: { ...params.wire, json: "text" } }) }) : decoder;
+    const column = binding.keys[name];
+    const render = (context) => {
+      if (definition.list === true && !context.dialect.capabilities.scalarArrays)
+        unsupported("Scalar array columns require native array support");
+      const name = context.dialect.quoteIdent({ name: definition.name });
+      return qualified ? `${context.dialect.quoteIdent({ name: binding.alias })}.${name}` : name;
+    };
+    return [name, makeExpression({
+      decoder: readDecoder,
+      render,
+      projection: (context) => transportProjection({ context, expression: render(context), definition }),
+      references: new Set([binding.token]),
+      ungrouped: new Set([column]),
+      aggregate: false,
+      column,
+      definition,
+      contract: columnContract(definition)
+    })];
+  })));
+}
+function scope(bindings) {
+  return Object.freeze(Object.fromEntries(bindings.map((binding) => [binding.alias, bindingColumns(binding)])));
+}
+function renderSource(params) {
+  const { context, binding } = params;
+  const state = sourceState(binding.source);
+  const alias = context.dialect.quoteIdent({ name: binding.alias });
+  if (state.cte !== undefined)
+    return `${context.dialect.quoteIdent({ name: state.cte })} AS ${alias}`;
+  if (state.query !== undefined)
+    return `(${state.query.render({ ...context, transport: false })}) AS ${alias}`;
+  if (state.namespace !== undefined)
+    assertSqlNamespace({ dialect: context.dialect.name, namespace: state.namespace });
+  const name = context.dialect.quoteIdent({ name: state.name });
+  return `${state.namespace === undefined ? "" : `${context.dialect.quoteIdent({ name: state.namespace })}.`}${name} AS ${alias}`;
+}
+function projectionEntries(params) {
+  const entries = Object.entries(params.projection);
+  if (entries.length === 0)
+    invalid("SELECT/RETURNING requires a non-empty explicit projection");
+  return Object.freeze(entries.map(([alias, expression]) => {
+    identifier(alias);
+    checkScope({ expression, bindings: params.bindings, aggregates: params.aggregates, nullableContracts: true });
+    return Object.freeze({ alias, expression });
+  }));
+}
+function renderEntries(params) {
+  return params.entries.map(({ alias, expression }) => {
+    const state = expressionState(expression);
+    const rendered = params.context.transport !== false && state.projection !== undefined ? state.projection(params.context) : state.render(params.context);
+    return `${rendered} AS ${params.context.dialect.quoteIdent({ name: alias })}`;
+  }).join(", ");
+}
+function projectionDecoder(entries) {
+  return Object.freeze({
+    decode: (params) => {
+      if (typeof params.value !== "object" || params.value === null || Array.isArray(params.value))
+        invalidData("SQL query decoder requires a row object");
+      const row = params.value;
+      return Object.fromEntries(entries.map(({ alias, expression }) => {
+        if (!Object.hasOwn(row, alias))
+          invalidData(`Missing SQL result alias "${alias}"`);
+        return [alias, expressionState(expression).decoder.decode({ ...params, value: row[alias] })];
+      }));
+    }
+  });
+}
+function groupKeys(expressions) {
+  return new Set(expressions.flatMap((expression) => {
+    const state = expressionState(expression);
+    return state.column === undefined ? [] : [state.column];
+  }));
+}
+
+// packages/sql/src/query/select.ts
+function count2(value) {
+  if (!Number.isSafeInteger(value) || value < 0)
+    invalid("SQL LIMIT/OFFSET must be non-negative safe integers");
+  return value;
+}
+function pageValue(value) {
+  if (isSqlParam2(value)) {
+    assertSqlParamBuilding2({ param: value });
+    return value;
+  }
+  return count2(value);
+}
+function renderPage(params) {
+  if (!isSqlParam2(params.value))
+    return String(params.value);
+  const contract = sqlParamContract2({ param: params.value });
+  if (contract.scalar !== "Int" || contract.list || contract.nullable || contract.nativeType !== undefined)
+    invalid("SQL pagination inputs require a non-null Int contract");
+  return recordSqlBinding2({
+    collector: params.context.collector,
+    source: { kind: "input", param: params.value },
+    contract,
+    transport: { kind: "plain" },
+    rejectNull: true,
+    validate: (value) => {
+      if (typeof value !== "number")
+        invalid("SQL LIMIT/OFFSET must be non-negative safe integers");
+      count2(value);
+    },
+    encode: ({ value, dialect }) => contract.encoder.encode({ value, dialect: dialect.name })
+  });
+}
+function predicate(expression, bindings, aggregates) {
+  checkScope({ expression, bindings, aggregates });
+  return expression;
+}
+function collectCtes(bindings) {
+  const ctes = [];
+  for (const binding of bindings) {
+    const state = sourceState(binding.source);
+    if (state.query !== undefined)
+      ctes.push(...state.query.ctes);
+    if (state.cte !== undefined)
+      ctes.push(binding.source);
+  }
+  const unique = [...new Set(ctes)];
+  const names = unique.map((source) => sourceState(source).cte);
+  if (new Set(names).size !== names.length)
+    invalid("Read CTE names must be unique across composed queries");
+  for (const binding of bindings) {
+    const source = sourceState(binding.source);
+    if (source.name !== undefined && source.namespace === undefined && names.includes(source.name))
+      invalid("A read CTE cannot shadow a physical source table");
+  }
+  return Object.freeze(unique);
+}
+function withCtes(params) {
+  const { state, context } = params;
+  if (state.ctes.length === 0)
+    return state.render(context);
+  const definitions = state.ctes.map((source) => {
+    const cte = sourceState(source);
+    return `${context.dialect.quoteIdent({ name: cte.cte })} AS (${cte.query.render({ ...context, transport: false })})`;
+  });
+  return `WITH ${definitions.join(", ")} ${state.render(context)}`;
+}
+function finish(state) {
+  const query = createSqlQuery({ decoder: projectionDecoder(state.entries), render: (context) => withCtes({ state, context }) });
+  readStates.set(query, Object.freeze(state));
+  builderTerminals.add(query);
+  return query;
+}
+function renderOrder(params) {
+  const { context } = params;
+  const terms = params.terms.flatMap((term) => {
+    const state = expressionState(term.expression);
+    if (state.definition?.scalar === "Decimal" && context.dialect.name === "sqlite")
+      unsupported("SQLite Decimal ordering is not exact; use an explicit raw numeric contract");
+    const expression = () => state.render(context);
+    const direction = term.direction === "desc" ? "DESC" : "ASC";
+    if (term.nulls === undefined)
+      return [`${expression()} ${direction}`];
+    if (context.dialect.orderByNullsMode === "native")
+      return [`${expression()} ${direction} NULLS ${term.nulls.toUpperCase()}`];
+    return [`(${expression()} IS NULL) ${term.nulls === "first" ? "DESC" : "ASC"}`, `${expression()} ${direction}`];
+  });
+  return terms.length === 0 ? "" : ` ORDER BY ${terms.join(", ")}`;
+}
+function select(params) {
+  const { state } = params;
+  const entries = projectionEntries({ projection: params.projection, bindings: state.bindings });
+  const groupedExpressions = [...entries.map((entry) => entry.expression), ...state.having, ...state.order.map((term) => term.expression)];
+  const aggregate = groupedExpressions.some((expression) => expressionState(expression).aggregate);
+  if (state.having.length > 0 && state.group === undefined && !aggregate)
+    invalid("HAVING requires a grouped or aggregate query");
+  if (state.group !== undefined || aggregate) {
+    const keys = groupKeys(state.group ?? []);
+    for (const expression of groupedExpressions) {
+      if (state.group?.includes(expression))
+        continue;
+      for (const key of expressionState(expression).ungrouped)
+        if (!keys.has(key))
+          invalid("Every non-aggregate projection, HAVING and ORDER expression must be grouped");
+    }
+  }
+  const ctes = collectCtes(state.bindings);
+  const physicalNames = Object.freeze([...new Set(state.bindings.flatMap((binding) => {
+    const source = sourceState(binding.source);
+    return source.query?.physicalNames ?? (source.name !== undefined && source.namespace === undefined ? [source.name] : []);
+  }))]);
+  if (ctes.some((source) => physicalNames.includes(sourceState(source).cte)))
+    invalid("A read CTE cannot shadow a physical source table");
+  const distinct = params.distinct === true;
+  const distinctEntries = distinct ? entries.map(({ alias, expression }) => {
+    const original = expressionState(expression);
+    const render = (context) => `${context.dialect.quoteIdent({ name: "__vibe_distinct" })}.${context.dialect.quoteIdent({ name: alias })}`;
+    return { alias, expression: makeExpression({ ...original, render, projection: original.definition === undefined ? undefined : (context) => transportProjection({ context, expression: render(context), definition: original.definition }) }) };
+  }) : entries;
+  const distinctOrder = distinct ? state.order.map((term) => {
+    const ordered = expressionState(term.expression);
+    const index = entries.findIndex((entry) => entry.expression === term.expression || ordered.column !== undefined && expressionState(entry.expression).column === ordered.column);
+    if (index < 0)
+      invalid("DISTINCT ordering must use a selected column or the same selected expression");
+    return { ...term, expression: distinctEntries[index].expression };
+  }) : state.order;
+  return finish({ entries, ctes, physicalNames, render: (context) => {
+    const columns = renderEntries({ entries, context: distinct ? { ...context, transport: false } : context });
+    const from = renderSource({ context, binding: state.bindings[0] });
+    const joins = state.joins.map((join) => ` ${join.kind} JOIN ${renderSource({ context, binding: join.binding })}${join.on === undefined ? "" : ` ON ${expressionState(join.on).render(context)}`}`).join("");
+    const where = state.where.length === 0 ? "" : ` WHERE ${state.where.map((expression) => expressionState(expression).render(context)).join(" AND ")}`;
+    const group = state.group === undefined || state.group.length === 0 ? "" : ` GROUP BY ${state.group.map((expression) => expressionState(expression).render(context)).join(", ")}`;
+    const having = state.having.length === 0 ? "" : ` HAVING ${state.having.map((expression) => expressionState(expression).render(context)).join(" AND ")}`;
+    const order = renderOrder({ terms: distinctOrder, context });
+    const limit = state.limit === undefined ? state.offset === undefined || context.dialect.offsetRequiresLimit === null ? "" : ` LIMIT ${context.dialect.offsetRequiresLimit.limitText}` : ` LIMIT ${renderPage({ value: state.limit, context })}`;
+    const offset = state.offset === undefined ? "" : ` OFFSET ${renderPage({ value: state.offset, context })}`;
+    const native = `SELECT ${distinct ? "DISTINCT " : ""}${columns} FROM ${from}${joins}${where}${group}${having}`;
+    const query = distinct ? `SELECT ${renderEntries({ entries: distinctEntries, context })} FROM (${native}) AS ${context.dialect.quoteIdent({ name: "__vibe_distinct" })}` : native;
+    return `${query}${order}${limit}${offset}`;
+  } });
+}
+function builder(state) {
+  const addJoin = (params) => {
+    if (state.bindings.some((binding) => binding.alias === params.as))
+      invalid("SQL source aliases must be unique within a SELECT");
+    const joined = makeBinding({ source: params.source, alias: params.as });
+    const onBindings = [...state.bindings, joined];
+    const on = params.kind === "CROSS" ? undefined : predicate(params.on(scope(onBindings)), onBindings, false);
+    const output = params.kind === "LEFT" ? Object.freeze({ ...joined, nullable: true }) : joined;
+    return builder({ ...state, bindings: Object.freeze([...state.bindings, output]), joins: Object.freeze([...state.joins, Object.freeze({ binding: output, kind: params.kind, on })]) });
+  };
+  return Object.freeze({
+    innerJoin: (params) => addJoin({ ...params, kind: "INNER" }),
+    leftJoin: (params) => addJoin({ ...params, kind: "LEFT" }),
+    crossJoin: (params) => addJoin({ ...params, kind: "CROSS" }),
+    where: (callback) => {
+      if (typeof callback !== "function")
+        invalid("SQL WHERE requires a callback");
+      return builder({ ...state, where: Object.freeze([...state.where, predicate(callback(scope(state.bindings)), state.bindings, false)]) });
+    },
+    groupBy: (callback) => {
+      if (typeof callback !== "function")
+        invalid("SQL GROUP BY requires a callback");
+      const expressions = [...callback(scope(state.bindings))];
+      for (const expression of expressions)
+        checkScope({ expression, bindings: state.bindings, aggregates: false });
+      return builder({ ...state, group: Object.freeze(expressions) });
+    },
+    having: (callback) => {
+      if (typeof callback !== "function")
+        invalid("SQL HAVING requires a callback");
+      return builder({ ...state, having: Object.freeze([...state.having, predicate(callback(scope(state.bindings)), state.bindings, true)]) });
+    },
+    orderBy: (callback) => {
+      if (typeof callback !== "function")
+        invalid("SQL ORDER BY requires a callback");
+      const terms = callback(scope(state.bindings)).map((term) => {
+        checkScope({ expression: term.expression, bindings: state.bindings });
+        if (term.direction !== undefined && term.direction !== "asc" && term.direction !== "desc")
+          invalid("SQL order direction must be asc or desc");
+        if (term.nulls !== undefined && term.nulls !== "first" && term.nulls !== "last")
+          invalid("SQL null ordering must be first or last");
+        return Object.freeze({ ...term });
+      });
+      return builder({ ...state, order: Object.freeze([...state.order, ...terms]) });
+    },
+    limit: (value) => builder({ ...state, limit: pageValue(value) }),
+    offset: (value) => builder({ ...state, offset: pageValue(value) }),
+    select: (callback, options) => {
+      if (typeof callback !== "function")
+        invalid("SQL SELECT requires a callback");
+      return select({ state, projection: callback(scope(state.bindings)), distinct: options?.distinct });
+    }
+  });
+}
+function from(params) {
+  const binding = makeBinding({ source: params.source, alias: params.as });
+  return builder({ bindings: Object.freeze([binding]), joins: Object.freeze([]), where: Object.freeze([]), having: Object.freeze([]), order: Object.freeze([]) });
+}
+function union(params) {
+  if (!Array.isArray(params.queries) || params.queries.length < 2)
+    invalid("UNION requires at least two builder read queries");
+  const all = params.all === true;
+  const branches = params.queries.map(readState);
+  const first = branches[0];
+  for (const branch of branches.slice(1)) {
+    if (branch.entries.length !== first.entries.length)
+      invalid("UNION branches must expose the same aliases and result contracts");
+    for (const expected of first.entries) {
+      const other = branch.entries.find((entry) => entry.alias === expected.alias);
+      if (other === undefined)
+        invalid("UNION branches must expose the same aliases");
+      const left = expressionState(expected.expression);
+      const right = expressionState(other.expression);
+      const leftDecoder = left.definition?.decoder ?? left.decoder;
+      const rightDecoder = right.definition?.decoder ?? right.decoder;
+      if (left.contract !== right.contract || !sameResultDecoder({ left: leftDecoder, right: rightDecoder }))
+        invalid("UNION output decoders, physical types and nullability must match by alias");
+    }
+  }
+  const ctes = [...new Set(branches.flatMap((branch) => [...branch.ctes]))];
+  const names = ctes.map((source) => sourceState(source).cte);
+  if (new Set(names).size !== names.length)
+    invalid("UNION read CTE names must be unique");
+  if (names.some((name) => branches.some((branch) => branch.physicalNames.includes(name))))
+    invalid("A UNION read CTE cannot shadow a physical source table");
+  const entries = first.entries.map(({ alias, expression }) => {
+    identifier(alias);
+    const original = expressionState(expression);
+    return { alias, expression: makeExpression({ ...original, references: new Set, ungrouped: new Set, aggregate: false, column: undefined, render: (context) => `${context.dialect.quoteIdent({ name: "__vibe_union" })}.${context.dialect.quoteIdent({ name: alias })}`, projection: original.definition === undefined ? undefined : (context) => transportProjection({ context, expression: `${context.dialect.quoteIdent({ name: "__vibe_union" })}.${context.dialect.quoteIdent({ name: alias })}`, definition: original.definition }) }) };
+  });
+  const state = {
+    entries,
+    ctes: Object.freeze(ctes),
+    physicalNames: Object.freeze([...new Set(branches.flatMap((branch) => [...branch.physicalNames]))]),
+    render: (context) => {
+      const rendered = branches.map((branch, index) => {
+        const alias = context.dialect.quoteIdent({ name: `__vibe_branch_${index}` });
+        const columns = first.entries.map((entry) => `${alias}.${context.dialect.quoteIdent({ name: entry.alias })}`).join(", ");
+        return `SELECT ${columns} FROM (${branch.render({ ...context, transport: false })}) AS ${alias}`;
+      }).join(all ? " UNION ALL " : " UNION ");
+      return `SELECT ${renderEntries({ entries, context })} FROM (${rendered}) AS ${context.dialect.quoteIdent({ name: "__vibe_union" })}`;
+    }
+  };
+  return finish(state);
+}
+
+// packages/sql/src/query/mutations.ts
+import { assertSqlNamespace as assertSqlNamespace2 } from "@vibeorm/schema";
+import { assertSqlParamBuilding as assertSqlParamBuilding3, createSqlCommand, createSqlQuery as createSqlQuery2, decode as decode2, isSqlParam as isSqlParam3, snapshotSqlValue as snapshotSqlValue2 } from "@vibeorm/sql";
+var sqlDefault = makeExpression({ decoder: decode2.json, contract: "sql-default", references: new Set, ungrouped: new Set, aggregate: false, default: true, render: () => "DEFAULT" });
+function tableBinding(table) {
+  const state = sourceState(table);
+  if (state.readOnly === true || state.query !== undefined || state.name === undefined)
+    invalid("SQL writes require a writable physical table; views and read sources cannot be mutated");
+  return makeBinding({ source: table, alias: "__vibe_write" });
+}
+function cells(params) {
+  if (typeof params.value !== "object" || params.value === null || Array.isArray(params.value))
+    invalid("SQL write rows must be field objects");
+  const table = sourceState(params.binding.source);
+  const row = params.value;
+  for (const name of Object.keys(row))
+    if (!Object.hasOwn(table.columns, name))
+      invalid(`Unknown SQL write field "${name}"`);
+  return Object.freeze(Object.keys(table.columns).filter((name) => Object.hasOwn(row, name)).map((name) => {
+    const value = row[name];
+    if (isSqlParam3(value)) {
+      assertSqlParamBuilding3({ param: value });
+      return Object.freeze({ name, value });
+    }
+    if (typeof value === "object" && value !== null && expressionStates.has(value)) {
+      const expression = value;
+      const state = expressionState(expression);
+      if (state.default === true) {
+        if (table.columns[name].dbDefault !== true || table.required.includes(name))
+          invalid(`SQL DEFAULT requires a physical database default on "${name}"`);
+      } else
+        checkScope({ expression, bindings: [params.binding], aggregates: false });
+      return Object.freeze({ name, value: undefined, expression });
+    }
+    return Object.freeze({ name, value: snapshotSqlValue2(value) });
+  }));
+}
+function physicalTable(context, binding) {
+  const table = sourceState(binding.source);
+  if (table.namespace !== undefined)
+    assertSqlNamespace2({ namespace: table.namespace, dialect: context.dialect.name });
+  return `${table.namespace === undefined ? "" : `${context.dialect.quoteIdent({ name: table.namespace })}.`}${context.dialect.quoteIdent({ name: table.name })}`;
+}
+function renderCell(params) {
+  const definition = sourceState(params.state.binding.source).columns[params.cell.name];
+  if (params.cell.expression !== undefined) {
+    const expression = expressionState(params.cell.expression);
+    if (expression.default === true && params.state.kind === "insert" && !params.context.dialect.rowDefaultKeyword)
+      unsupported("This dialect cannot render SQL DEFAULT in VALUES cells; omit the defaulted column");
+    if (expression.default === true && params.state.kind === "update" && !params.context.dialect.rowDefaultKeyword)
+      unsupported("This dialect cannot render SQL DEFAULT in UPDATE assignments");
+    if (expression.parameter !== undefined)
+      return bindColumnValue({ context: params.context, definition, encoder: expression.parameter.decoder, value: expression.parameter.value });
+    return expression.render(params.context);
+  }
+  return bindColumnValue({ context: params.context, definition, value: params.cell.value });
+}
+function renderWrite(params) {
+  const { state, context } = params;
+  const table = physicalTable(context, state.binding);
+  const alias = context.dialect.quoteIdent({ name: state.binding.alias });
+  if (state.kind === "insert") {
+    const rows = state.rows;
+    const fields = rows[0];
+    if (fields.length === 0) {
+      if (rows.length > 1)
+        unsupported("Multiple all-default insert rows cannot preserve one portable statement");
+      return context.dialect.name === "mysql" ? `INSERT INTO ${table} () VALUES ()` : `INSERT INTO ${table} DEFAULT VALUES`;
+    }
+    const definitions = sourceState(state.binding.source).columns;
+    const columns = fields.map((cell) => context.dialect.quoteIdent({ name: definitions[cell.name].name })).join(", ");
+    const values = rows.map((row) => `(${row.map((cell) => renderCell({ cell, state, context })).join(", ")})`).join(", ");
+    return `INSERT INTO ${table} (${columns}) VALUES ${values}`;
+  }
+  const where = () => state.where.length === 0 ? "" : ` WHERE ${state.where.map((expression) => expressionState(expression).render(context)).join(" AND ")}`;
+  if (state.kind === "delete")
+    return `DELETE FROM ${table} AS ${alias}${where()}`;
+  const definitions = sourceState(state.binding.source).columns;
+  const set = state.set.map((cell) => `${context.dialect.quoteIdent({ name: definitions[cell.name].name })} = ${renderCell({ cell, state, context })}`).join(", ");
+  return `UPDATE ${table} AS ${alias} SET ${set}${where()}`;
+}
+function mutation(state) {
+  return Object.freeze({
+    where: (callback) => {
+      if (state.kind === "insert")
+        invalid("INSERT does not accept WHERE");
+      if (typeof callback !== "function")
+        invalid("SQL WHERE requires a callback");
+      const expression = callback(bindingColumns(state.binding));
+      checkScope({ expression, bindings: [state.binding], aggregates: false });
+      return mutation({ ...state, where: Object.freeze([...state.where, expression]) });
+    },
+    command: () => {
+      const query = createSqlCommand({ render: (context) => renderWrite({ state, context }) });
+      builderTerminals.add(query);
+      return query;
+    },
+    returning: (callback) => {
+      if (typeof callback !== "function")
+        invalid("SQL RETURNING requires a callback");
+      const entries = projectionEntries({ projection: callback(bindingColumns(state.binding, false)), bindings: [state.binding], aggregates: false });
+      const query = createSqlQuery2({ decoder: projectionDecoder(entries), render: (context) => {
+        if (!context.dialect.capabilities.returning)
+          unsupported("This dialect does not support native RETURNING; use a command instead");
+        return `${renderWrite({ state, context })} RETURNING ${renderEntries({ entries, context })}`;
+      } });
+      builderTerminals.add(query);
+      return query;
+    }
+  });
+}
+function insert(params) {
+  const binding = tableBinding(params.into);
+  const table = sourceState(params.into);
+  const values = Array.isArray(params.values) ? params.values : [params.values];
+  if (values.length === 0)
+    invalid("INSERT requires at least one row");
+  const rows = values.map((value) => cells({ value, binding }));
+  for (const row of rows) {
+    const names = row.map((cell) => cell.name);
+    if (table.required.some((name) => !names.includes(name)))
+      invalid("INSERT is missing a required physical column; application defaults are not generated");
+    if (names.length !== rows[0].length || names.some((name, index) => name !== rows[0][index].name))
+      invalid("Batch INSERT rows must have one homogeneous field set; statements are never split implicitly");
+    for (const cell of row)
+      if (cell.expression !== undefined && expressionState(cell.expression).references.size > 0)
+        invalid("INSERT values cannot reference the target table");
+  }
+  return mutation({ binding, kind: "insert", rows: Object.freeze(rows), where: Object.freeze([]) });
+}
+function update(params) {
+  const binding = tableBinding(params.table);
+  const set = cells({ value: params.set, binding });
+  if (set.length === 0)
+    invalid("UPDATE requires at least one assignment");
+  return mutation({ binding, kind: "update", set, where: Object.freeze([]) });
+}
+function deleteRows(params) {
+  return mutation({ binding: tableBinding(params.table), kind: "delete", where: Object.freeze([]) });
+}
+
+// packages/sql/src/query/reusable.ts
+import { createReusableSqlCommand, createReusableSqlQuery, createSqlInput, createSqlInputScope, isSqlCommand, isSqlQuery, sealSqlInputScope } from "@vibeorm/sql";
+var columnInputs = new WeakMap;
+function input(params) {
+  const table = sourceState(params.table);
+  if (table.readOnly || table.query !== undefined || table.name === undefined)
+    invalid("qb.input requires a writable physical table");
+  if (!Object.hasOwn(table.columns, params.column))
+    invalid("SQL input column does not belong to its table");
+  const definition = table.columns[params.column];
+  let descriptor = columnInputs.get(definition);
+  if (descriptor === undefined) {
+    descriptor = createSqlInput({ contract: { ...columnInputContract(definition), columnIdentity: definition } });
+    columnInputs.set(definition, descriptor);
+  }
+  return descriptor;
+}
+function builderHandle(value) {
+  return expressionStates.has(value) || sourceStates.has(value);
+}
+function reusable(params) {
+  if (typeof params.build !== "function")
+    invalid("Reusable SQL requires a synchronous builder callback");
+  const environment = createSqlInputScope({ inputs: params.params, isHandle: builderHandle });
+  let query;
+  try {
+    query = params.build(environment.params);
+  } finally {
+    sealSqlInputScope({ scope: environment.scope });
+  }
+  if (typeof query !== "object" || query === null || !builderTerminals.has(query))
+    invalid("Reusable SQL requires an ordinary builder query or command terminal");
+  if (isSqlQuery(query))
+    return createReusableSqlQuery({ query, scope: environment.scope });
+  if (isSqlCommand(query))
+    return createReusableSqlCommand({ query, scope: environment.scope });
+  return invalid("Reusable SQL requires an ordinary builder query or command terminal");
+}
+
+// packages/sql/src/query/index.ts
+var qb = Object.freeze({
+  input,
+  reusable,
+  table: makeTable,
+  from,
+  derived: (params) => makeDerived(params),
+  cte: (params) => makeDerived(params),
+  union,
+  insert,
+  update,
+  delete: deleteRows,
+  default: sqlDefault,
+  value: literal,
+  raw: rawExpression
+});
+export {
+  and,
+  avg,
+  count,
+  eq,
+  gt,
+  gte,
+  inList,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  max,
+  min,
+  ne,
+  not,
+  notInList,
+  or,
+  qb,
+  sum
+};
+
+//# debugId=B60163A02807B75F64756E2164756E21