@vibeorm/sql 3.0.0 → 4.0.0

package/dist/index.js

@@ -39,33 +39,870 @@ function renderExternalOwnershipCatalog(params) {
   return { text, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/external-dependents.ts
+import { unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
+
+// packages/sql/src/params.ts
 import { unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
 
+// packages/sql/src/sql-bindings.ts
+import { VibeError as VibeError5, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
+
+// packages/sql/src/parameter-snapshot.ts
+import { VibeError as VibeError4 } from "@vibeorm/schema";
+
+// packages/sql/src/sql-input.ts
+import { VibeError as VibeError3 } from "@vibeorm/schema";
+
+// packages/sql/src/result-decoder.ts
+import { VibeError as VibeError2 } from "@vibeorm/schema";
+
+// packages/sql/src/pg-array.ts
+var PG_ARRAY_QUOTE = /^$|^NULL$|[{},"\\\s]/i;
+function toPgArrayLiteral(params) {
+  const { values } = params;
+  const parts = values.map((value) => {
+    if (value === null || value === undefined)
+      return "NULL";
+    const text = String(value);
+    return PG_ARRAY_QUOTE.test(text) ? `"${text.replace(/["\\]/g, (char) => `\\${char}`)}"` : text;
+  });
+  return `{${parts.join(",")}}`;
+}
+function parsePgArrayLiteral(params) {
+  const literal = params.literal.startsWith("[") ? params.literal.replace(/^\[-?\d+:-?\d+\]=/, "") : params.literal;
+  if (literal.length < 2 || !literal.startsWith("{") || !literal.endsWith("}"))
+    return null;
+  const inner = literal.slice(1, -1);
+  if (inner.length === 0)
+    return [];
+  const out = [];
+  let index = 0;
+  while (index < inner.length) {
+    if (inner[index] === '"') {
+      let text = "";
+      index++;
+      while (index < inner.length) {
+        const char = inner[index];
+        if (char === "\\") {
+          text += inner[index + 1] ?? "";
+          index += 2;
+          continue;
+        }
+        index++;
+        if (char === '"')
+          break;
+        text += char;
+      }
+      out.push(text);
+    } else {
+      let text = "";
+      while (index < inner.length && inner[index] !== ",") {
+        text += inner[index];
+        index++;
+      }
+      out.push(text === "NULL" ? null : text);
+    }
+    if (inner[index] === ",")
+      index++;
+  }
+  return out;
+}
+function parsePgArrayLiteralNested(params) {
+  const text = params.literal.replace(/^(?:\[-?\d+:-?\d+\])+=/, "");
+  const cursor = { index: 0 };
+  const parsed = parseDimension({ text, cursor });
+  return parsed !== null && cursor.index === text.length ? parsed : null;
+}
+function parseDimension(params) {
+  const { text, cursor } = params;
+  if (text[cursor.index] !== "{")
+    return null;
+  cursor.index++;
+  const out = [];
+  if (text[cursor.index] === "}") {
+    cursor.index++;
+    return out;
+  }
+  while (cursor.index < text.length) {
+    if (text[cursor.index] === "{") {
+      const nested = parseDimension({ text, cursor });
+      if (nested === null)
+        return null;
+      out.push(nested);
+    } else if (text[cursor.index] === '"') {
+      let element = "";
+      cursor.index++;
+      while (cursor.index < text.length && text[cursor.index] !== '"') {
+        if (text[cursor.index] === "\\")
+          cursor.index++;
+        element += text[cursor.index] ?? "";
+        cursor.index++;
+      }
+      if (text[cursor.index] !== '"')
+        return null;
+      cursor.index++;
+      out.push(element);
+    } else {
+      let element = "";
+      while (cursor.index < text.length && text[cursor.index] !== "," && text[cursor.index] !== "}") {
+        element += text[cursor.index];
+        cursor.index++;
+      }
+      out.push(element === "NULL" ? null : element);
+    }
+    if (text[cursor.index] === ",") {
+      cursor.index++;
+      continue;
+    }
+    if (text[cursor.index] !== "}")
+      return null;
+    cursor.index++;
+    return out;
+  }
+  return null;
+}
+
+// packages/sql/src/codecs.ts
+import { VibeError, invalidStoredData, timeOfDayType } from "@vibeorm/schema";
+function enumMembershipCodec(params) {
+  const { model, field, enum: enumName } = params;
+  const members = new Set(params.members);
+  return {
+    encode: (value) => {
+      if (typeof value === "string" && members.has(value))
+        return value;
+      throw new VibeError({
+        code: "VIBE_VALIDATION",
+        message: `Invalid value for enum ${enumName} on ${model}.${field}`,
+        meta: { model, field, enum: enumName }
+      });
+    },
+    decode: (value) => {
+      if (typeof value === "string" && members.has(value))
+        return value;
+      throw invalidStoredData({ model, field, enum: enumName, value });
+    }
+  };
+}
+function decodeIsNoop(params) {
+  const { scalarType, wire } = params;
+  if (wire === undefined)
+    return false;
+  if (scalarType === "DateTime")
+    return false;
+  if (scalarType === "Json")
+    return wire.json === "parsed";
+  if (scalarType === "Int" || scalarType === "Float")
+    return wire.numbers === "native";
+  return false;
+}
+var identity = (value) => value;
+var passthroughCodec = { encode: identity, decode: identity };
+var numberCodec = {
+  encode: identity,
+  decode: (value) => typeof value === "string" ? Number(value) : value
+};
+var bigIntCodec = {
+  encode: (value) => typeof value === "bigint" ? value.toString() : value,
+  decode: (value) => {
+    if (typeof value === "bigint")
+      return value;
+    if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim()))
+      return BigInt(value.trim());
+    if (typeof value === "number" && Number.isSafeInteger(value))
+      return BigInt(value);
+    throw new VibeError({ code: "VIBE_DATA_INVALID", message: "BigInt requires an integer string or a safe integer", meta: { value } });
+  }
+};
+var decimalCodec = {
+  encode: (value) => typeof value === "number" || typeof value === "bigint" ? String(value) : value,
+  decode: identity
+};
+var mysqlDecimalCodec = {
+  encode: decimalCodec.encode,
+  decode: (value) => {
+    if (typeof value !== "string" || !value.includes("."))
+      return value;
+    const trimmed = value.replace(/0+$/, "").replace(/\.$/, "");
+    return trimmed === "" || trimmed === "-" ? "0" : trimmed;
+  }
+};
+var ZONE_LESS_DATETIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/;
+var PG_ZONED_DATETIME = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?)(\.\d{1,9})?([+-]\d{2})(?::?(\d{2}))?$/;
+function parseDateTimeText(params) {
+  const trimmed = params.text.trim();
+  if (ZONE_LESS_DATETIME.test(trimmed)) {
+    const asUtc = new Date(`${trimmed.replace(" ", "T").replace(/(\.\d{3})\d+$/, "$1")}Z`);
+    if (!Number.isNaN(asUtc.getTime()))
+      return asUtc;
+  }
+  const zoned = PG_ZONED_DATETIME.exec(trimmed);
+  if (zoned !== null) {
+    const [, date, time, fraction, hours, minutes] = zoned;
+    const iso = new Date(`${date}T${time}${(fraction ?? "").slice(0, 4)}${hours}:${minutes ?? "00"}`);
+    if (!Number.isNaN(iso.getTime()))
+      return iso;
+  }
+  const parsed = new Date(trimmed);
+  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
+var dateNativeCodec = {
+  encode: (value) => {
+    if (value instanceof Date && !Number.isFinite(value.getTime()) || typeof value === "number" && !Number.isFinite(value) || typeof value === "string" && /^[+-]?infinity$/i.test(value.trim())) {
+      throw new VibeError({ code: "VIBE_VALIDATION", message: "DateTime parameters require finite timestamps; use an extended timestamp encoder for infinity" });
+    }
+    return value;
+  },
+  decode: (value) => {
+    const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
+    if (date !== undefined && Number.isFinite(date.getTime()))
+      return date;
+    throw new VibeError({ code: "VIBE_DATA_INVALID", message: "DateTime requires a finite timestamp; use an explicit extended timestamp decoder for infinity" });
+  }
+};
+var dateTextCodec = {
+  encode: (value) => {
+    dateNativeCodec.encode(value);
+    const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
+    if (date !== undefined && Number.isFinite(date.getTime()))
+      return date.toISOString();
+    throw new VibeError({ code: "VIBE_VALIDATION", message: "DateTime parameters require a valid finite timestamp" });
+  },
+  decode: dateNativeCodec.decode
+};
+var mysqlDateCodec = {
+  encode: (value) => {
+    dateNativeCodec.encode(value);
+    if (value instanceof Date)
+      return value;
+    if (typeof value === "number") {
+      const parsed = new Date(value);
+      if (!Number.isNaN(parsed.getTime()))
+        return parsed;
+      return value;
+    }
+    if (typeof value === "string")
+      return parseDateTimeText({ text: value }) ?? value;
+    return value;
+  },
+  decode: dateNativeCodec.decode
+};
+var MILLISECONDS_PER_DAY = 86400000;
+var TIME_OF_DAY_TEXT = /^(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?(?:([+-])(\d{2})(?::?(\d{2}))?(?::?(\d{2}))?)?$/;
+var pad = (value, width) => String(value).padStart(width, "0");
+var utcMillisecondOfDay = (date) => (date.getTime() % MILLISECONDS_PER_DAY + MILLISECONDS_PER_DAY) % MILLISECONDS_PER_DAY;
+var timeOfDayText = (millisecond) => `${pad(Math.floor(millisecond / 3600000), 2)}:${pad(Math.floor(millisecond / 60000) % 60, 2)}:${pad(Math.floor(millisecond / 1000) % 60, 2)}.${pad(millisecond % 1000, 3)}`;
+function makeTimeOfDayCodec(params) {
+  const suffix = params.zoned ? "+00" : "";
+  return Object.freeze({
+    encode: (value) => {
+      dateNativeCodec.encode(value);
+      const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
+      if (date === undefined || !Number.isFinite(date.getTime())) {
+        throw new VibeError({ code: "VIBE_VALIDATION", message: "a time-of-day DateTime parameter requires a valid finite Date", meta: { value } });
+      }
+      return `${timeOfDayText(utcMillisecondOfDay(date))}${suffix}`;
+    },
+    decode: (value) => {
+      if (value instanceof Date && Number.isFinite(value.getTime()))
+        return new Date(utcMillisecondOfDay(value));
+      const match = typeof value === "string" ? TIME_OF_DAY_TEXT.exec(value.trim()) : null;
+      if (match !== null) {
+        const [, hours, minutes, seconds, fraction, sign, offsetHours, offsetMinutes, offsetSeconds] = match;
+        const millisecond = Number(hours) * 3600000 + Number(minutes) * 60000 + Number(seconds ?? 0) * 1000 + Number((fraction ?? "").slice(0, 3).padEnd(3, "0"));
+        const offset = sign === undefined ? 0 : (sign === "-" ? -1 : 1) * (Number(offsetHours) * 3600000 + Number(offsetMinutes ?? 0) * 60000 + Number(offsetSeconds ?? 0) * 1000);
+        if (millisecond <= MILLISECONDS_PER_DAY) {
+          return new Date(((millisecond - offset) % MILLISECONDS_PER_DAY + MILLISECONDS_PER_DAY) % MILLISECONDS_PER_DAY);
+        }
+      }
+      throw new VibeError({ code: "VIBE_DATA_INVALID", message: "a time-of-day DateTime column returned a value that is not a time of day", meta: { value } });
+    }
+  });
+}
+var timeCodec = makeTimeOfDayCodec({ zoned: false });
+var timetzCodec = makeTimeOfDayCodec({ zoned: true });
+function timeOfDayCodec(params) {
+  const type = timeOfDayType({ nativeType: params.nativeType });
+  return type === "timetz" ? timetzCodec : type === "time" ? timeCodec : undefined;
+}
+var booleanIntCodec = {
+  encode: (value) => typeof value === "boolean" ? value ? 1 : 0 : value,
+  decode: (value) => typeof value === "number" ? value !== 0 : value
+};
+var booleanNativeInCodec = {
+  encode: identity,
+  decode: (value) => value === "0" ? false : value === "1" ? true : booleanIntCodec.decode(value)
+};
+function parseJsonText(params) {
+  const { text, context } = params;
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    if (context !== undefined) {
+      throw new VibeError({
+        code: "VIBE_INTERNAL",
+        message: "a bound Json field returned text that is not valid JSON",
+        meta: { ...context }
+      });
+    }
+    throw new VibeError({
+      code: "VIBE_INTERNAL",
+      message: "a Json column returned text that is not valid JSON",
+      meta: { value: text },
+      cause
+    });
+  }
+}
+var jsonCodec = {
+  encode: (value) => JSON.stringify(value),
+  decode: (value) => {
+    if (typeof value !== "string")
+      return value;
+    return parseJsonText({ text: value });
+  }
+};
+function shortestFloat32(params) {
+  const { value } = params;
+  if (value === 0 || !Number.isFinite(value))
+    return value;
+  const target = Math.fround(value);
+  for (let precision = 1;precision <= 9; precision++) {
+    const candidate = Number(value.toPrecision(precision));
+    if (Math.fround(candidate) === target)
+      return candidate;
+  }
+  return value;
+}
+var float32Codec = {
+  encode: identity,
+  decode: (value) => {
+    const number = typeof value === "string" ? Number(value) : value;
+    return typeof number === "number" ? shortestFloat32({ value: number }) : number;
+  }
+};
+var booleanFromText = (text) => text === "t" ? true : text === "f" ? false : text;
+var bytesFromText = (text) => /^\\x(?:[0-9a-fA-F]{2})*$/.test(text) ? new Uint8Array(Buffer.from(text.slice(2), "hex")) : text;
+function postgresArrayElementFromText(params) {
+  switch (params.scalarType) {
+    case "Boolean":
+      return booleanFromText;
+    case "Bytes":
+      return bytesFromText;
+    case "Json":
+      return jsonCodec.decode;
+    default:
+      return null;
+  }
+}
+var POSTGRES_CODECS = {
+  String: passthroughCodec,
+  Boolean: passthroughCodec,
+  Int: numberCodec,
+  BigInt: bigIntCodec,
+  Float: numberCodec,
+  Decimal: decimalCodec,
+  DateTime: dateNativeCodec,
+  Json: jsonCodec,
+  Bytes: passthroughCodec
+};
+var SQLITE_CODECS = {
+  String: passthroughCodec,
+  Boolean: booleanIntCodec,
+  Int: numberCodec,
+  BigInt: bigIntCodec,
+  Float: numberCodec,
+  Decimal: decimalCodec,
+  DateTime: dateTextCodec,
+  Json: jsonCodec,
+  Bytes: passthroughCodec
+};
+var MYSQL_CODECS = {
+  String: passthroughCodec,
+  Boolean: booleanNativeInCodec,
+  Int: numberCodec,
+  BigInt: bigIntCodec,
+  Float: numberCodec,
+  Decimal: mysqlDecimalCodec,
+  DateTime: mysqlDateCodec,
+  Json: jsonCodec,
+  Bytes: passthroughCodec
+};
+var DIALECT_CODECS = {
+  postgres: POSTGRES_CODECS,
+  sqlite: SQLITE_CODECS,
+  mysql: MYSQL_CODECS
+};
+
+// packages/sql/src/result-decoder.ts
+var scalarContracts = new WeakMap;
+function resultScalarContract(params) {
+  return scalarContracts.get(params.decoder);
+}
+function registerScalar(params) {
+  if (params.contract !== undefined)
+    scalarContracts.set(params.decoder, Object.freeze(params.contract));
+  return params.decoder;
+}
+function wrappedContract(params) {
+  const contract = scalarContracts.get(params.decoder);
+  if (contract === undefined || params.list === true && contract.list)
+    return;
+  return { ...contract, ...params.list === true ? { list: true, nullable: false } : {}, ...params.nullable === true ? { nullable: true } : {} };
+}
+function refuse(encoding, message) {
+  throw new VibeError2({ code: encoding ? "VIBE_VALIDATION" : "VIBE_DATA_INVALID", message });
+}
+function scalar(type, valid) {
+  const convert = (params, encoding) => {
+    const { value, dialect } = params;
+    if (value === null || value === undefined)
+      refuse(encoding, `A non-null ${type} projection received null or a missing column`);
+    if (type === "BigInt" && !(typeof value === "bigint" || typeof value === "string" && /^[+-]?\d+$/.test(value) || typeof value === "number" && Number.isSafeInteger(value))) {
+      refuse(encoding, "BigInt requires exact integer text, bigint, or a safe integer");
+    }
+    if (type === "Boolean" && value !== true && value !== false && value !== 0 && value !== 1 && !(!encoding && dialect === "mysql" && (value === "0" || value === "1")))
+      refuse(encoding, "Boolean requires true, false, 0, or 1");
+    if (type === "Decimal" && typeof value === "number")
+      refuse(encoding, "Decimal requires exact decimal text, not a floating-point number");
+    if ((type === "Int" || type === "Float") && typeof value === "string" && !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value)) {
+      refuse(encoding, `Invalid ${type} text`);
+    }
+    const codec = DIALECT_CODECS[dialect][type];
+    const result = type === "Json" && params.wire?.json === "parsed" ? value : codec.decode(value);
+    if (!valid(result))
+      refuse(encoding, `Invalid ${type} projection value`);
+    return result;
+  };
+  return registerScalar({ contract: { scalar: type, nullable: false, list: false }, decoder: Object.freeze({
+    decode: (params) => convert(params, false),
+    encode: (params) => {
+      const value = type === "Json" ? params.value : convert(params, true);
+      if (value === undefined || value === null)
+        refuse(true, `A non-null ${type} parameter cannot be null or undefined`);
+      return DIALECT_CODECS[params.dialect][type].encode(value);
+    }
+  }) });
+}
+var stringDecoder = scalar("String", (value) => typeof value === "string");
+var dateDecoder = scalar("DateTime", (value) => value instanceof Date && Number.isFinite(value.getTime()));
+var extendedDecoder = registerScalar({ contract: { scalar: "DateTime", nullable: false, list: false }, decoder: Object.freeze({
+  decode: (params) => {
+    if (params.value === "infinity" || params.value === Infinity)
+      return "infinity";
+    if (params.value === "-infinity" || params.value === -Infinity)
+      return "-infinity";
+    return dateDecoder.decode(params);
+  },
+  encode: (params) => {
+    if (params.value === "infinity" || params.value === "-infinity") {
+      if (params.dialect !== "postgres")
+        throw new VibeError2({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Timestamp infinity parameters require PostgreSQL" });
+      return params.value;
+    }
+    return dateDecoder.encode(params);
+  }
+}) });
+function hasEncoder(decoder) {
+  return "encode" in decoder && typeof decoder.encode === "function";
+}
+function nullable({ decoder }) {
+  const read = (params) => params.value === null ? null : decoder.decode(params);
+  if (!hasEncoder(decoder))
+    return Object.freeze({ decode: read });
+  return registerScalar({ contract: wrappedContract({ decoder, nullable: true }), decoder: Object.freeze({
+    decode: read,
+    encode: (params) => params.value === null ? null : decoder.encode(params)
+  }) });
+}
+function array({ decoder }) {
+  const bidirectional = hasEncoder(decoder);
+  const read = (params) => {
+    const raw = params.value;
+    let value;
+    if (params.dialect === "postgres" && typeof raw === "string") {
+      if (bidirectional)
+        value = parsePgArrayLiteral({ literal: raw });
+      else {
+        const elements = parsePgArrayLiteralNested({ literal: raw });
+        if (elements !== null && elements.some((element) => Array.isArray(element)))
+          refuse(false, "Read-only array decoders support one-dimensional SQL arrays only");
+        value = elements;
+      }
+    } else
+      value = ArrayBuffer.isView(raw) && "length" in raw ? Array.from(raw) : raw;
+    if (!Array.isArray(value))
+      refuse(false, "Expected an array projection");
+    return value.map((element) => decoder.decode({ ...params, value: element }));
+  };
+  if (!hasEncoder(decoder))
+    return Object.freeze({ decode: read });
+  return registerScalar({ contract: wrappedContract({ decoder, list: true }), decoder: Object.freeze({
+    decode: read,
+    encode: (params) => {
+      if (!Array.isArray(params.value))
+        refuse(true, "Expected an array parameter");
+      return params.value.map((value) => decoder.encode({ ...params, value }));
+    }
+  }) });
+}
+var encode = Object.freeze({
+  array: ({ encoder }) => Object.freeze({
+    encode: (params) => {
+      if (!Array.isArray(params.value))
+        refuse(true, "Expected an array parameter");
+      return Array.from(params.value, (value) => encoder.encode({ ...params, value }));
+    }
+  })
+});
+var decode = Object.freeze({
+  string: stringDecoder,
+  boolean: scalar("Boolean", (value) => typeof value === "boolean"),
+  int: scalar("Int", (value) => typeof value === "number" && Number.isSafeInteger(value)),
+  float: scalar("Float", (value) => typeof value === "number" && Number.isFinite(value)),
+  bigInt: scalar("BigInt", (value) => typeof value === "bigint"),
+  decimal: scalar("Decimal", (value) => typeof value === "string" && /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value)),
+  dateTime: dateDecoder,
+  extendedDateTime: extendedDecoder,
+  json: scalar("Json", (value) => value !== undefined),
+  bytes: scalar("Bytes", (value) => value instanceof Uint8Array),
+  nullable,
+  array,
+  enum: ({ values }) => {
+    const members = new Set(values);
+    return registerScalar({ contract: { scalar: "String", nullable: false, list: false }, decoder: Object.freeze({
+      decode: ({ value }) => typeof value === "string" && members.has(value) ? value : refuse(false, "Unknown enum projection member"),
+      encode: ({ value }) => typeof value === "string" && members.has(value) ? value : refuse(true, "Unknown enum parameter member")
+    }) });
+  },
+  object: ({ fields }) => {
+    const entries = Object.entries(fields);
+    const convert = (params, encoding) => {
+      if (typeof params.value !== "object" || params.value === null || Array.isArray(params.value))
+        refuse(encoding, "Expected a result row object");
+      const row = params.value;
+      return Object.fromEntries(entries.map(([name, decoder]) => {
+        if (!Object.hasOwn(row, name))
+          refuse(encoding, `Missing projection column "${name}"`);
+        return [name, encoding ? decoder.encode({ ...params, value: row[name] }) : decoder.decode({ ...params, value: row[name] })];
+      }));
+    };
+    return Object.freeze({ decode: (params) => convert(params, false), encode: (params) => convert(params, true) });
+  }
+});
+
+// packages/sql/src/sql-input.ts
+var inputs = new WeakMap;
+var tokens = new WeakMap;
+var scopes = new WeakMap;
+function invalid(message) {
+  throw new VibeError3({ code: "VIBE_VALIDATION", message });
+}
+function isSqlParam(value) {
+  return typeof value === "object" && value !== null && tokens.has(value);
+}
+function isSqlInput(value) {
+  return typeof value === "object" && value !== null && inputs.has(value);
+}
+function createSqlInput(params) {
+  if (typeof params.contract.encoder?.encode !== "function")
+    invalid("SQL input contracts require a parameter encoder");
+  const input = Object.freeze(Object.create(null));
+  inputs.set(input, Object.freeze({
+    ...params.contract,
+    ...params.contract.enumValues === undefined ? {} : { enumValues: Object.freeze([...params.contract.enumValues]) },
+    ...params.contract.enumType === undefined ? {} : { enumType: Object.freeze({ ...params.contract.enumType }) }
+  }));
+  return input;
+}
+function sqlInputContract(params) {
+  const value = params.input;
+  if (typeof value !== "object" || value === null)
+    invalid("SQL input declarations require a decoder or qb.input descriptor");
+  const declared = inputs.get(value);
+  if (declared !== undefined)
+    return declared;
+  if (!("encode" in value) || !("decode" in value) || typeof value.encode !== "function" || typeof value.decode !== "function")
+    invalid("Expected an authentic SQL input descriptor or bidirectional decoder");
+  const decoder = value;
+  const physical = resultScalarContract({ decoder });
+  return Object.freeze({ encoder: decoder, scalar: physical?.scalar ?? "Unknown", nullable: physical?.nullable ?? true, list: physical?.list ?? false });
+}
+function createSqlInputScope(params) {
+  if (typeof params.isHandle !== "function")
+    invalid("SQL input scopes require the builder's handle check");
+  const declarations = params.inputs;
+  if (typeof declarations !== "object" || declarations === null || Array.isArray(declarations))
+    invalid("Reusable SQL requires an input declaration record");
+  const prototype = Object.getPrototypeOf(declarations);
+  if (prototype !== Object.prototype && prototype !== null)
+    invalid("SQL input declarations require a plain record");
+  const keys = Reflect.ownKeys(declarations);
+  const entries = keys.map((key) => {
+    if (typeof key !== "string" || key.length === 0 || key.includes("\x00"))
+      invalid("SQL input names must be nonempty strings without NUL");
+    const descriptor = Object.getOwnPropertyDescriptor(declarations, key);
+    if (!("value" in descriptor))
+      invalid("SQL input declarations cannot contain accessors");
+    return [key, sqlInputContract({ input: descriptor.value })];
+  });
+  const scope = Object.freeze(Object.create(null));
+  scopes.set(scope, { open: true, keys: Object.freeze(entries.map(([key]) => key)), isHandle: params.isHandle });
+  const record = Object.create(null);
+  for (const [key, contract] of entries) {
+    const param = Object.freeze(Object.create(null));
+    tokens.set(param, { scope, key, contract });
+    record[key] = param;
+  }
+  return { scope, params: Object.freeze(record) };
+}
+function sealSqlInputScope(params) {
+  const state = scopes.get(params.scope) ?? invalid("Expected an authentic SQL input scope");
+  state.open = false;
+}
+function assertSqlParamBuilding(params) {
+  const state = tokens.get(params.param) ?? invalid("Expected an authentic SQL input token");
+  if (scopes.get(state.scope)?.open !== true)
+    invalid("SQL input tokens cannot escape their reusable build callback");
+}
+function sqlParamContract(params) {
+  return (tokens.get(params.param) ?? invalid("Expected an authentic SQL input token")).contract;
+}
+function sqlParamKey(params) {
+  const state = tokens.get(params.param) ?? invalid("Expected an authentic SQL input token");
+  if (state.scope !== params.scope)
+    invalid("A reusable query cannot capture another template's input token");
+  return state.key;
+}
+function sqlInputScopeHandle(params) {
+  const state = scopes.get(params.scope) ?? invalid("Expected an authentic SQL input scope");
+  return state.isHandle(params.value);
+}
+function sqlInputScopeKeys(params) {
+  const state = scopes.get(params.scope) ?? invalid("Expected an authentic SQL input scope");
+  if (state.open)
+    invalid("A reusable SQL build must finish before compilation");
+  return state.keys;
+}
+
+// packages/sql/src/parameter-snapshot.ts
+function snapshotSqlValue(value, ancestors = new Set, isHandle) {
+  const invalid = (message) => {
+    throw new VibeError4({ code: "VIBE_VALIDATION", message });
+  };
+  if (isSqlParam(value))
+    return invalid("SQL input tokens are valid only in admitted reusable builder positions");
+  if (isHandle !== undefined && typeof value === "object" && value !== null && isHandle(value))
+    return invalid("SQL builder, plan, template, input and fragment handles are not execution values");
+  if (value === undefined)
+    return invalid("SQL values cannot be undefined; omit a defaulted column or use null");
+  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "bigint")
+    return value;
+  if (typeof value === "number")
+    return value;
+  if (value instanceof Date)
+    return Number.isFinite(value.getTime()) ? new Date(value.getTime()) : invalid("SQL dates must be finite");
+  if (value instanceof Uint8Array)
+    return new Uint8Array(value);
+  if (typeof value !== "object")
+    return invalid("Unsupported SQL parameter value");
+  if (ancestors.has(value))
+    return invalid("Cyclic SQL parameter values are unsupported");
+  const array = Array.isArray(value);
+  const prototype = Object.getPrototypeOf(value);
+  if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null)
+    return invalid("SQL parameters require standard arrays or plain objects");
+  const nested = new Set([...ancestors, value]);
+  const snapshot = array ? [] : Object.create(prototype === null ? null : Object.prototype);
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in descriptor))
+      return invalid("SQL parameter objects and arrays cannot contain accessors");
+    Object.defineProperty(snapshot, key, { ...descriptor, value: snapshotSqlValue(descriptor.value, nested, isHandle) });
+  }
+  return snapshot;
+}
+
+// packages/sql/src/sql-bindings.ts
+var recordings = new WeakMap;
+var programs = new WeakMap;
+function invalid2(message) {
+  throw new VibeError5({ code: "VIBE_VALIDATION", message });
+}
+function unsupported(message) {
+  throw new VibeError5({ code: "VIBE_UNSUPPORTED_CAPABILITY", message });
+}
+function sqlParameterTransport(params) {
+  if (isNativeEnumArrayParameter(params.value))
+    return { kind: "native-enum-array", type: params.value.type };
+  if (isJsonListParameter(params.value))
+    return { kind: "json-list", storage: params.value.storage, whole: typeof params.value.value !== "string" };
+  return { kind: "plain" };
+}
+function renderSqlParameterTransport(params) {
+  const { dialect, placeholder, transport } = params;
+  if (transport.kind === "plain")
+    return placeholder;
+  if (!dialect.capabilities.scalarArrays)
+    throw unsupportedCapability2({ dialect: dialect.name, feature: "scalarArrays" });
+  if (transport.kind === "native-enum-array")
+    return `${placeholder}::${dialect.quoteIdent({ name: transport.type.namespace })}.${dialect.quoteIdent({ name: transport.type.name })}[]`;
+  return `${placeholder}::text::${transport.storage}${transport.whole ? "[]" : ""}`;
+}
+function sqlParameterWireValue(params) {
+  if (isNativeEnumArrayParameter(params.value))
+    return params.value.value;
+  if (isJsonListParameter(params.value))
+    return typeof params.value.value === "string" ? params.value.value : toPgArrayLiteral({ values: params.value.value });
+  return params.value;
+}
+function isSqlBindingCollector(params) {
+  return recordings.has(params.collector);
+}
+function startSqlBindingCollection(params) {
+  sqlInputScopeKeys({ scope: params.scope });
+  if (recordings.has(params.collector))
+    invalid2("SQL binding collection was already started");
+  recordings.set(params.collector, { dialect: params.dialect, scope: params.scope, steps: [], contracts: new Map, used: new Set });
+}
+function contractShape(contract) {
+  return JSON.stringify({
+    scalar: contract.scalar,
+    nullable: contract.nullable,
+    list: contract.list,
+    nativeType: contract.nativeType,
+    enumValues: contract.enumValues,
+    enumType: contract.enumType === undefined ? undefined : [contract.enumType.namespace, contract.enumType.name],
+    jsonStorage: contract.jsonStorage
+  });
+}
+function sameContract(left, right) {
+  return left.encoder === right.encoder && left.columnIdentity === right.columnIdentity && contractShape(left) === contractShape(right);
+}
+function recordSqlBinding(params) {
+  const state = recordings.get(params.collector) ?? invalid2("SQL input tokens require execution through their reusable template");
+  let key;
+  if (params.source.kind === "input") {
+    key = sqlParamKey({ param: params.source.param, scope: state.scope });
+    if (params.contract === undefined)
+      invalid2("Named SQL inputs require an effective encoding contract");
+    const previous = state.contracts.get(key);
+    if (previous !== undefined && !sameContract(previous, params.contract))
+      invalid2(`SQL input "${key}" has incompatible encoding contracts`);
+    state.contracts.set(key, params.contract);
+    state.used.add(key);
+  }
+  const transport = params.transport.kind === "native-enum-array" ? Object.freeze({ ...params.transport, type: Object.freeze({ ...params.transport.type }) }) : Object.freeze({ ...params.transport });
+  const source = params.source.kind === "literal" ? Object.freeze({ kind: "literal", value: snapshotSqlValue(params.source.value) }) : Object.freeze({ ...params.source });
+  const placeholder = params.collector.reserve();
+  const text = renderSqlParameterTransport({ dialect: state.dialect, placeholder, transport });
+  state.steps.push(Object.freeze({ kind: "slot", source, key, transport, encode: params.encode, rejectNull: params.rejectNull === true, ...params.validate === undefined ? {} : { validate: params.validate } }));
+  return text;
+}
+function recordSqlBindingCheck(params) {
+  const state = recordings.get(params.collector) ?? invalid2("Expected a structural SQL collector");
+  state.steps.push(Object.freeze({ kind: "check", check: params.check }));
+}
+function finishSqlBindingCollection(params) {
+  const state = recordings.get(params.collector) ?? invalid2("Expected a structural SQL collector");
+  const keys = sqlInputScopeKeys({ scope: state.scope });
+  for (const key of keys)
+    if (!state.used.has(key))
+      invalid2(`Declared SQL input "${key}" is unused by the finished query`);
+  const program = Object.freeze(Object.create(null));
+  programs.set(program, { dialect: state.dialect, keys, steps: Object.freeze([...state.steps]) });
+  return program;
+}
+function inputSnapshot(params) {
+  const value = params.value === undefined && params.keys.length === 0 ? Object.create(null) : params.value;
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    invalid2("Reusable SQL parameters require an exact plain record");
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null)
+    invalid2("Reusable SQL parameters require a plain record without inherited inputs");
+  const own = Reflect.ownKeys(value);
+  if (own.length !== params.keys.length || own.some((key) => typeof key !== "string" || !params.keys.includes(key)))
+    invalid2("Reusable SQL parameters must contain exactly the declared names");
+  const descriptors = params.keys.map((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor === undefined || !("value" in descriptor) || descriptor.value === undefined)
+      invalid2(`SQL input "${key}" must be an own defined data property`);
+    return { key, value: descriptor.value };
+  });
+  const snapshot = Object.create(null);
+  for (const entry of descriptors)
+    snapshot[entry.key] = snapshotSqlValue(entry.value, new Set, params.isHandle);
+  return snapshot;
+}
+function sameTransport(left, right) {
+  if (left.kind !== right.kind)
+    return false;
+  if (left.kind === "native-enum-array" && right.kind === "native-enum-array")
+    return left.type.namespace === right.type.namespace && left.type.name === right.type.name;
+  if (left.kind === "json-list" && right.kind === "json-list")
+    return left.storage === right.storage && left.whole === right.whole;
+  return true;
+}
+function bindSqlBindingProgram(params) {
+  const state = programs.get(params.program) ?? invalid2("Expected an authentic SQL binding program");
+  const inputs = inputSnapshot({ keys: state.keys, value: params.params, isHandle: params.isHandle });
+  const encodedInputs = new Map;
+  const values = [];
+  for (const step of state.steps) {
+    if (step.kind === "check") {
+      step.check();
+      continue;
+    }
+    const value = step.source.kind === "literal" ? step.source.value : inputs[step.key];
+    step.validate?.(value);
+    if (step.rejectNull && value === null)
+      invalid2("SQL comparison and membership inputs cannot be SQL NULL; use isNull");
+    let encoded;
+    if (step.key !== undefined && encodedInputs.has(step.key))
+      encoded = encodedInputs.get(step.key);
+    else {
+      encoded = snapshotSqlValue(step.encode({ value: snapshotSqlValue(value), dialect: state.dialect }));
+      if (step.key !== undefined)
+        encodedInputs.set(step.key, encoded);
+    }
+    step.validate?.(encoded);
+    if (step.rejectNull && encoded === null)
+      invalid2("SQL comparison and membership encoders cannot produce SQL NULL; use isNull");
+    if (encoded !== null && !sameTransport(step.transport, sqlParameterTransport({ value: encoded })))
+      unsupported("A reusable SQL encoder produced an undeclared parameter transport shape");
+    values.push(snapshotSqlValue(sqlParameterWireValue({ value: encoded })));
+  }
+  return values;
+}
+
 // packages/sql/src/params.ts
-import { unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
 class ParamCollector {
   dialect;
+  reserved = 0;
   values;
   constructor(dialect) {
     this.dialect = dialect;
     this.values = [];
   }
+  reserve() {
+    const index = isSqlBindingCollector({ collector: this }) ? ++this.reserved : this.values.length;
+    return this.dialect.placeholder({ index });
+  }
+  count() {
+    return isSqlBindingCollector({ collector: this }) ? this.reserved : this.values.length;
+  }
   add(value) {
-    if (isNativeEnumArrayParameter(value)) {
-      if (!this.dialect.capabilities.scalarArrays)
-        throw unsupportedCapability2({ dialect: this.dialect.name, feature: "scalarArrays" });
-      this.values.push(value.value);
-      return `${this.dialect.placeholder({ index: this.values.length })}::${this.dialect.quoteIdent({ name: value.type.namespace })}.${this.dialect.quoteIdent({ name: value.type.name })}[]`;
-    }
-    if (isJsonListParameter(value)) {
-      if (!this.dialect.capabilities.scalarArrays)
-        throw unsupportedCapability2({ dialect: this.dialect.name, feature: "scalarArrays" });
-      const whole = typeof value.value !== "string";
-      this.values.push(whole ? [...value.value] : value.value);
-      return `${this.dialect.placeholder({ index: this.values.length })}::text::${value.storage}${whole ? "[]" : ""}`;
-    }
-    this.values.push(value);
-    return this.dialect.placeholder({ index: this.values.length });
+    const transport = sqlParameterTransport({ value });
+    if (isSqlBindingCollector({ collector: this }))
+      return recordSqlBinding({
+        collector: this,
+        source: { kind: "literal", value },
+        transport,
+        encode: (params) => params.value
+      });
+    if (transport.kind !== "plain" && !this.dialect.capabilities.scalarArrays)
+      throw unsupportedCapability3({ dialect: this.dialect.name, feature: "scalarArrays" });
+    this.values.push(sqlParameterWireValue({ value }));
+    return renderSqlParameterTransport({ dialect: this.dialect, placeholder: this.reserve(), transport });
   }
   addMany(values) {
     return values.map((value) => this.add(value));
@@ -75,7 +912,7 @@ class ParamCollector {
 // packages/sql/src/dialects/external-dependents.ts
 function renderExternalDependents(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability3({ dialect: params.dialect.name, feature: "externalObjects" });
+    throw unsupportedCapability4({ dialect: params.dialect.name, feature: "externalObjects" });
   const collector = new ParamCollector(params.dialect);
   const requests = params.targets.map((target, position) => ({ position, kind: target.kind, namespace: target.namespace, name: target.name, column: target.kind === "column" ? target.column : null }));
   const request = collector.add(JSON.stringify(requests));
@@ -117,11 +954,11 @@ ORDER BY 1, 2, 3, 4`;
   return { text, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/postgres-physical-catalog.ts
-import { unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
 function renderPostgresPhysicalCatalog(params) {
   const { dialect } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability4({ dialect: dialect.name, feature: "postgresPhysicalCatalog" });
+    throw unsupportedCapability5({ dialect: dialect.name, feature: "postgresPhysicalCatalog" });
   const collector = new ParamCollector(dialect);
   const namespace = collector.add(params.namespace);
   const extensionOwnedFilter = `NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d JOIN pg_catalog.pg_class c ON c.oid = d.objid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE d.classid = 'pg_class'::regclass AND d.deptype = 'e' AND n.nspname = ${namespace} AND c.relname = table_name)`;
@@ -155,11 +992,11 @@ function renderPostgresPhysicalCatalog(params) {
   return { text, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/postgres-index-keys.ts
-import { unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
 function renderPostgresIndexKeys(params) {
   const { dialect } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability5({ dialect: dialect.name, feature: "indexOperatorClasses" });
+    throw unsupportedCapability6({ dialect: dialect.name, feature: "indexOperatorClasses" });
   const collector = new ParamCollector(dialect);
   const scope = params.table !== undefined ? `n.nspname = ${collector.add(params.table.namespace)} AND c.relname = ${collector.add(params.table.name)}` : params.namespaces === undefined ? "n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\'" : params.namespaces.length === 0 ? "false" : `n.nspname IN (${[...new Set(params.namespaces)].map((namespace) => collector.add(namespace)).join(", ")})`;
   const defaultResolution = `LEFT JOIN LATERAL (WITH RECURSIVE input_types AS (SELECT t.oid, t.typbasetype, t.typtype, t.typelem, t.typcategory FROM pg_catalog.pg_type t WHERE t.oid = a.atttypid UNION ALL SELECT t.oid, t.typbasetype, t.typtype, t.typelem, t.typcategory FROM pg_catalog.pg_type t JOIN input_types previous ON t.oid = previous.typbasetype WHERE previous.typtype = 'd'), candidates AS (SELECT candidate.oid, CASE WHEN candidate.opcintype = input.oid THEN 0 WHEN class_input.typispreferred AND class_input.typcategory = input.typcategory THEN 1 ELSE 2 END AS priority FROM pg_catalog.pg_opclass candidate JOIN pg_catalog.pg_type class_input ON class_input.oid = candidate.opcintype CROSS JOIN input_types input WHERE input.typtype <> 'd' AND candidate.opcdefault AND candidate.opcmethod = idx.relam AND (candidate.opcintype = input.oid OR EXISTS (SELECT 1 FROM pg_catalog.pg_cast cast_entry WHERE cast_entry.castsource = input.oid AND cast_entry.casttarget = candidate.opcintype AND cast_entry.castmethod = 'b' AND cast_entry.castcontext = 'i') OR input.typtype = 'e' AND candidate.opcintype = 'pg_catalog.anyenum'::regtype OR input.typelem <> 0 AND candidate.opcintype = 'pg_catalog.anyarray'::regtype)) SELECT (array_agg(candidate.oid))[1] AS oid FROM candidates candidate WHERE candidate.priority = (SELECT min(priority) FROM candidates) HAVING count(*) = 1) resolved_default ON true`;
@@ -170,18 +1007,18 @@ function renderPostgresIndexKeys(params) {
   };
 }
 // packages/sql/src/index-columns.ts
-import { VibeError, isSqlObjectIdentity, unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
+import { VibeError as VibeError6, isSqlObjectIdentity, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
 function renderIndexColumns(params) {
   const { dialect, columns, unique } = params;
   const hasOperatorClass = columns.some((column) => column.operatorClass !== undefined);
   if (hasOperatorClass && !dialect.capabilities.indexOperatorClasses)
-    throw unsupportedCapability6({ dialect: dialect.name, feature: "indexOperatorClasses" });
+    throw unsupportedCapability7({ dialect: dialect.name, feature: "indexOperatorClasses" });
   if (hasOperatorClass && unique)
-    throw unsupportedCapability6({ dialect: dialect.name, feature: "uniqueIndexOperatorClasses", hint: "custom unique operator classes can change client selector equality" });
+    throw unsupportedCapability7({ dialect: dialect.name, feature: "uniqueIndexOperatorClasses", hint: "custom unique operator classes can change client selector equality" });
   return columns.map((column) => {
     const operatorClass = column.operatorClass;
     if (operatorClass !== undefined && !isSqlObjectIdentity({ kind: "table", name: operatorClass })) {
-      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Index operator class must be a qualified SQL name { namespace, name }", meta: { rule: "index-operator-class-identity", column: column.name } });
+      throw new VibeError6({ code: "VIBE_SCHEMA_INVALID", message: "Index operator class must be a qualified SQL name { namespace, name }", meta: { rule: "index-operator-class-identity", column: column.name } });
     }
     const ops = operatorClass === undefined ? "" : ` ${dialect.quoteIdent({ name: operatorClass.namespace })}.${dialect.quoteIdent({ name: operatorClass.name })}`;
     return `${dialect.quoteIdent({ name: column.name })}${ops}${column.desc ? " DESC" : ""}`;
@@ -233,7 +1070,7 @@ UNION ALL SELECT DISTINCT 'partition', TABLE_NAME, TABLE_SCHEMA, NULL FROM infor
   return { text: `SELECT 'table-options' AS kind, name, schema AS namespace, NULL AS parent FROM pragma_table_list WHERE schema = ${namespace} AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\' AND (type = 'virtual' OR wr <> 0 OR strict <> 0)`, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/migration-shadow.ts
-import { assertSqlNamespace, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
+import { assertSqlNamespace, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
 var SHADOW_DATABASE = Object.freeze({ schema: "_vibeorm_shadow", table: "_vibe_shadow", lock: 1447645267, timeoutSeconds: 60 });
 var SHADOW_CAPABILITIES = Object.freeze({
   postgres: Object.freeze({ serverProvisioning: true, dedicated: true }),
@@ -243,7 +1080,7 @@ var SHADOW_CAPABILITIES = Object.freeze({
 function renderShadowOperation(params) {
   const { dialect, operation } = params;
   if (!SHADOW_CAPABILITIES[dialect.name].serverProvisioning)
-    throw unsupportedCapability7({ dialect: dialect.name, feature: "shadowDatabaseProvisioning" });
+    throw unsupportedCapability8({ dialect: dialect.name, feature: "shadowDatabaseProvisioning" });
   const pg = dialect.name === "postgres";
   const collector = new ParamCollector(dialect);
   const marker = pg ? `${dialect.quoteIdent({ name: SHADOW_DATABASE.schema })}.${dialect.quoteIdent({ name: SHADOW_DATABASE.table })}` : dialect.quoteIdent({ name: SHADOW_DATABASE.table });
@@ -268,7 +1105,7 @@ function renderShadowOperation(params) {
 ORDER BY ordinal_position`);
     case "grants": {
       if (pg)
-        throw unsupportedCapability7({ dialect: dialect.name, feature: "mysqlShadowPrivileges" });
+        throw unsupportedCapability8({ dialect: dialect.name, feature: "mysqlShadowPrivileges" });
       return result("SHOW GRANTS FOR CURRENT_USER");
     }
     case "markerCreate":
@@ -299,7 +1136,7 @@ UNION ALL SELECT 'EXTERNAL FOREIGN KEY', CONCAT(TABLE_NAME, '.', CONSTRAINT_NAME
     case "resetPostgres":
     case "resetDedicatedPostgres": {
       if (!pg)
-        throw unsupportedCapability7({ dialect: dialect.name, feature: "postgresShadowReset" });
+        throw unsupportedCapability8({ dialect: dialect.name, feature: "postgresShadowReset" });
       const owned = operation.kind === "resetDedicatedPostgres" ? operation.ownedNamespaces : [];
       for (const namespace of owned)
         assertSqlNamespace({ namespace, dialect: "postgres", allowPublic: false });
@@ -311,12 +1148,12 @@ UNION ALL SELECT 'EXTERNAL FOREIGN KEY', CONCAT(TABLE_NAME, '.', CONSTRAINT_NAME
     }
     case "mysqlForeignKeys": {
       if (pg)
-        throw unsupportedCapability7({ dialect: dialect.name, feature: "mysqlShadowReset" });
+        throw unsupportedCapability8({ dialect: dialect.name, feature: "mysqlShadowReset" });
       return result(`SET FOREIGN_KEY_CHECKS = ${operation.enabled ? "1" : "0"}`);
     }
     case "dropMysqlObject": {
       if (pg)
-        throw unsupportedCapability7({ dialect: dialect.name, feature: "mysqlShadowReset" });
+        throw unsupportedCapability8({ dialect: dialect.name, feature: "mysqlShadowReset" });
       return result(`DROP ${operation.object} ${dialect.quoteIdent({ name: operation.name })}`);
     }
   }
@@ -358,10 +1195,10 @@ import {
 } from "@vibeorm/schema";
 
 // packages/sql/src/identifiers.ts
-import { VibeError as VibeError2 } from "@vibeorm/schema";
+import { VibeError as VibeError7 } from "@vibeorm/schema";
 function assertNoNul(params) {
   if (params.name.includes("\x00")) {
-    throw new VibeError2({
+    throw new VibeError7({
       code: "VIBE_VALIDATION",
       message: "an SQL identifier cannot contain a NUL character \u2014 the server would stop reading it there and address a different object",
       meta: { name: params.name.replaceAll("\x00", "\\0") }
@@ -402,800 +1239,449 @@ var sqliteDialect = {
     "array_ends_with"
   ],
   jsonParamCast: "",
+  valueCastTypes: Object.freeze({ String: "TEXT", Boolean: "INTEGER", Int: "INTEGER", BigInt: "INTEGER", Float: "REAL", Decimal: "TEXT", DateTime: "TEXT", Json: "TEXT", Bytes: "BLOB" }),
   lastInsertIdSql: null,
   rowLockSyntax: null,
   advisoryLockFunctions: null,
-  rowDefaultKeyword: false,
-  statementChain: null,
-  paramBudget: 900,
-  booleanLiteral: { true: "1", false: "0" },
-  quoteIdent({ name }) {
-    return `"${assertNoNul({ name }).replaceAll('"', '""')}"`;
-  },
-  quoteStringLiteral({ value }) {
-    return `'${value.replaceAll("'", "''")}'`;
-  },
-  placeholder() {
-    return "?";
-  },
-  renderDbNow({ offsetSeconds, collector }) {
-    if (offsetSeconds === 0)
-      return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
-    return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now', ${collector.add(offsetSeconds)} || ' seconds')`;
-  }
-};
-
-// packages/sql/src/dialects/sqlite-table-definition.ts
-import { VibeError as VibeError3 } from "@vibeorm/schema";
-function tableDefinitionParts(params) {
-  const sql = params.sql;
-  if (!/^\s*CREATE\s+(?:TEMP(?:ORARY)?\s+)?TABLE\b/i.test(sql))
-    throw unavailable();
-  const parts = [];
-  let start = -1;
-  let depth = 0;
-  let quote;
-  for (let index = 0;index < sql.length; index++) {
-    const char = sql[index];
-    if (quote !== undefined) {
-      if (char === quote) {
-        if (quote !== "]" && sql[index + 1] === quote)
-          index++;
-        else
-          quote = undefined;
-      }
-      continue;
-    }
-    if (char === "'" || char === '"' || char === "`") {
-      quote = char;
-      continue;
-    }
-    if (char === "[") {
-      quote = "]";
-      continue;
-    }
-    if (char === "-" && sql[index + 1] === "-") {
-      const end = sql.indexOf(`
-`, index + 2);
-      if (end < 0)
-        break;
-      index = end;
-      continue;
-    }
-    if (char === "/" && sql[index + 1] === "*") {
-      const end = sql.indexOf("*/", index + 2);
-      if (end < 0)
-        break;
-      index = end + 1;
-      continue;
-    }
-    if (char === "(") {
-      if (depth === 0)
-        start = index + 1;
-      depth++;
-    } else if (char === ")") {
-      depth--;
-      if (depth === 0 && start >= 0) {
-        parts.push(sql.slice(start, index).trim());
-        return { clauses: parts, suffix: sql.slice(index + 1) };
-      }
-    } else if (char === "," && depth === 1) {
-      parts.push(sql.slice(start, index).trim());
-      start = index + 1;
-    }
-  }
-  throw unavailable();
-}
-function unavailable() {
-  return new VibeError3({ code: "VIBE_MIGRATION", message: "Cannot preserve table definition", meta: { reason: "table-definition-unavailable" } });
-}
-function sqliteColumnClauses(params) {
-  const columns = [];
-  for (const part of tableDefinitionParts(params).clauses) {
-    const token = /^(?:"((?:[^"]|"")+)"|`((?:[^`]|``)+)`|\[([^\]]+)\]|([A-Za-z_][A-Za-z_0-9]*))/.exec(part);
-    if (token === null)
-      throw unavailable();
-    if (token[4] !== undefined && /^(?:CONSTRAINT|PRIMARY|UNIQUE|CHECK|FOREIGN)$/i.test(token[4]))
-      continue;
-    const name = token[1]?.replaceAll('""', '"') ?? token[2]?.replaceAll("``", "`") ?? token[3] ?? token[4];
-    columns.push({ name, sql: part });
-  }
-  return columns;
-}
-
-// packages/sql/src/dialects/sqlite-fts.ts
-function updateStatements(params) {
-  const quote = (name) => sqliteDialect.quoteIdent({ name });
-  const columns = params.columns.map((column) => quote(column)).join(", ");
-  const oldValues = params.columns.map((column) => `old.${quote(column)}`).join(", ");
-  const newValues = params.columns.map((column) => `new.${quote(column)}`).join(", ");
-  const changes = [
-    "old.rowid IS NOT new.rowid",
-    ...params.columns.map((column) => `old.${quote(column)} COLLATE BINARY IS NOT new.${quote(column)} COLLATE BINARY`)
-  ].join(" OR ");
-  const target = `${quote(`${params.ftsTable}_au`)} AFTER UPDATE ON ${quote(params.table)}`;
-  const body = `BEGIN
-  INSERT INTO ${quote(params.ftsTable)}(${quote(params.ftsTable)}, rowid, ${columns}) VALUES ('delete', old.rowid, ${oldValues});
-  INSERT INTO ${quote(params.ftsTable)}(rowid, ${columns}) VALUES (new.rowid, ${newValues});
-END`;
-  const tail = `${target} WHEN (${changes}) ${body}`;
-  return {
-    create: `CREATE TRIGGER IF NOT EXISTS ${tail};`,
-    definition: `CREATE TRIGGER ${tail}`,
-    legacyDefinition: `CREATE TRIGGER ${target} ${body}`
-  };
-}
-function renderSqliteFtsUpdateTrigger(params) {
-  const { create, definition } = updateStatements(params);
-  return { create, definition };
-}
-function sqliteFtsUpdateUpgrade(params) {
-  const quoted = '"(?:[^"]|"")+"';
-  const body = new RegExp(`BEGIN\\n  INSERT INTO (${quoted})\\((${quoted}), rowid, (${quoted}(?:, ${quoted})*)\\) VALUES \\('delete', old\\.rowid, `, "g");
-  for (const match of params.create.matchAll(body)) {
-    const ftsTable = sqliteColumnClauses({ sql: `CREATE TABLE x (${match[1]})` })[0].name;
-    const columns = sqliteColumnClauses({ sql: `CREATE TABLE x (${match[3]})` }).map((column) => column.name);
-    if (params.name !== `${ftsTable}_au`)
-      continue;
-    const statements = updateStatements({ table: params.table, ftsTable, columns });
-    if (params.create !== statements.create)
-      continue;
-    const installed = params.installed === statements.legacyDefinition ? "legacy" : params.installed === statements.definition ? "current" : undefined;
-    if (installed === undefined)
-      continue;
-    if (params.tableDefinition === undefined)
-      return { kind: "tableRequired", ftsTable };
-    const tableTail = `${sqliteDialect.quoteIdent({ name: ftsTable })} USING fts5(${columns.map((name) => sqliteDialect.quoteIdent({ name })).join(", ")}, content=${sqliteDialect.quoteStringLiteral({ value: params.table })})`;
-    if (params.tableDefinition !== `CREATE VIRTUAL TABLE ${tableTail}` && params.tableDefinition !== `CREATE VIRTUAL TABLE IF NOT EXISTS ${tableTail};`)
-      continue;
-    return { kind: "recognized", ftsTable, legacyDefinition: statements.legacyDefinition, currentDefinition: statements.definition, drop: `DROP TRIGGER IF EXISTS ${sqliteDialect.quoteIdent({ name: `${ftsTable}_au` })};`, installed };
-  }
-  return;
-}
-// packages/sql/src/dialects/sqlite-session.ts
-var SQLITE_SESSION_SQL = Object.freeze({
-  lockingMode: "PRAGMA main.locking_mode",
-  exclusive: "PRAGMA main.locking_mode = EXCLUSIVE",
-  normal: "PRAGMA main.locking_mode = NORMAL",
-  acquire: "BEGIN EXCLUSIVE",
-  commit: "COMMIT",
-  rollback: "ROLLBACK",
-  touch: "SELECT name FROM main.sqlite_schema LIMIT 1",
-  foreignKeysOn: "PRAGMA foreign_keys = ON"
-});
-// packages/sql/src/composable.ts
-import { VibeError as VibeError4 } from "@vibeorm/schema";
-var fragments = new WeakMap;
-function invalid(message) {
-  throw new VibeError4({ code: "VIBE_VALIDATION", message });
-}
-function construct(parts) {
-  const snapshot = Object.freeze([...parts]);
-  const fragment = Object.freeze(Object.defineProperty(Object.create(null), "toJSON", {
-    value: () => ({ parts: snapshot })
-  }));
-  fragments.set(fragment, snapshot);
-  return fragment;
-}
-function isSqlFragment(value) {
-  return typeof value === "object" && value !== null && fragments.has(value);
-}
-function partsOf(value) {
-  return fragments.get(value) ?? invalid("Expected a constructed SQL fragment");
-}
-function containsGreatest(fragment) {
-  return partsOf(fragment).some((part) => typeof part !== "string" && ("greatest" in part));
-}
-function identifier(parts) {
-  if (!Array.isArray(parts) || parts.length === 0 || parts.some((part) => typeof part !== "string" || part.length === 0 || part.includes("\x00"))) {
-    invalid("SQL identifiers require non-empty, NUL-free name components");
-  }
-}
-function template(strings, ...values) {
-  if (!Array.isArray(strings) || !Array.isArray(strings.raw) || strings.length !== values.length + 1 || strings.some((text) => typeof text !== "string")) {
-    invalid("Use sql as a template tag");
-  }
-  const parts = [];
-  for (let index = 0;index < strings.length; index++) {
-    parts.push(strings[index]);
-    if (index < values.length) {
-      const value = values[index];
-      if (isSqlFragment(value))
-        parts.push(...partsOf(value));
-      else
-        parts.push(Object.freeze({ value }));
-    }
-  }
-  return construct(parts);
-}
-var sql = Object.freeze(Object.assign(template, {
-  text: ({ text }) => {
-    if (typeof text !== "string" || text.includes("\x00"))
-      invalid("SQL text must be a NUL-free string");
-    return construct([text]);
-  },
-  ident: ({ parts }) => {
-    identifier(parts);
-    return construct([Object.freeze({ ident: Object.freeze([...parts]) })]);
-  },
-  value: ({ value, decoder }) => construct([Object.freeze({ value, ...decoder === undefined ? {} : { decoder } })]),
-  join: ({ items, separator }) => {
-    if (!Array.isArray(items))
-      invalid("sql.join requires an array");
-    const between = separator === undefined ? [", "] : partsOf(separator);
-    const parts = [];
-    items.forEach((value, index) => {
-      if (index > 0)
-        parts.push(...between);
-      parts.push(...isSqlFragment(value) ? partsOf(value) : [Object.freeze({ value })]);
-    });
-    return construct(parts);
+  rowDefaultKeyword: false,
+  statementChain: null,
+  paramBudget: 900,
+  booleanLiteral: { true: "1", false: "0" },
+  quoteIdent({ name }) {
+    return `"${assertNoNul({ name }).replaceAll('"', '""')}"`;
   },
-  existing: ({ column }) => {
-    identifier([column]);
-    return construct([Object.freeze({ row: "existing", column })]);
+  quoteStringLiteral({ value }) {
+    return `'${value.replaceAll("'", "''")}'`;
   },
-  incoming: ({ column }) => {
-    identifier([column]);
-    return construct([Object.freeze({ row: "incoming", column })]);
+  placeholder() {
+    return "?";
   },
-  greatest: ({ values }) => {
-    if (!Array.isArray(values) || values.length !== 2 || values.some((value) => !isSqlFragment(value)))
-      invalid("sql.greatest requires two SQL fragments");
-    return construct([Object.freeze({ greatest: Object.freeze([...values]) })]);
+  jsonTextProjection({ expression }) {
+    return expression;
+  },
+  renderDbNow({ offsetSeconds, collector }) {
+    if (offsetSeconds === 0)
+      return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+    return `strftime('%Y-%m-%dT%H:%M:%fZ', 'now', ${collector.add(offsetSeconds)} || ' seconds')`;
   }
-}));
-function renderSqlFragment(params) {
-  const { dialect, collector, conflict } = params;
-  const render = (fragment) => renderSqlFragment({ ...params, fragment });
-  const encode = (part) => {
-    if (part.value === undefined)
-      invalid("SQL parameters cannot be undefined; use null explicitly");
-    return part.decoder === undefined ? part.value : part.decoder.encode({ value: part.value, dialect: dialect.name });
-  };
-  const frameOperand = (fragment) => {
-    const parts = partsOf(fragment).filter((part) => part !== "");
-    const only = parts.length === 1 ? parts[0] : undefined;
-    const value = only !== undefined && typeof only !== "string" && "value" in only ? { encoded: encode(only) } : undefined;
-    if (value !== undefined && value.encoded === null)
-      return "NULL";
-    const text = value === undefined ? render(fragment) : collector.add(value.encoded);
-    return dialect.greatestForm === "wrapped-frame" ? `(SELECT ${text})` : text;
-  };
-  return partsOf(params.fragment).map((part) => {
-    if (typeof part === "string")
-      return part;
-    if ("value" in part)
-      return collector.add(encode(part));
-    if ("ident" in part)
-      return part.ident.map((name) => dialect.quoteIdent({ name })).join(".");
-    if ("row" in part) {
-      if (conflict === undefined)
-        invalid("Existing/incoming row references require a conflict update");
-      const name = conflict.columns === undefined ? part.column : conflict.columns[part.column];
-      if (name === undefined)
-        invalid(`Unknown conflict-expression field "${part.column}"`);
-      const ref = dialect.excludedRowRef;
-      const qualifier = part.row === "existing" ? dialect.quoteIdent({ name: conflict.table }) : ref.form === "keyword" ? ref.name : dialect.quoteIdent({ name: ref.alias });
-      return `${qualifier}.${dialect.quoteIdent({ name })}`;
+};
+
+// packages/sql/src/dialects/sqlite-table-definition.ts
+import { VibeError as VibeError8 } from "@vibeorm/schema";
+function tableDefinitionParts(params) {
+  const sql = params.sql;
+  if (!/^\s*CREATE\s+(?:TEMP(?:ORARY)?\s+)?TABLE\b/i.test(sql))
+    throw unavailable();
+  const parts = [];
+  let start = -1;
+  let depth = 0;
+  let quote;
+  for (let index = 0;index < sql.length; index++) {
+    const char = sql[index];
+    if (quote !== undefined) {
+      if (char === quote) {
+        if (quote !== "]" && sql[index + 1] === quote)
+          index++;
+        else
+          quote = undefined;
+      }
+      continue;
     }
-    if (dialect.greatestForm === "native")
-      return `GREATEST(${part.greatest.map(render).join(", ")})`;
-    if (!part.greatest.some(containsGreatest)) {
-      return render(part.greatest.reduce((left, right) => sql`(CASE WHEN ${left} IS NULL THEN ${right} WHEN ${right} IS NULL THEN ${left} WHEN ${left} >= ${right} THEN ${left} ELSE ${right} END)`));
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
     }
-    const [left, right] = part.greatest.map(frameOperand);
-    const [a, b, frame] = ["a", "b", "g"].map((name) => dialect.quoteIdent({ name }));
-    return `(SELECT CASE WHEN ${a} IS NULL THEN ${b} WHEN ${b} IS NULL THEN ${a} WHEN ${a} >= ${b} THEN ${a} ELSE ${b} END FROM (SELECT ${left} AS ${a}, ${right} AS ${b}) AS ${frame})`;
-  }).join("");
-}
-function mapConflictColumns(params) {
-  return construct(partsOf(params.fragment).map((part) => {
-    if (typeof part === "string")
-      return part;
-    if ("row" in part) {
-      const column = Object.hasOwn(params.columns, part.column) ? params.columns[part.column] : undefined;
-      if (column === undefined)
-        invalid(`Unknown conflict-expression field "${part.column}"`);
-      return Object.freeze({ ...part, column });
+    if (char === "[") {
+      quote = "]";
+      continue;
     }
-    if ("greatest" in part)
-      return Object.freeze({ greatest: Object.freeze(part.greatest.map((fragment) => mapConflictColumns({ ...params, fragment }))) });
-    return part;
-  }));
-}
-function compileSql(params) {
-  const collector = new ParamCollector(params.dialect);
-  const text = renderSqlFragment({ dialect: params.dialect, fragment: params.query, collector });
-  return { text, values: collector.values };
-}
-function sqlUsesIncoming(params) {
-  return partsOf(params.fragment).some((part) => typeof part !== "string" && (("row" in part) && part.row === "incoming" || ("greatest" in part) && part.greatest.some((fragment) => sqlUsesIncoming({ fragment }))));
-}
-// packages/sql/src/result-decoder.ts
-import { VibeError as VibeError6 } from "@vibeorm/schema";
-
-// packages/sql/src/pg-array.ts
-var PG_ARRAY_QUOTE = /^$|^NULL$|[{},"\\\s]/i;
-function toPgArrayLiteral(params) {
-  const { values } = params;
-  const parts = values.map((value) => {
-    if (value === null || value === undefined)
-      return "NULL";
-    const text = String(value);
-    return PG_ARRAY_QUOTE.test(text) ? `"${text.replace(/["\\]/g, (char) => `\\${char}`)}"` : text;
-  });
-  return `{${parts.join(",")}}`;
-}
-function parsePgArrayLiteral(params) {
-  const literal = params.literal.startsWith("[") ? params.literal.replace(/^\[-?\d+:-?\d+\]=/, "") : params.literal;
-  if (literal.length < 2 || !literal.startsWith("{") || !literal.endsWith("}"))
-    return null;
-  const inner = literal.slice(1, -1);
-  if (inner.length === 0)
-    return [];
-  const out = [];
-  let index = 0;
-  while (index < inner.length) {
-    if (inner[index] === '"') {
-      let text = "";
-      index++;
-      while (index < inner.length) {
-        const char = inner[index];
-        if (char === "\\") {
-          text += inner[index + 1] ?? "";
-          index += 2;
-          continue;
-        }
-        index++;
-        if (char === '"')
-          break;
-        text += char;
-      }
-      out.push(text);
-    } else {
-      let text = "";
-      while (index < inner.length && inner[index] !== ",") {
-        text += inner[index];
-        index++;
+    if (char === "-" && sql[index + 1] === "-") {
+      const end = sql.indexOf(`
+`, index + 2);
+      if (end < 0)
+        break;
+      index = end;
+      continue;
+    }
+    if (char === "/" && sql[index + 1] === "*") {
+      const end = sql.indexOf("*/", index + 2);
+      if (end < 0)
+        break;
+      index = end + 1;
+      continue;
+    }
+    if (char === "(") {
+      if (depth === 0)
+        start = index + 1;
+      depth++;
+    } else if (char === ")") {
+      depth--;
+      if (depth === 0 && start >= 0) {
+        parts.push(sql.slice(start, index).trim());
+        return { clauses: parts, suffix: sql.slice(index + 1) };
       }
-      out.push(text === "NULL" ? null : text);
+    } else if (char === "," && depth === 1) {
+      parts.push(sql.slice(start, index).trim());
+      start = index + 1;
     }
-    if (inner[index] === ",")
-      index++;
   }
-  return out;
+  throw unavailable();
 }
-function parsePgArrayLiteralNested(params) {
-  const text = params.literal.replace(/^(?:\[-?\d+:-?\d+\])+=/, "");
-  const cursor = { index: 0 };
-  const parsed = parseDimension({ text, cursor });
-  return parsed !== null && cursor.index === text.length ? parsed : null;
+function unavailable() {
+  return new VibeError8({ code: "VIBE_MIGRATION", message: "Cannot preserve table definition", meta: { reason: "table-definition-unavailable" } });
 }
-function parseDimension(params) {
-  const { text, cursor } = params;
-  if (text[cursor.index] !== "{")
-    return null;
-  cursor.index++;
-  const out = [];
-  if (text[cursor.index] === "}") {
-    cursor.index++;
-    return out;
-  }
-  while (cursor.index < text.length) {
-    if (text[cursor.index] === "{") {
-      const nested = parseDimension({ text, cursor });
-      if (nested === null)
-        return null;
-      out.push(nested);
-    } else if (text[cursor.index] === '"') {
-      let element = "";
-      cursor.index++;
-      while (cursor.index < text.length && text[cursor.index] !== '"') {
-        if (text[cursor.index] === "\\")
-          cursor.index++;
-        element += text[cursor.index] ?? "";
-        cursor.index++;
-      }
-      if (text[cursor.index] !== '"')
-        return null;
-      cursor.index++;
-      out.push(element);
-    } else {
-      let element = "";
-      while (cursor.index < text.length && text[cursor.index] !== "," && text[cursor.index] !== "}") {
-        element += text[cursor.index];
-        cursor.index++;
-      }
-      out.push(element === "NULL" ? null : element);
-    }
-    if (text[cursor.index] === ",") {
-      cursor.index++;
+function sqliteColumnClauses(params) {
+  const columns = [];
+  for (const part of tableDefinitionParts(params).clauses) {
+    const token = /^(?:"((?:[^"]|"")+)"|`((?:[^`]|``)+)`|\[([^\]]+)\]|([A-Za-z_][A-Za-z_0-9]*))/.exec(part);
+    if (token === null)
+      throw unavailable();
+    if (token[4] !== undefined && /^(?:CONSTRAINT|PRIMARY|UNIQUE|CHECK|FOREIGN)$/i.test(token[4]))
       continue;
-    }
-    if (text[cursor.index] !== "}")
-      return null;
-    cursor.index++;
-    return out;
+    const name = token[1]?.replaceAll('""', '"') ?? token[2]?.replaceAll("``", "`") ?? token[3] ?? token[4];
+    columns.push({ name, sql: part });
   }
-  return null;
+  return columns;
 }
 
-// packages/sql/src/codecs.ts
-import { VibeError as VibeError5, invalidStoredData, timeOfDayType } from "@vibeorm/schema";
-function enumMembershipCodec(params) {
-  const { model, field, enum: enumName } = params;
-  const members = new Set(params.members);
+// packages/sql/src/dialects/sqlite-fts.ts
+function updateStatements(params) {
+  const quote = (name) => sqliteDialect.quoteIdent({ name });
+  const columns = params.columns.map((column) => quote(column)).join(", ");
+  const oldValues = params.columns.map((column) => `old.${quote(column)}`).join(", ");
+  const newValues = params.columns.map((column) => `new.${quote(column)}`).join(", ");
+  const changes = [
+    "old.rowid IS NOT new.rowid",
+    ...params.columns.map((column) => `old.${quote(column)} COLLATE BINARY IS NOT new.${quote(column)} COLLATE BINARY`)
+  ].join(" OR ");
+  const target = `${quote(`${params.ftsTable}_au`)} AFTER UPDATE ON ${quote(params.table)}`;
+  const body = `BEGIN
+  INSERT INTO ${quote(params.ftsTable)}(${quote(params.ftsTable)}, rowid, ${columns}) VALUES ('delete', old.rowid, ${oldValues});
+  INSERT INTO ${quote(params.ftsTable)}(rowid, ${columns}) VALUES (new.rowid, ${newValues});
+END`;
+  const tail = `${target} WHEN (${changes}) ${body}`;
   return {
-    encode: (value) => {
-      if (typeof value === "string" && members.has(value))
-        return value;
-      throw new VibeError5({
-        code: "VIBE_VALIDATION",
-        message: `Invalid value for enum ${enumName} on ${model}.${field}`,
-        meta: { model, field, enum: enumName }
-      });
-    },
-    decode: (value) => {
-      if (typeof value === "string" && members.has(value))
-        return value;
-      throw invalidStoredData({ model, field, enum: enumName, value });
-    }
+    create: `CREATE TRIGGER IF NOT EXISTS ${tail};`,
+    definition: `CREATE TRIGGER ${tail}`,
+    legacyDefinition: `CREATE TRIGGER ${target} ${body}`
   };
 }
-function decodeIsNoop(params) {
-  const { scalarType, wire } = params;
-  if (wire === undefined)
-    return false;
-  if (scalarType === "DateTime")
-    return false;
-  if (scalarType === "Json")
-    return wire.json === "parsed";
-  if (scalarType === "Int" || scalarType === "Float")
-    return wire.numbers === "native";
-  return false;
+function renderSqliteFtsUpdateTrigger(params) {
+  const { create, definition } = updateStatements(params);
+  return { create, definition };
 }
-var identity = (value) => value;
-var passthroughCodec = { encode: identity, decode: identity };
-var numberCodec = {
-  encode: identity,
-  decode: (value) => typeof value === "string" ? Number(value) : value
-};
-var bigIntCodec = {
-  encode: (value) => typeof value === "bigint" ? value.toString() : value,
-  decode: (value) => {
-    if (typeof value === "bigint")
-      return value;
-    if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim()))
-      return BigInt(value.trim());
-    if (typeof value === "number" && Number.isSafeInteger(value))
-      return BigInt(value);
-    throw new VibeError5({ code: "VIBE_DATA_INVALID", message: "BigInt requires an integer string or a safe integer", meta: { value } });
+function sqliteFtsUpdateUpgrade(params) {
+  const quoted = '"(?:[^"]|"")+"';
+  const body = new RegExp(`BEGIN\\n  INSERT INTO (${quoted})\\((${quoted}), rowid, (${quoted}(?:, ${quoted})*)\\) VALUES \\('delete', old\\.rowid, `, "g");
+  for (const match of params.create.matchAll(body)) {
+    const ftsTable = sqliteColumnClauses({ sql: `CREATE TABLE x (${match[1]})` })[0].name;
+    const columns = sqliteColumnClauses({ sql: `CREATE TABLE x (${match[3]})` }).map((column) => column.name);
+    if (params.name !== `${ftsTable}_au`)
+      continue;
+    const statements = updateStatements({ table: params.table, ftsTable, columns });
+    if (params.create !== statements.create)
+      continue;
+    const installed = params.installed === statements.legacyDefinition ? "legacy" : params.installed === statements.definition ? "current" : undefined;
+    if (installed === undefined)
+      continue;
+    if (params.tableDefinition === undefined)
+      return { kind: "tableRequired", ftsTable };
+    const tableTail = `${sqliteDialect.quoteIdent({ name: ftsTable })} USING fts5(${columns.map((name) => sqliteDialect.quoteIdent({ name })).join(", ")}, content=${sqliteDialect.quoteStringLiteral({ value: params.table })})`;
+    if (params.tableDefinition !== `CREATE VIRTUAL TABLE ${tableTail}` && params.tableDefinition !== `CREATE VIRTUAL TABLE IF NOT EXISTS ${tableTail};`)
+      continue;
+    return { kind: "recognized", ftsTable, legacyDefinition: statements.legacyDefinition, currentDefinition: statements.definition, drop: `DROP TRIGGER IF EXISTS ${sqliteDialect.quoteIdent({ name: `${ftsTable}_au` })};`, installed };
   }
-};
-var decimalCodec = {
-  encode: (value) => typeof value === "number" || typeof value === "bigint" ? String(value) : value,
-  decode: identity
-};
-var mysqlDecimalCodec = {
-  encode: decimalCodec.encode,
-  decode: (value) => {
-    if (typeof value !== "string" || !value.includes("."))
-      return value;
-    const trimmed = value.replace(/0+$/, "").replace(/\.$/, "");
-    return trimmed === "" || trimmed === "-" ? "0" : trimmed;
+  return;
+}
+// packages/sql/src/dialects/sqlite-session.ts
+var SQLITE_SESSION_SQL = Object.freeze({
+  lockingMode: "PRAGMA main.locking_mode",
+  exclusive: "PRAGMA main.locking_mode = EXCLUSIVE",
+  normal: "PRAGMA main.locking_mode = NORMAL",
+  acquire: "BEGIN EXCLUSIVE",
+  commit: "COMMIT",
+  rollback: "ROLLBACK",
+  touch: "SELECT name FROM main.sqlite_schema LIMIT 1",
+  foreignKeysOn: "PRAGMA foreign_keys = ON"
+});
+// packages/sql/src/composable.ts
+import { VibeError as VibeError9 } from "@vibeorm/schema";
+var fragments = new WeakMap;
+function invalid3(message) {
+  throw new VibeError9({ code: "VIBE_VALIDATION", message });
+}
+function construct(parts) {
+  const snapshot = Object.freeze([...parts]);
+  const fragment = Object.freeze(Object.defineProperty(Object.create(null), "toJSON", {
+    value: () => ({ parts: snapshot })
+  }));
+  fragments.set(fragment, snapshot);
+  return fragment;
+}
+function isSqlFragment(value) {
+  return typeof value === "object" && value !== null && fragments.has(value);
+}
+function partsOf(value) {
+  return fragments.get(value) ?? invalid3("Expected a constructed SQL fragment");
+}
+function containsGreatest(fragment) {
+  return partsOf(fragment).some((part) => typeof part !== "string" && ("greatest" in part));
+}
+function identifier(parts) {
+  if (!Array.isArray(parts) || parts.length === 0 || parts.some((part) => typeof part !== "string" || part.length === 0 || part.includes("\x00"))) {
+    invalid3("SQL identifiers require non-empty, NUL-free name components");
   }
-};
-var ZONE_LESS_DATETIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/;
-var PG_ZONED_DATETIME = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?)(\.\d{1,9})?([+-]\d{2})(?::?(\d{2}))?$/;
-function parseDateTimeText(params) {
-  const trimmed = params.text.trim();
-  if (ZONE_LESS_DATETIME.test(trimmed)) {
-    const asUtc = new Date(`${trimmed.replace(" ", "T").replace(/(\.\d{3})\d+$/, "$1")}Z`);
-    if (!Number.isNaN(asUtc.getTime()))
-      return asUtc;
+}
+function template(strings, ...values) {
+  if (!Array.isArray(strings) || !Array.isArray(strings.raw) || strings.length !== values.length + 1 || strings.some((text) => typeof text !== "string")) {
+    invalid3("Use sql as a template tag");
   }
-  const zoned = PG_ZONED_DATETIME.exec(trimmed);
-  if (zoned !== null) {
-    const [, date, time, fraction, hours, minutes] = zoned;
-    const iso = new Date(`${date}T${time}${(fraction ?? "").slice(0, 4)}${hours}:${minutes ?? "00"}`);
-    if (!Number.isNaN(iso.getTime()))
-      return iso;
+  const parts = [];
+  for (let index = 0;index < strings.length; index++) {
+    parts.push(strings[index]);
+    if (index < values.length) {
+      const value = values[index];
+      if (isSqlFragment(value))
+        parts.push(...partsOf(value));
+      else
+        parts.push(Object.freeze({ value: snapshotSqlValue(value) }));
+    }
   }
-  const parsed = new Date(trimmed);
-  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+  return construct(parts);
 }
-var dateNativeCodec = {
-  encode: (value) => {
-    if (value instanceof Date && !Number.isFinite(value.getTime()) || typeof value === "number" && !Number.isFinite(value) || typeof value === "string" && /^[+-]?infinity$/i.test(value.trim())) {
-      throw new VibeError5({ code: "VIBE_VALIDATION", message: "DateTime parameters require finite timestamps; use an extended timestamp encoder for infinity" });
-    }
-    return value;
+var sql = Object.freeze(Object.assign(template, {
+  text: ({ text }) => {
+    if (typeof text !== "string" || text.includes("\x00"))
+      invalid3("SQL text must be a NUL-free string");
+    return construct([text]);
   },
-  decode: (value) => {
-    const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
-    if (date !== undefined && Number.isFinite(date.getTime()))
-      return date;
-    throw new VibeError5({ code: "VIBE_DATA_INVALID", message: "DateTime requires a finite timestamp; use an explicit extended timestamp decoder for infinity" });
-  }
-};
-var dateTextCodec = {
-  encode: (value) => {
-    dateNativeCodec.encode(value);
-    const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
-    if (date !== undefined && Number.isFinite(date.getTime()))
-      return date.toISOString();
-    throw new VibeError5({ code: "VIBE_VALIDATION", message: "DateTime parameters require a valid finite timestamp" });
+  ident: ({ parts }) => {
+    identifier(parts);
+    return construct([Object.freeze({ ident: Object.freeze([...parts]) })]);
   },
-  decode: dateNativeCodec.decode
-};
-var mysqlDateCodec = {
-  encode: (value) => {
-    dateNativeCodec.encode(value);
-    if (value instanceof Date)
-      return value;
-    if (typeof value === "number") {
-      const parsed = new Date(value);
-      if (!Number.isNaN(parsed.getTime()))
-        return parsed;
-      return value;
-    }
-    if (typeof value === "string")
-      return parseDateTimeText({ text: value }) ?? value;
-    return value;
+  value: ({ value, decoder }) => construct([Object.freeze({ value: snapshotSqlValue(value), ...decoder === undefined ? {} : { decoder } })]),
+  join: ({ items, separator }) => {
+    if (!Array.isArray(items))
+      invalid3("sql.join requires an array");
+    const between = separator === undefined ? [", "] : partsOf(separator);
+    const parts = [];
+    items.forEach((value, index) => {
+      if (index > 0)
+        parts.push(...between);
+      parts.push(...isSqlFragment(value) ? partsOf(value) : [Object.freeze({ value: snapshotSqlValue(value) })]);
+    });
+    return construct(parts);
   },
-  decode: dateNativeCodec.decode
-};
-var MILLISECONDS_PER_DAY = 86400000;
-var TIME_OF_DAY_TEXT = /^(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?(?:([+-])(\d{2})(?::?(\d{2}))?(?::?(\d{2}))?)?$/;
-var pad = (value, width) => String(value).padStart(width, "0");
-var utcMillisecondOfDay = (date) => (date.getTime() % MILLISECONDS_PER_DAY + MILLISECONDS_PER_DAY) % MILLISECONDS_PER_DAY;
-var timeOfDayText = (millisecond) => `${pad(Math.floor(millisecond / 3600000), 2)}:${pad(Math.floor(millisecond / 60000) % 60, 2)}:${pad(Math.floor(millisecond / 1000) % 60, 2)}.${pad(millisecond % 1000, 3)}`;
-function makeTimeOfDayCodec(params) {
-  const suffix = params.zoned ? "+00" : "";
-  return Object.freeze({
-    encode: (value) => {
-      dateNativeCodec.encode(value);
-      const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
-      if (date === undefined || !Number.isFinite(date.getTime())) {
-        throw new VibeError5({ code: "VIBE_VALIDATION", message: "a time-of-day DateTime parameter requires a valid finite Date", meta: { value } });
-      }
-      return `${timeOfDayText(utcMillisecondOfDay(date))}${suffix}`;
-    },
-    decode: (value) => {
-      if (value instanceof Date && Number.isFinite(value.getTime()))
-        return new Date(utcMillisecondOfDay(value));
-      const match = typeof value === "string" ? TIME_OF_DAY_TEXT.exec(value.trim()) : null;
-      if (match !== null) {
-        const [, hours, minutes, seconds, fraction, sign, offsetHours, offsetMinutes, offsetSeconds] = match;
-        const millisecond = Number(hours) * 3600000 + Number(minutes) * 60000 + Number(seconds ?? 0) * 1000 + Number((fraction ?? "").slice(0, 3).padEnd(3, "0"));
-        const offset = sign === undefined ? 0 : (sign === "-" ? -1 : 1) * (Number(offsetHours) * 3600000 + Number(offsetMinutes ?? 0) * 60000 + Number(offsetSeconds ?? 0) * 1000);
-        if (millisecond <= MILLISECONDS_PER_DAY) {
-          return new Date(((millisecond - offset) % MILLISECONDS_PER_DAY + MILLISECONDS_PER_DAY) % MILLISECONDS_PER_DAY);
-        }
+  existing: ({ column }) => {
+    identifier([column]);
+    return construct([Object.freeze({ row: "existing", column })]);
+  },
+  incoming: ({ column }) => {
+    identifier([column]);
+    return construct([Object.freeze({ row: "incoming", column })]);
+  },
+  greatest: ({ values }) => {
+    if (!Array.isArray(values) || values.length !== 2 || values.some((value) => !isSqlFragment(value)))
+      invalid3("sql.greatest requires two SQL fragments");
+    return construct([Object.freeze({ greatest: Object.freeze([...values]) })]);
+  }
+}));
+function renderSqlFragment(params) {
+  const { dialect, collector, conflict } = params;
+  const render = (fragment) => renderSqlFragment({ ...params, fragment });
+  const encode = (part) => {
+    if (part.value === undefined)
+      invalid3("SQL parameters cannot be undefined; use null explicitly");
+    return snapshotSqlValue(part.decoder === undefined ? part.value : part.decoder.encode({ value: part.value, dialect: dialect.name }));
+  };
+  const recording = isSqlBindingCollector({ collector });
+  const recordValue = (part) => recordSqlBinding({
+    collector,
+    source: { kind: "literal", value: part.value },
+    transport: part.decoder === undefined ? sqlParameterTransport({ value: part.value }) : { kind: "plain" },
+    encode: ({ value, dialect: target }) => part.decoder === undefined ? value : part.decoder.encode({ value, dialect: target.name })
+  });
+  const frameOperand = (fragment) => {
+    const parts = partsOf(fragment).filter((part) => part !== "");
+    const only = parts.length === 1 ? parts[0] : undefined;
+    if (recording && only !== undefined && typeof only !== "string" && "value" in only) {
+      if (only.decoder !== undefined && resultScalarContract({ decoder: only.decoder }) === undefined)
+        throw new VibeError9({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Reusable SQL cannot compile an opaque encoder whose output controls a greatest NULL frame" });
+      if (only.value === null) {
+        if (only.decoder !== undefined)
+          recordSqlBindingCheck({ collector, check: () => {
+            if (encode({ ...only, value: snapshotSqlValue(only.value) }) !== null)
+              throw new VibeError9({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Reusable SQL NULL frame encoding changed its declared structure" });
+          } });
+        return "NULL";
       }
-      throw new VibeError5({ code: "VIBE_DATA_INVALID", message: "a time-of-day DateTime column returned a value that is not a time of day", meta: { value } });
+      const text = recordValue(only);
+      return dialect.greatestForm === "wrapped-frame" ? `(SELECT ${text})` : text;
+    }
+    const value = only !== undefined && typeof only !== "string" && "value" in only ? { encoded: encode(only) } : undefined;
+    if (value !== undefined && value.encoded === null)
+      return "NULL";
+    const text = value === undefined ? render(fragment) : collector.add(value.encoded);
+    return dialect.greatestForm === "wrapped-frame" ? `(SELECT ${text})` : text;
+  };
+  return partsOf(params.fragment).map((part) => {
+    if (typeof part === "string")
+      return part;
+    if ("value" in part)
+      return recording ? recordValue(part) : collector.add(encode(part));
+    if ("ident" in part)
+      return part.ident.map((name) => dialect.quoteIdent({ name })).join(".");
+    if ("row" in part) {
+      if (conflict === undefined)
+        invalid3("Existing/incoming row references require a conflict update");
+      const name = conflict.columns === undefined ? part.column : conflict.columns[part.column];
+      if (name === undefined)
+        invalid3(`Unknown conflict-expression field "${part.column}"`);
+      const ref = dialect.excludedRowRef;
+      const qualifier = part.row === "existing" ? dialect.quoteIdent({ name: conflict.table }) : ref.form === "keyword" ? ref.name : dialect.quoteIdent({ name: ref.alias });
+      return `${qualifier}.${dialect.quoteIdent({ name })}`;
     }
-  });
-}
-var timeCodec = makeTimeOfDayCodec({ zoned: false });
-var timetzCodec = makeTimeOfDayCodec({ zoned: true });
-function timeOfDayCodec(params) {
-  const type = timeOfDayType({ nativeType: params.nativeType });
-  return type === "timetz" ? timetzCodec : type === "time" ? timeCodec : undefined;
+    if (dialect.greatestForm === "native")
+      return `GREATEST(${part.greatest.map(render).join(", ")})`;
+    if (!part.greatest.some(containsGreatest)) {
+      return render(part.greatest.reduce((left, right) => sql`(CASE WHEN ${left} IS NULL THEN ${right} WHEN ${right} IS NULL THEN ${left} WHEN ${left} >= ${right} THEN ${left} ELSE ${right} END)`));
+    }
+    const [left, right] = part.greatest.map(frameOperand);
+    const [a, b, frame] = ["a", "b", "g"].map((name) => dialect.quoteIdent({ name }));
+    return `(SELECT CASE WHEN ${a} IS NULL THEN ${b} WHEN ${b} IS NULL THEN ${a} WHEN ${a} >= ${b} THEN ${a} ELSE ${b} END FROM (SELECT ${left} AS ${a}, ${right} AS ${b}) AS ${frame})`;
+  }).join("");
 }
-var booleanIntCodec = {
-  encode: (value) => typeof value === "boolean" ? value ? 1 : 0 : value,
-  decode: (value) => typeof value === "number" ? value !== 0 : value
-};
-var booleanNativeInCodec = {
-  encode: identity,
-  decode: booleanIntCodec.decode
-};
-var jsonCodec = {
-  encode: (value) => JSON.stringify(value),
-  decode: (value) => {
-    if (typeof value !== "string")
-      return value;
-    try {
-      return JSON.parse(value);
-    } catch (cause) {
-      throw new VibeError5({
-        code: "VIBE_INTERNAL",
-        message: "a Json column returned text that is not valid JSON",
-        meta: { value },
-        cause
-      });
+function mapConflictColumns(params) {
+  return construct(partsOf(params.fragment).map((part) => {
+    if (typeof part === "string")
+      return part;
+    if ("row" in part) {
+      const column = Object.hasOwn(params.columns, part.column) ? params.columns[part.column] : undefined;
+      if (column === undefined)
+        invalid3(`Unknown conflict-expression field "${part.column}"`);
+      return Object.freeze({ ...part, column });
     }
-  }
-};
-function shortestFloat32(params) {
+    if ("greatest" in part)
+      return Object.freeze({ greatest: Object.freeze(part.greatest.map((fragment) => mapConflictColumns({ ...params, fragment }))) });
+    return part;
+  }));
+}
+function compileSql(params) {
+  const collector = new ParamCollector(params.dialect);
+  const text = renderSqlFragment({ dialect: params.dialect, fragment: params.query, collector });
+  return { text, values: collector.values };
+}
+function sqlUsesIncoming(params) {
+  return partsOf(params.fragment).some((part) => typeof part !== "string" && (("row" in part) && part.row === "incoming" || ("greatest" in part) && part.greatest.some((fragment) => sqlUsesIncoming({ fragment }))));
+}
+// packages/sql/src/query-plan.ts
+import { VibeError as VibeError10 } from "@vibeorm/schema";
+var queries = new WeakMap;
+var commands = new WeakMap;
+var reusableQueries = new WeakMap;
+var reusableCommands = new WeakMap;
+function invalid4(message) {
+  throw new VibeError10({ code: "VIBE_VALIDATION", message });
+}
+function createSqlQuery(params) {
+  if (typeof params.render !== "function" || typeof params.decoder?.decode !== "function")
+    invalid4("SQL queries require a renderer and result decoder");
+  const query = Object.freeze(Object.create(null));
+  queries.set(query, Object.freeze({ render: params.render, decoder: params.decoder }));
+  return query;
+}
+function createSqlCommand(params) {
+  if (typeof params.render !== "function")
+    invalid4("SQL commands require a renderer");
+  const command = Object.freeze(Object.create(null));
+  commands.set(command, params.render);
+  return command;
+}
+function isSqlQuery(value) {
+  return typeof value === "object" && value !== null && queries.has(value);
+}
+function isSqlCommand(value) {
+  return typeof value === "object" && value !== null && commands.has(value);
+}
+function isReusableSqlQuery(value) {
+  return typeof value === "object" && value !== null && reusableQueries.has(value);
+}
+function isReusableSqlCommand(value) {
+  return typeof value === "object" && value !== null && reusableCommands.has(value);
+}
+function createReusableSqlQuery(params) {
+  const state = queries.get(params.query) ?? invalid4("Expected an authentic SQL row query");
+  sqlInputScopeKeys({ scope: params.scope });
+  const query = Object.freeze(Object.create(null));
+  reusableQueries.set(query, { ...state, scope: params.scope, cache: new WeakMap });
+  return query;
+}
+function createReusableSqlCommand(params) {
+  const render = commands.get(params.query) ?? invalid4("Expected an authentic SQL command");
+  sqlInputScopeKeys({ scope: params.scope });
+  const query = Object.freeze(Object.create(null));
+  reusableCommands.set(query, { render, scope: params.scope, cache: new WeakMap });
+  return query;
+}
+function compiledTemplate(params) {
+  const cached = params.state.cache.get(params.dialect);
+  if (cached !== undefined)
+    return cached;
+  const collector = new ParamCollector(params.dialect);
+  startSqlBindingCollection({ collector, dialect: params.dialect, scope: params.state.scope });
+  const text = params.state.render({ dialect: params.dialect, collector });
+  if (collector.count() > params.dialect.paramBudget)
+    invalid4("SQL query exceeds this dialect's parameter budget; statements are never split implicitly");
+  const program = finishSqlBindingCollection({ collector });
+  const compiled = Object.freeze({ text, program });
+  params.state.cache.set(params.dialect, compiled);
+  return compiled;
+}
+function executionHandle(params) {
   const { value } = params;
-  if (value === 0 || !Number.isFinite(value))
-    return value;
-  const target = Math.fround(value);
-  for (let precision = 1;precision <= 9; precision++) {
-    const candidate = Number(value.toPrecision(precision));
-    if (Math.fround(candidate) === target)
-      return candidate;
-  }
-  return value;
+  return queries.has(value) || commands.has(value) || reusableQueries.has(value) || reusableCommands.has(value) || isSqlFragment(value) || isSqlInput(value) || sqlInputScopeHandle(params);
 }
-var float32Codec = {
-  encode: identity,
-  decode: (value) => {
-    const number = typeof value === "string" ? Number(value) : value;
-    return typeof number === "number" ? shortestFloat32({ value: number }) : number;
-  }
-};
-var booleanFromText = (text) => text === "t" ? true : text === "f" ? false : text;
-var bytesFromText = (text) => /^\\x(?:[0-9a-fA-F]{2})*$/.test(text) ? new Uint8Array(Buffer.from(text.slice(2), "hex")) : text;
-function postgresArrayElementFromText(params) {
-  switch (params.scalarType) {
-    case "Boolean":
-      return booleanFromText;
-    case "Bytes":
-      return bytesFromText;
-    case "Json":
-      return jsonCodec.decode;
-    default:
-      return null;
-  }
+function bindTemplate(params) {
+  const { scope } = params.state;
+  return bindSqlBindingProgram({ program: params.compiled.program, params: params.inputs, isHandle: (value) => executionHandle({ scope, value }) });
 }
-var POSTGRES_CODECS = {
-  String: passthroughCodec,
-  Boolean: passthroughCodec,
-  Int: numberCodec,
-  BigInt: bigIntCodec,
-  Float: numberCodec,
-  Decimal: decimalCodec,
-  DateTime: dateNativeCodec,
-  Json: jsonCodec,
-  Bytes: passthroughCodec
-};
-var SQLITE_CODECS = {
-  String: passthroughCodec,
-  Boolean: booleanIntCodec,
-  Int: numberCodec,
-  BigInt: bigIntCodec,
-  Float: numberCodec,
-  Decimal: decimalCodec,
-  DateTime: dateTextCodec,
-  Json: jsonCodec,
-  Bytes: passthroughCodec
-};
-var MYSQL_CODECS = {
-  String: passthroughCodec,
-  Boolean: booleanNativeInCodec,
-  Int: numberCodec,
-  BigInt: bigIntCodec,
-  Float: numberCodec,
-  Decimal: mysqlDecimalCodec,
-  DateTime: mysqlDateCodec,
-  Json: jsonCodec,
-  Bytes: passthroughCodec
-};
-var DIALECT_CODECS = {
-  postgres: POSTGRES_CODECS,
-  sqlite: SQLITE_CODECS,
-  mysql: MYSQL_CODECS
-};
-
-// packages/sql/src/result-decoder.ts
-function refuse(encoding, message) {
-  throw new VibeError6({ code: encoding ? "VIBE_VALIDATION" : "VIBE_DATA_INVALID", message });
+function compileReusableSqlQuery(params) {
+  const state = reusableQueries.get(params.query) ?? invalid4("Expected an authentic reusable SQL row query");
+  const compiled = compiledTemplate({ dialect: params.dialect, state });
+  return { text: compiled.text, values: bindTemplate({ compiled, state, inputs: params.params }), decoder: state.decoder };
 }
-function scalar(type, valid) {
-  const convert = (params, encoding) => {
-    const { value, dialect } = params;
-    if (value === null || value === undefined)
-      refuse(encoding, `A non-null ${type} projection received null or a missing column`);
-    if (type === "BigInt" && !(typeof value === "bigint" || typeof value === "string" && /^[+-]?\d+$/.test(value) || typeof value === "number" && Number.isSafeInteger(value))) {
-      refuse(encoding, "BigInt requires exact integer text, bigint, or a safe integer");
-    }
-    if (type === "Boolean" && value !== true && value !== false && value !== 0 && value !== 1)
-      refuse(encoding, "Boolean requires true, false, 0, or 1");
-    if (type === "Decimal" && typeof value === "number")
-      refuse(encoding, "Decimal requires exact decimal text, not a floating-point number");
-    if ((type === "Int" || type === "Float") && typeof value === "string" && !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value)) {
-      refuse(encoding, `Invalid ${type} text`);
-    }
-    const codec = DIALECT_CODECS[dialect][type];
-    const result = type === "Json" && params.wire?.json === "parsed" ? value : codec.decode(value);
-    if (!valid(result))
-      refuse(encoding, `Invalid ${type} projection value`);
-    return result;
-  };
-  return Object.freeze({
-    decode: (params) => convert(params, false),
-    encode: (params) => {
-      const value = type === "Json" ? params.value : convert(params, true);
-      if (value === undefined || value === null)
-        refuse(true, `A non-null ${type} parameter cannot be null or undefined`);
-      return DIALECT_CODECS[params.dialect][type].encode(value);
-    }
-  });
+function compileReusableSqlCommand(params) {
+  const state = reusableCommands.get(params.query) ?? invalid4("Expected an authentic reusable SQL command");
+  const compiled = compiledTemplate({ dialect: params.dialect, state });
+  return { text: compiled.text, values: bindTemplate({ compiled, state, inputs: params.params }) };
+}
+function compileSqlQuery(params) {
+  const state = queries.get(params.query) ?? invalid4("Expected an authentic SQL row query");
+  const collector = new ParamCollector(params.dialect);
+  const text = state.render({ dialect: params.dialect, collector });
+  if (collector.values.length > params.dialect.paramBudget)
+    invalid4("SQL query exceeds this dialect's parameter budget; statements are never split implicitly");
+  return { text, values: collector.values, decoder: state.decoder };
+}
+function compileSqlCommand(params) {
+  const render = commands.get(params.query) ?? invalid4("Expected an authentic SQL command");
+  const collector = new ParamCollector(params.dialect);
+  const text = render({ dialect: params.dialect, collector });
+  if (collector.values.length > params.dialect.paramBudget)
+    invalid4("SQL command exceeds this dialect's parameter budget; statements are never split implicitly");
+  return { text, values: collector.values };
 }
-var stringDecoder = scalar("String", (value) => typeof value === "string");
-var dateDecoder = scalar("DateTime", (value) => value instanceof Date && Number.isFinite(value.getTime()));
-var extendedDecoder = Object.freeze({
-  decode: (params) => {
-    if (params.value === "infinity" || params.value === Infinity)
-      return "infinity";
-    if (params.value === "-infinity" || params.value === -Infinity)
-      return "-infinity";
-    return dateDecoder.decode(params);
-  },
-  encode: (params) => {
-    if (params.value === "infinity" || params.value === "-infinity") {
-      if (params.dialect !== "postgres")
-        throw new VibeError6({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Timestamp infinity parameters require PostgreSQL" });
-      return params.value;
-    }
-    return dateDecoder.encode(params);
-  }
-});
-var decode = Object.freeze({
-  string: stringDecoder,
-  boolean: scalar("Boolean", (value) => typeof value === "boolean"),
-  int: scalar("Int", (value) => typeof value === "number" && Number.isSafeInteger(value)),
-  float: scalar("Float", (value) => typeof value === "number" && Number.isFinite(value)),
-  bigInt: scalar("BigInt", (value) => typeof value === "bigint"),
-  decimal: scalar("Decimal", (value) => typeof value === "string" && /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value)),
-  dateTime: dateDecoder,
-  extendedDateTime: extendedDecoder,
-  json: scalar("Json", (value) => value !== undefined),
-  bytes: scalar("Bytes", (value) => value instanceof Uint8Array),
-  nullable: ({ decoder }) => Object.freeze({
-    decode: (params) => params.value === null ? null : decoder.decode(params),
-    encode: (params) => params.value === null ? null : decoder.encode(params)
-  }),
-  array: ({ decoder }) => Object.freeze({
-    decode: (params) => {
-      const raw = params.value;
-      const value = params.dialect === "postgres" && typeof raw === "string" ? parsePgArrayLiteral({ literal: raw }) : ArrayBuffer.isView(raw) && ("length" in raw) ? Array.from(raw) : raw;
-      if (!Array.isArray(value))
-        refuse(false, "Expected an array projection");
-      return value.map((element) => decoder.decode({ ...params, value: element }));
-    },
-    encode: (params) => {
-      if (!Array.isArray(params.value))
-        refuse(true, "Expected an array parameter");
-      return params.value.map((value) => decoder.encode({ ...params, value }));
-    }
-  }),
-  enum: ({ values }) => {
-    const members = new Set(values);
-    return Object.freeze({
-      decode: ({ value }) => typeof value === "string" && members.has(value) ? value : refuse(false, "Unknown enum projection member"),
-      encode: ({ value }) => typeof value === "string" && members.has(value) ? value : refuse(true, "Unknown enum parameter member")
-    });
-  },
-  object: ({ fields }) => {
-    const entries = Object.entries(fields);
-    const convert = (params, encoding) => {
-      if (typeof params.value !== "object" || params.value === null || Array.isArray(params.value))
-        refuse(encoding, "Expected a result row object");
-      const row = params.value;
-      return Object.fromEntries(entries.map(([name, decoder]) => {
-        if (!Object.hasOwn(row, name))
-          refuse(encoding, `Missing projection column "${name}"`);
-        return [name, encoding ? decoder.encode({ ...params, value: row[name] }) : decoder.decode({ ...params, value: row[name] })];
-      }));
-    };
-    return Object.freeze({ decode: (params) => convert(params, false), encode: (params) => convert(params, true) });
-  }
-});
 // packages/sql/src/exclusion.ts
-import { VibeError as VibeError8, fieldTypeIdentity as fieldTypeIdentity2, isEnumType as isEnumType2, unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
+import { VibeError as VibeError12, fieldTypeIdentity as fieldTypeIdentity2, isEnumType as isEnumType2, unsupportedCapability as unsupportedCapability10 } from "@vibeorm/schema";
 
 // packages/sql/src/predicate.ts
-import { VibeError as VibeError7, fieldTypeIdentity, isEnumType, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+import { VibeError as VibeError11, assertPredicateCapabilities, fieldTypeIdentity, isEnumType, unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
 function renderPredicate(params) {
+  assertPredicateCapabilities({ predicate: params.predicate, dialect: params.dialect.name, usage: params.usage });
   if (params.usage === "exclusionPredicate" && !params.dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability8({ dialect: params.dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability9({ dialect: params.dialect.name, feature: "exclusionConstraints" });
   if (params.usage === "indexPredicate" && !params.dialect.capabilities.partialIndexes) {
-    throw unsupportedCapability8({ dialect: params.dialect.name, feature: "partialIndexes" });
+    throw unsupportedCapability9({ dialect: params.dialect.name, feature: "partialIndexes" });
   }
   const context = {
     model: params.model,
@@ -1212,7 +1698,8 @@ var PRECEDENCE = {
   not: 3,
   compare: 4,
   inList: 4,
-  isNull: 4
+  isNull: 4,
+  isTrue: 4
 };
 var COMPARISON_SQL = {
   eq: "=",
@@ -1230,7 +1717,7 @@ var INT64_MIN = -(2n ** 63n);
 var INT64_MAX = 2n ** 63n - 1n;
 function refuse2(params) {
   const { context, rule, message } = params;
-  throw new VibeError7({
+  throw new VibeError11({
     code: "VIBE_SCHEMA_INVALID",
     message: `${context.site} on "${context.model.name}": ${message}`,
     meta: { rule, model: context.model.name, site: context.site, ...params.meta ?? {} }
@@ -1263,14 +1750,16 @@ function renderNode(params) {
     }
     case "not":
       return `NOT ${renderChild({ node: node.operand, parent: "not", context })}`;
+    case "isTrue":
+      return `COALESCE(${renderNode({ node: node.operand, context })}, FALSE)`;
     case "isNull": {
-      const field = resolveField({ name: node.field.name, context });
+      const field = resolveField({ name: node.field.name, context, nullTest: true });
       return `${quoteColumn({ field, context })} IS ${node.negate === true ? "NOT NULL" : "NULL"}`;
     }
     case "compare": {
-      const left = resolveField({ name: node.left.name, context });
-      const right = renderOperand({ operand: node.right, field: left, context });
-      return `${compareColumn({ field: left, context })} ${COMPARISON_SQL[node.op]} ${right}`;
+      const left = renderExpression({ expression: node.left, context });
+      const right = renderOperand({ operand: node.right, field: left.field, context });
+      return `${left.text} ${COMPARISON_SQL[node.op]} ${right}`;
     }
     case "inList": {
       if (node.values.length === 0) {
@@ -1314,7 +1803,7 @@ function resolveField(params) {
       meta: { field: name }
     });
   }
-  if (field.type === "Json" || field.type === "Bytes") {
+  if (params.nullTest !== true && (field.type === "Json" || field.type === "Bytes")) {
     refuse2({
       context,
       rule: "predicate-unsupported-type",
@@ -1323,7 +1812,7 @@ function resolveField(params) {
     });
   }
   if (context.usage === "check" && context.dialect.name === "mysql" && field.default?.kind === "autoincrement") {
-    throw unsupportedCapability8({
+    throw unsupportedCapability9({
       dialect: "mysql",
       feature: `CHECK constraint referencing auto-increment column "${context.model.name}.${name}"`,
       hint: "mysql refuses this with error 3818 \u2014 enforce the rule in application code or on a non-generated column"
@@ -1340,22 +1829,43 @@ function compareColumn(params) {
   const quoted = quoteColumn({ field, context });
   return context.dialect.name === "sqlite" && field.type === "Decimal" ? `CAST(${quoted} AS REAL)` : quoted;
 }
+function renderExpression(params) {
+  const { expression, context } = params;
+  if (expression.kind === "field") {
+    const field = resolveField({ name: expression.name, context });
+    return { text: compareColumn({ field, context }), field };
+  }
+  if (expression.kind === "jsonText") {
+    const field = resolveField({ name: expression.field.name, context, nullTest: true });
+    if (field.type !== "Json")
+      refuse2({ context, rule: "predicate-type-mismatch", message: `jsonText requires a scalar Json field, not "${field.name}"` });
+    if (!Array.isArray(expression.path) || Array.from(expression.path).some((segment) => typeof segment !== "string" || segment.includes("\x00"))) {
+      refuse2({ context, rule: "predicate-json-path", message: "jsonText requires a string-only path without NUL bytes" });
+    }
+    const path = expression.path.map((value) => context.dialect.quoteStringLiteral({ value })).join(", ");
+    return { text: `(${quoteColumn({ field, context })} #>> ARRAY[${path}]::text[])`, field: { ...field, type: "String" } };
+  }
+  const inner = renderExpression({ expression: expression.expression, context });
+  if (inner.field.type !== "String")
+    refuse2({ context, rule: "predicate-type-mismatch", message: "length requires a text expression" });
+  return { text: `length(${inner.text})`, field: { ...inner.field, type: "Int" } };
+}
 function renderOperand(params) {
   const { operand, field, context } = params;
   if (operand.kind === "value")
     return renderLiteral({ value: operand, field, context });
-  const other = resolveField({ name: operand.name, context });
+  const other = renderExpression({ expression: operand, context });
   const leftType = fieldTypeIdentity({ type: field.type });
-  const rightType = fieldTypeIdentity({ type: other.type });
+  const rightType = fieldTypeIdentity({ type: other.field.type });
   if (leftType !== rightType) {
     refuse2({
       context,
       rule: "predicate-type-mismatch",
-      message: `compares "${field.name}" (${leftType}) with "${other.name}" (${rightType}) \u2014 both sides of a comparison need the same scalar type`,
-      meta: { field: field.name, other: other.name, fieldType: leftType, otherType: rightType }
+      message: `compares "${field.name}" (${leftType}) with "${other.field.name}" (${rightType}) \u2014 both sides of a comparison need the same scalar type`,
+      meta: { field: field.name, other: other.field.name, fieldType: leftType, otherType: rightType }
     });
   }
-  return compareColumn({ field: other, context });
+  return other.text;
 }
 function renderLiteral(params) {
   const { field, context } = params;
@@ -1493,23 +2003,23 @@ function describe(params) {
 }
 
 // packages/sql/src/exclusion.ts
-function invalid2(rule) {
-  throw new VibeError8({ code: "VIBE_SCHEMA_INVALID", message: `Invalid exclusion constraint: ${rule}`, meta: { rule: `exclusion-${rule}` } });
+function invalid5(rule) {
+  throw new VibeError12({ code: "VIBE_SCHEMA_INVALID", message: `Invalid exclusion constraint: ${rule}`, meta: { rule: `exclusion-${rule}` } });
 }
 function compileExclusion(params) {
   const { exclusion: spec, model, dialect } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability9({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability10({ dialect: dialect.name, feature: "exclusionConstraints" });
   if (!spec.name || spec.name.includes("\x00"))
-    invalid2("name");
+    invalid5("name");
   if (!["int8range", "tsrange", "tstzrange"].includes(spec.range.type))
-    invalid2("range-type");
+    invalid5("range-type");
   if (!["[)", "[]", "()", "(]"].includes(spec.range.bounds))
-    invalid2("bounds");
+    invalid5("bounds");
   const field = (name) => {
     const value = model.fields.find((entry) => entry.name === name);
     if (value === undefined || value.isList || value.isUnsupported)
-      invalid2("field");
+      invalid5("field");
     return value;
   };
   const endpoint = (value) => {
@@ -1517,17 +2027,17 @@ function compileExclusion(params) {
       return "NULL";
     const infinity = "infinity" in value ? value.infinity : value.nullAs;
     if (infinity !== undefined && (spec.range.type === "int8range" || !["infinity", "-infinity"].includes(infinity)))
-      invalid2("infinity");
+      invalid5("infinity");
     const literal = infinity === undefined ? undefined : `${dialect.quoteStringLiteral({ value: infinity })}::${spec.range.type === "tsrange" ? "timestamp" : "timestamptz"}`;
     if ("infinity" in value)
       return literal;
     const column = field(value.field);
     if (fieldTypeIdentity2({ type: column.type }) !== (spec.range.type === "int8range" ? "BigInt" : "DateTime"))
-      invalid2("range-field-type");
+      invalid5("range-field-type");
     if (column.type === "DateTime") {
       const timezone = /timestamptz|timestamp.*with time zone/i.test(column.nativeType ?? "timestamptz");
       if (timezone !== (spec.range.type === "tstzrange"))
-        invalid2("range-timezone");
+        invalid5("range-timezone");
     }
     const sql = dialect.quoteIdent({ name: column.dbName ?? column.name });
     return literal === undefined ? sql : `COALESCE(${sql}, ${literal})`;
@@ -1535,15 +2045,15 @@ function compileExclusion(params) {
   const keys = spec.keys.map((key) => {
     if ("expression" in key) {
       if (!key.expression.trim() || key.expression.includes("\x00") || key.fields.length === 0)
-        invalid2("expression");
+        invalid5("expression");
       key.fields.forEach(field);
       return `(${key.expression}) WITH =`;
     }
     const column = field(key.field);
     if (column.isOptional)
-      invalid2("nullable-key-requires-expression");
+      invalid5("nullable-key-requires-expression");
     if (!isEnumType2(column.type) && !["String", "Int", "BigInt", "Float", "Decimal", "Boolean", "DateTime"].includes(fieldTypeIdentity2({ type: column.type })))
-      invalid2("key-type");
+      invalid5("key-type");
     return `${dialect.quoteIdent({ name: column.dbName ?? column.name })} WITH =`;
   });
   keys.push(`${spec.range.type}(${endpoint(spec.range.lower)}, ${endpoint(spec.range.upper)}, ${dialect.quoteStringLiteral({ value: spec.range.bounds })}) WITH &&`);
@@ -1552,13 +2062,13 @@ function compileExclusion(params) {
 }
 function renderExclusionSetup(params) {
   if (!params.dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability9({ dialect: params.dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability10({ dialect: params.dialect.name, feature: "exclusionConstraints" });
   return params.exclusion.requiredExtensions.map((name) => `CREATE EXTENSION IF NOT EXISTS ${params.dialect.quoteIdent({ name })};`);
 }
 function renderExclusionDdl(params) {
   const { dialect, table, exclusion, operation } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability9({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability10({ dialect: dialect.name, feature: "exclusionConstraints" });
   const target = `ALTER TABLE ${dialect.quoteIdent({ name: table })}`;
   if (operation === "drop")
     return [`${target} DROP CONSTRAINT ${dialect.quoteIdent({ name: exclusion.name })};`];
@@ -1567,14 +2077,14 @@ function renderExclusionDdl(params) {
 function renderExclusionCatalog(params) {
   const { dialect, probe } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability9({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability10({ dialect: dialect.name, feature: "exclusionConstraints" });
   const scope = probe === undefined ? `n.nspname = ${dialect.quoteStringLiteral({ value: params.namespace ?? "public" })}` : `t.oid = ${dialect.quoteStringLiteral({ value: probe })}::regclass`;
   return `SELECT t.relname AS table_name, c.conname AS constraint_name, pg_catalog.pg_get_constraintdef(c.oid, true) AS definition, c.convalidated AS validated, i.indisvalid AS valid, i.indisready AS ready FROM pg_catalog.pg_constraint c JOIN pg_catalog.pg_class t ON t.oid = c.conrelid JOIN pg_catalog.pg_namespace n ON n.oid = t.relnamespace JOIN pg_catalog.pg_index i ON i.indexrelid = c.conindid WHERE c.contype = 'x' AND ${scope} ORDER BY t.relname, c.conname`;
 }
 function renderExclusionProbe(params) {
   const { dialect, table, probe, definition } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability9({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability10({ dialect: dialect.name, feature: "exclusionConstraints" });
   return [`CREATE TEMP TABLE ${dialect.quoteIdent({ name: probe })} (LIKE ${dialect.quoteIdent({ name: params.namespace ?? "public" })}.${dialect.quoteIdent({ name: table })})`, `ALTER TABLE ${dialect.quoteIdent({ name: probe })} ADD CONSTRAINT ${dialect.quoteIdent({ name: `${probe}_x` })} ${definition}`];
 }
 // packages/sql/src/ast.ts
@@ -1653,7 +2163,7 @@ function chainVetoToken(params) {
   return;
 }
 // packages/sql/src/locks.ts
-import { internalError, unsupportedCapability as unsupportedCapability10 } from "@vibeorm/schema";
+import { internalError, unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
 var ROW_LOCK_PROSE = Object.freeze({
   strengths: Object.freeze({
     update: "FOR UPDATE",
@@ -1673,7 +2183,7 @@ function renderRowLockClause(params) {
   if (syntax === null) {
     if (lock.strength === "update" && lock.wait === "wait")
       return null;
-    throw unsupportedCapability10({
+    throw unsupportedCapability11({
       dialect: dialect.name,
       feature: `a ${describeRowLock({ lock })} locking read`,
       hint: `${dialect.name} has no locking-read clause at all`
@@ -1681,7 +2191,7 @@ function renderRowLockClause(params) {
   }
   const strengthText = syntax.strengths[lock.strength];
   if (strengthText === undefined) {
-    throw unsupportedCapability10({
+    throw unsupportedCapability11({
       dialect: dialect.name,
       feature: `the ${describeRowLock({ lock: { ...lock, wait: "wait" } })} row-lock strength`,
       hint: `${dialect.name} can express: ${Object.keys(syntax.strengths).join(", ")}`
@@ -1689,7 +2199,7 @@ function renderRowLockClause(params) {
   }
   const waitText = syntax.wait[lock.wait];
   if (waitText === undefined) {
-    throw unsupportedCapability10({
+    throw unsupportedCapability11({
       dialect: dialect.name,
       feature: `the "${lock.wait}" lock wait policy`,
       hint: `${dialect.name} can express: ${Object.keys(syntax.wait).join(", ")}`
@@ -1708,7 +2218,7 @@ function renderAdvisoryLock(params) {
   const { dialect, statement, collector } = params;
   const functions = dialect.advisoryLockFunctions;
   if (functions === null) {
-    throw unsupportedCapability10({
+    throw unsupportedCapability11({
       dialect: dialect.name,
       feature: "advisory locks",
       hint: dialect.name === "mysql" ? "mysql's GET_LOCK is SESSION-scoped \u2014 it survives a rollback, so it cannot be released with the transaction" : `${dialect.name} has no advisory-lock functions`
@@ -1739,7 +2249,7 @@ function assertInt32(params) {
 var JSON_TRANSPORT = Object.freeze({ chunkSize: 100 });
 function projectionOutputName(params) {
   const { column } = params;
-  return column.transform === undefined ? column.alias ?? column.name : column.name;
+  return column.transform === undefined || column.transform === "jsonText" ? column.alias ?? column.name : column.name;
 }
 // packages/sql/src/dialects/postgres.ts
 var postgresDialect = {
@@ -1773,6 +2283,7 @@ var postgresDialect = {
     "array_ends_with"
   ],
   jsonParamCast: "::text::jsonb",
+  valueCastTypes: Object.freeze({ String: "TEXT", Boolean: "BOOLEAN", Int: "INTEGER", BigInt: "BIGINT", Float: "DOUBLE PRECISION", Decimal: "NUMERIC", DateTime: "TIMESTAMPTZ", Json: "JSONB", Bytes: "BYTEA" }),
   lastInsertIdSql: null,
   rowLockSyntax: {
     strengths: Object.freeze({
@@ -1807,6 +2318,9 @@ var postgresDialect = {
   placeholder({ index }) {
     return `$${index}`;
   },
+  jsonTextProjection({ expression }) {
+    return `${expression}::text`;
+  },
   renderDbNow({ offsetSeconds, collector }) {
     if (offsetSeconds === 0)
       return "now()";
@@ -1846,6 +2360,7 @@ var mysqlDialect = {
     "array_ends_with"
   ],
   jsonParamCast: "",
+  valueCastTypes: Object.freeze({ String: "CHAR", Boolean: "UNSIGNED", Int: "SIGNED", BigInt: "SIGNED", Float: "DOUBLE", Decimal: "DECIMAL(65, 30)", DateTime: "DATETIME(3)", Json: "JSON", Bytes: "BINARY" }),
   lastInsertIdSql: "SELECT LAST_INSERT_ID() AS `id`",
   rowLockSyntax: {
     strengths: Object.freeze({ update: "FOR UPDATE", share: "FOR SHARE" }),
@@ -1865,6 +2380,9 @@ var mysqlDialect = {
   placeholder() {
     return "?";
   },
+  jsonTextProjection({ expression }) {
+    return `CAST(${expression} AS CHAR)`;
+  },
   renderDbNow({ offsetSeconds, collector }) {
     if (offsetSeconds === 0)
       return "NOW(6)";
@@ -1881,7 +2399,7 @@ function getSqlDialect(params) {
   return SQL_DIALECTS[params.dialect];
 }
 // packages/sql/src/dialects/diagnostics.ts
-import { unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
 var QUERIES = Object.freeze({
   postgresJsonWire: { dialect: "postgres", text: `SELECT '{"__vibeorm":1}'::jsonb AS "probe"` },
   sqliteTriggers: { dialect: "sqlite", text: "SELECT name, tbl_name, sql FROM sqlite_master WHERE type = 'trigger'" }
@@ -1889,7 +2407,7 @@ var QUERIES = Object.freeze({
 function renderDiagnostic(params) {
   const query = QUERIES[params.query];
   if (params.dialect.name !== query.dialect) {
-    throw unsupportedCapability11({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
+    throw unsupportedCapability12({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
   }
   return { text: query.text, values: [], returning: "none" };
 }
@@ -1898,7 +2416,7 @@ function isFixedDiagnostic(params) {
 }
 
 // packages/sql/src/dialects/postgres-diagnostics.ts
-import { VibeError as VibeError9, unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
+import { VibeError as VibeError13, unsupportedCapability as unsupportedCapability13 } from "@vibeorm/schema";
 function renderPostgresExplain(params) {
   const { dialect, query, options } = params;
   requirePostgres({ dialect, feature: "query plan inspection (EXPLAIN)" });
@@ -1933,7 +2451,7 @@ var POSTGRES_WORKLOAD_LIMITS = Object.freeze({
 });
 function requirePostgres(params) {
   if (params.dialect.name !== "postgres") {
-    throw unsupportedCapability12({
+    throw unsupportedCapability13({
       dialect: params.dialect.name,
       feature: params.feature,
       hint: "plan inspection and workload statistics are PostgreSQL-shaped; portable operation tracing works on every dialect"
@@ -1951,7 +2469,7 @@ function renderPostgresWorkload(params) {
   if (query === "statementSnapshot") {
     const bounded = limit ?? 20;
     if (!Number.isInteger(bounded) || bounded < POSTGRES_WORKLOAD_LIMITS.minLimit || bounded > POSTGRES_WORKLOAD_LIMITS.maxLimit) {
-      throw new VibeError9({
+      throw new VibeError13({
         code: "VIBE_CONFIG",
         message: `workload snapshot limit must be an integer between ${POSTGRES_WORKLOAD_LIMITS.minLimit} and ${POSTGRES_WORKLOAD_LIMITS.maxLimit}, got ${String(limit)}`,
         meta: { limit }
@@ -1970,7 +2488,7 @@ function renderPostgresWorkload(params) {
 function requireArg(params) {
   const { value, name, query } = params;
   if (value === undefined || value.length === 0) {
-    throw new VibeError9({
+    throw new VibeError13({
       code: "VIBE_CONFIG",
       message: `the "${query}" diagnostic read requires a ${name}`,
       meta: { query, argument: name }
@@ -1980,10 +2498,10 @@ function requireArg(params) {
 }
 
 // packages/sql/src/dialects/postgres-rls-readiness.ts
-import { unsupportedCapability as unsupportedCapability14 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability15 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-rls.ts
-import { RlsContextError, VibeError as VibeError10, assertValidSchemaIR, unsupportedCapability as unsupportedCapability13, validateRlsContextIR } from "@vibeorm/schema";
+import { RlsContextError, VibeError as VibeError14, assertValidSchemaIR, unsupportedCapability as unsupportedCapability14, validateRlsContextIR } from "@vibeorm/schema";
 var NATIVE_RLS = Object.freeze({ policyName: "vibeorm_managed", tableSchema: "public", settingPrefix: "vibeorm.", parentAlias: "parent" });
 var COLUMN_TYPES = {
   String: { default: "text", native: { text: "text", varchar: "varchar", charactervarying: "varchar", uuid: "uuid" } },
@@ -1996,18 +2514,18 @@ var COLUMN_TYPES = {
 };
 function requireRls(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability13({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
   }
 }
 function identifier2(params) {
   if (typeof params.name !== "string" || params.name.length === 0 || params.name.includes("\x00") || new TextEncoder().encode(params.name).length > 63) {
-    throw new VibeError10({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS identifiers must be nonempty PostgreSQL identifiers of at most 63 bytes" });
+    throw new VibeError14({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS identifiers must be nonempty PostgreSQL identifiers of at most 63 bytes" });
   }
   return params.dialect.quoteIdent({ name: params.name });
 }
 function tableRef(params) {
   if (params.schema !== undefined && params.schema !== "public" && params.schema !== "pg_temp") {
-    throw unsupportedCapability13({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: "Only public tables and temporary policy probes are supported" });
+    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: "Only public tables and temporary policy probes are supported" });
   }
   return `${identifier2({ dialect: params.dialect, name: params.schema ?? NATIVE_RLS.tableSchema })}.${identifier2({ dialect: params.dialect, name: params.table })}`;
 }
@@ -2048,14 +2566,14 @@ function renderRlsColumnType(params) {
     if (native !== undefined)
       return native;
   }
-  throw unsupportedCapability13({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
+  throw unsupportedCapability14({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
 }
 function protectedModel(params) {
   requireRls(params);
   assertValidSchemaIR({ schema: params.schema });
   const model = params.schema.models.find((entry) => entry.name === params.model);
   if (model === undefined || model.rls === undefined || model.rls === "unprotected") {
-    throw new VibeError10({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
+    throw new VibeError14({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
   }
   return model;
 }
@@ -2088,7 +2606,7 @@ function predicate(params) {
     }).join(" AND ");
     return `EXISTS (SELECT 1 FROM ${tableRef({ dialect, table: parent.dbName ?? parent.name })} AS ${alias} WHERE ${join})`;
   }
-  throw new VibeError10({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
+  throw new VibeError14({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
 }
 function renderRlsPolicy(params) {
   const model = protectedModel(params);
@@ -2122,7 +2640,7 @@ function renderRlsContext(params) {
 function renderRlsRole(params) {
   requireRls(params);
   if (typeof params.role !== "string" || params.role.trim().length === 0 || params.role.includes("\x00")) {
-    throw new VibeError10({ code: "VIBE_CONFIG", message: "PGlite native RLS requires a trusted nonempty runtime role name" });
+    throw new VibeError14({ code: "VIBE_CONFIG", message: "PGlite native RLS requires a trusted nonempty runtime role name" });
   }
   const collector = new ParamCollector(params.dialect);
   return query({ text: `SELECT set_config('role', ${collector.add(params.role)}, true)`, values: collector.values });
@@ -2274,7 +2792,7 @@ ORDER BY c.relname, p.polname`,
 });
 function requireRls2(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability15({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
   }
 }
 function renderRlsReadinessQuery(params) {
@@ -2306,7 +2824,7 @@ function renderRlsPolicyPath(params) {
 }
 
 // packages/sql/src/render.ts
-import { assertSqlNamespace as assertSqlNamespace2, internalError as internalError2, unsupportedCapability as unsupportedCapability15 } from "@vibeorm/schema";
+import { assertSqlNamespace as assertSqlNamespace2, internalError as internalError2, unsupportedCapability as unsupportedCapability16 } from "@vibeorm/schema";
 
 // packages/sql/src/like.ts
 function escapeLikePattern(params) {
@@ -2425,6 +2943,11 @@ function quoteProjection(dialect, column) {
       return base;
     return `${base} AS ${dialect.quoteIdent({ name: column.alias })}`;
   }
+  if (column.transform === "jsonText") {
+    const ref = quoteCol(dialect, column);
+    const alias = dialect.quoteIdent({ name: column.alias ?? column.name });
+    return `${dialect.jsonTextProjection({ expression: ref })} AS ${alias}`;
+  }
   if (dialect.name !== "postgres") {
     throw internalError2({ message: "ColRef.transform is a postgres construct" });
   }
@@ -2481,7 +3004,7 @@ function renderAggRef(dialect, agg) {
 function assertScalarArrays(dialect, feature) {
   if (dialect.capabilities.scalarArrays)
     return;
-  throw unsupportedCapability15({
+  throw unsupportedCapability16({
     dialect: dialect.name,
     feature,
     hint: "only postgres has native array columns \u2014 model the list as a related table instead"
@@ -2711,7 +3234,7 @@ function renderJsonLike(params) {
 function renderJsonFilter(params) {
   const { dialect, expr, collector } = params;
   if (!dialect.supportedJsonOps.includes(expr.op)) {
-    throw unsupportedCapability15({
+    throw unsupportedCapability16({
       dialect: dialect.name,
       feature: `the json filter "${expr.op}"`,
       hint: `this dialect can express: ${dialect.supportedJsonOps.join(", ")}`
@@ -2778,7 +3301,7 @@ function renderJsonFilter(params) {
         const elements = Array.isArray(expr.value) ? expr.value : [expr.value];
         const tests = elements.map((element) => {
           if (element === null || typeof element === "object" && element !== null) {
-            throw unsupportedCapability15({
+            throw unsupportedCapability16({
               dialect: dialect.name,
               feature: "json array_contains with object/array/null elements",
               hint: "sqlite expresses scalar-element containment only \u2014 deep structural containment needs postgres or mysql"
@@ -2916,6 +3439,10 @@ function applyReturning(params) {
   const columns = requested.map((column) => {
     if (typeof column === "string")
       return dialect.quoteIdent({ name: column });
+    if ("transform" in column) {
+      const name = dialect.quoteIdent({ name: column.name });
+      return `${dialect.jsonTextProjection({ expression: name })} AS ${name}`;
+    }
     if (dialect.name !== "postgres") {
       throw internalError2({ message: "a castText RETURNING column is a postgres construct" });
     }
@@ -2929,7 +3456,7 @@ function renderKeyTableJoin(params) {
   const postgresMember = (member) => member.kind === "citext" || member.kind === "text" || member.kind === "integer";
   const admitted = dialect.name === "mysql" ? join.members.every((member) => member.kind !== "citext" && member.kind !== "text") : dialect.name === "postgres" && join.members.every(postgresMember);
   if (!admitted) {
-    throw unsupportedCapability15({
+    throw unsupportedCapability16({
       dialect: dialect.name,
       feature: "relation key table",
       hint: "the key-table join is mysql's relation association \u2014 this dialect compares relation keys by value"
@@ -3006,7 +3533,7 @@ function renderSelect(params) {
   let distinctPrefix = "";
   if (statement.distinctOn !== undefined && statement.distinctOn.length > 0) {
     if (!dialect.capabilities.distinctOn) {
-      throw unsupportedCapability15({
+      throw unsupportedCapability16({
         dialect: dialect.name,
         feature: "SELECT DISTINCT ON",
         hint: "postgres-only \u2014 the runtime emulates distinct client-side on this dialect"
@@ -3040,7 +3567,7 @@ function renderSelect(params) {
   }
   if (statement.lateralJoins !== undefined && statement.lateralJoins.length > 0) {
     if (!dialect.capabilities.lateralJoin) {
-      throw unsupportedCapability15({
+      throw unsupportedCapability16({
         dialect: dialect.name,
         feature: "LATERAL JOIN relation loading",
         hint: 'use the portable "query" relation strategy on this dialect'
@@ -3125,7 +3652,7 @@ function renderInsert(params) {
         let target = "";
         if (onConflict.constraint !== undefined) {
           if (dialect.name !== "postgres") {
-            throw unsupportedCapability15({
+            throw unsupportedCapability16({
               dialect: dialect.name,
               feature: "a named-constraint conflict target (ON CONFLICT ON CONSTRAINT)",
               hint: "only postgres names constraints in conflict targets \u2014 use a column-list target"
@@ -3140,7 +3667,7 @@ function renderInsert(params) {
         }
         text += ` ON CONFLICT${target} DO NOTHING`;
       } else if (onConflict.constraint !== undefined || onConflict.conflictWhere !== undefined) {
-        throw unsupportedCapability15({
+        throw unsupportedCapability16({
           dialect: dialect.name,
           feature: "a refined conflict target (constraint / partial-index predicate) on INSERT IGNORE",
           hint: "mysql skips on any duplicate key \u2014 drop the refinement or gate the call per dialect"
@@ -3158,7 +3685,7 @@ function renderInsert(params) {
           throw internalError2({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
         }
         if (onConflict.constraint !== undefined && dialect.name !== "postgres") {
-          throw unsupportedCapability15({
+          throw unsupportedCapability16({
             dialect: dialect.name,
             feature: "a named-constraint conflict target (ON CONFLICT ON CONSTRAINT)",
             hint: "sqlite conflict targets are column lists \u2014 name the indexed columns instead"
@@ -3174,14 +3701,14 @@ function renderInsert(params) {
         text += ` ON CONFLICT${target} DO UPDATE SET ${assignments}`;
       } else {
         if (onConflict.constraint !== undefined) {
-          throw unsupportedCapability15({
+          throw unsupportedCapability16({
             dialect: dialect.name,
             feature: "a named-constraint conflict target on ON DUPLICATE KEY UPDATE",
             hint: "mysql's ODKU fires on any duplicate key \u2014 no target can be named"
           });
         }
         if (onConflict.conflictWhere !== undefined) {
-          throw unsupportedCapability15({
+          throw unsupportedCapability16({
             dialect: dialect.name,
             feature: "a partial-index conflict target on ON DUPLICATE KEY UPDATE",
             hint: "mysql's ODKU fires on any duplicate key \u2014 a partial arbiter cannot be selected; gate the call per dialect"
@@ -3268,7 +3795,7 @@ var CHAIN_ONE_ALIAS = "__vibe_one";
 function renderChain(params) {
   const { dialect, statement, collector } = params;
   if (dialect.statementChain === null) {
-    throw unsupportedCapability15({
+    throw unsupportedCapability16({
       dialect: dialect.name,
       feature: "a statement chain (data-modifying WITH steps)",
       hint: "this dialect accepts only SELECT inside WITH \u2014 gate on SqlDialect.statementChain and keep the multi-statement path"
@@ -3430,7 +3957,7 @@ function renderInsertSelect(params) {
   return text + applyReturning({ dialect, requested: statement.returning }).suffix;
 }
 // packages/sql/src/dialects/postgres-type-identity.ts
-import { unsupportedCapability as unsupportedCapability16 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability17 } from "@vibeorm/schema";
 var IDENTIFIER = '(?:"(?:[^"\\x00]|"")+"|[a-zA-Z_][a-zA-Z_0-9$]*)';
 var MODIFIER_VALUE = `(?:[+-]?\\d+|${IDENTIFIER}|'(?:[^'\\x00]|'')*')`;
 var TYPE_NAME = new RegExp(`^\\s*(${IDENTIFIER})(?:\\s*\\.\\s*(${IDENTIFIER}))?\\s*(\\(\\s*${MODIFIER_VALUE}(?:\\s*,\\s*${MODIFIER_VALUE})*\\s*\\))?\\s*((?:\\[\\s*\\]\\s*)*)$`);
@@ -3457,13 +3984,13 @@ function parsePostgresTypeName(params) {
 }
 function renderPostgresTypeName(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability16({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
+    throw unsupportedCapability17({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
   const { dialect, type } = params;
   return `${type.namespace === undefined ? "" : `${dialect.quoteIdent({ name: type.namespace })}.`}${dialect.quoteIdent({ name: type.name })}${type.modifier}${type.array ? "[]" : ""}`;
 }
 function renderPostgresTypeIdentity(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability16({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
+    throw unsupportedCapability17({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
   const collector = new ParamCollector(params.dialect);
   const { source } = params;
   let text;
@@ -3476,11 +4003,11 @@ function renderPostgresTypeIdentity(params) {
   return { text, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/postgres-default-identity.ts
-import { unsupportedCapability as unsupportedCapability17 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability18 } from "@vibeorm/schema";
 function renderPostgresDefaultFunctionIdentity(params) {
   const { dialect, table, column } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability17({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
+    throw unsupportedCapability18({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
   const collector = new ParamCollector(dialect);
   const namespace = collector.add(table.namespace);
   const name = collector.add(table.name);
@@ -3504,28 +4031,28 @@ WHERE n.nspname = ${namespace} AND c.relname = ${name} AND a.attname = ${field}
   };
 }
 // packages/sql/src/dialects/constraint-owned-index.ts
-import { unsupportedCapability as unsupportedCapability18 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability19 } from "@vibeorm/schema";
 function renderConstraintOwnedIndexDrop(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability18({ dialect: params.dialect.name, feature: "constraintOwnedIndexDrop" });
+    throw unsupportedCapability19({ dialect: params.dialect.name, feature: "constraintOwnedIndexDrop" });
   const quote = (name) => params.dialect.quoteIdent({ name });
   return { text: `ALTER TABLE ${quote(params.table)} DROP CONSTRAINT ${quote(params.constraint)};`, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/mysql-check-probe.ts
-import { unsupportedCapability as unsupportedCapability19 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability20 } from "@vibeorm/schema";
 function renderMysqlCheckProbe(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability19({ dialect: params.dialect.name, feature: "temporaryCheckProbe" });
+    throw unsupportedCapability20({ dialect: params.dialect.name, feature: "temporaryCheckProbe" });
   const q = (name) => params.dialect.quoteIdent({ name });
   const probe = q(params.probe);
   switch (params.operation) {
     case "clone":
       if (params.table === undefined)
-        throw unsupportedCapability19({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "A source table is required" });
+        throw unsupportedCapability20({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "A source table is required" });
       return { text: `CREATE TEMPORARY TABLE ${probe} LIKE ${q(params.table.namespace)}.${q(params.table.name)}`, values: [], returning: "none" };
     case "add": {
       if (params.expression === undefined || params.definition === undefined)
-        throw unsupportedCapability19({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "An authored expression and temporary clone definition are required" });
+        throw unsupportedCapability20({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "An authored expression and temporary clone definition are required" });
       const parts = tableDefinitionParts({ sql: params.definition });
       return { text: `CREATE TEMPORARY TABLE ${probe} (
 ${[...parts.clauses, `CONSTRAINT ${probe} CHECK (${params.expression})`].join(`,
@@ -3571,31 +4098,31 @@ function sqliteTableConstraints(params) {
   return result;
 }
 // packages/sql/src/dialects/migration-visibility.ts
-import { unsupportedCapability as unsupportedCapability20 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability21 } from "@vibeorm/schema";
 function renderMigrationVisibility(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability20({ dialect: params.dialect.name, feature: "mysqlCatalogVisibility" });
+    throw unsupportedCapability21({ dialect: params.dialect.name, feature: "mysqlCatalogVisibility" });
   const collector = new ParamCollector(params.dialect);
   const grantee = "CONCAT(QUOTE(SUBSTRING_INDEX(CURRENT_USER(), '@', 1)), '@', QUOTE(SUBSTRING_INDEX(CURRENT_USER(), '@', -1)))";
   return { text: `SELECT PRIVILEGE_TYPE AS privilege FROM information_schema.USER_PRIVILEGES WHERE GRANTEE = ${grantee} UNION SELECT PRIVILEGE_TYPE AS privilege FROM information_schema.SCHEMA_PRIVILEGES WHERE GRANTEE = ${grantee} AND ${collector.add(params.namespace)} LIKE TABLE_SCHEMA`, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/migration-inventory.ts
-import { unsupportedCapability as unsupportedCapability21 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability22 } from "@vibeorm/schema";
 function renderSqliteColumnInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability21({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
+    throw unsupportedCapability22({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
   const collector = new ParamCollector(params.dialect);
   return { text: `SELECT name, hidden, pk, dflt_value AS definition FROM pragma_table_xinfo(${collector.add(params.table)}, ${collector.add(params.namespace)}) ORDER BY cid`, values: collector.values, returning: "none" };
 }
 function renderSqliteForeignKeyInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability21({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
+    throw unsupportedCapability22({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
   const collector = new ParamCollector(params.dialect);
   return { text: `SELECT id, seq, "from", "to", "table", on_update, on_delete, match FROM pragma_foreign_key_list(${collector.add(params.table)}, ${collector.add(params.namespace)}) ORDER BY id, seq`, values: collector.values, returning: "none" };
 }
 function renderSqliteRebuildObjects(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability21({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
+    throw unsupportedCapability22({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
   return { text: "SELECT name, tbl_name, type, sql FROM main.sqlite_schema WHERE type IN ('index', 'trigger') AND sql IS NOT NULL ORDER BY type, name", values: [], returning: "none" };
 }
 function renderMigrationInventory(params) {
@@ -3634,7 +4161,7 @@ ORDER BY kind, parent, name`, values: collector.values, returning: "none" };
   return { text: `SELECT type AS kind, name, tbl_name AS parent, sql AS definition FROM ${schema}.sqlite_schema WHERE name NOT LIKE 'sqlite\\_%' ESCAPE '\\' AND name <> '_vibe_migrations' ORDER BY type, tbl_name, name`, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/migration-objects.ts
-import { internalError as internalError3, unsupportedCapability as unsupportedCapability22 } from "@vibeorm/schema";
+import { internalError as internalError3, unsupportedCapability as unsupportedCapability23 } from "@vibeorm/schema";
 function renderMigrationObjectQuery(params) {
   return objectQuery({ ...params, collector: new ParamCollector(params.dialect) });
 }
@@ -3642,7 +4169,7 @@ function objectQuery(params) {
   const { dialect, identity: object, collector } = params;
   if (object.kind === "namespace") {
     if (dialect.name !== "postgres")
-      throw unsupportedCapability22({ dialect: dialect.name, feature: "fixedNamespaces" });
+      throw unsupportedCapability23({ dialect: dialect.name, feature: "fixedNamespaces" });
     return { text: `SELECT n.nspname::text AS "name" FROM pg_catalog.pg_namespace n WHERE n.nspname = ${collector.add(object.name)}`, values: collector.values, returning: "none" };
   }
   const physical = "table" in object ? object.table : object.name;
@@ -3706,7 +4233,7 @@ function objectQuery(params) {
         break;
       case "constraint":
         if (object.constraintType === "exclusion")
-          throw unsupportedCapability22({ dialect: "mysql", feature: "exclusionConstraints" });
+          throw unsupportedCapability23({ dialect: "mysql", feature: "exclusionConstraints" });
         text = `SELECT tc.CONSTRAINT_TYPE AS type, tc.ENFORCED AS enforced, cc.CHECK_CLAUSE AS definition, rc.UPDATE_RULE AS onUpdate, rc.DELETE_RULE AS onDelete, rc.MATCH_OPTION AS matchOption FROM information_schema.TABLE_CONSTRAINTS tc LEFT JOIN information_schema.CHECK_CONSTRAINTS cc ON cc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA AND cc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME LEFT JOIN information_schema.REFERENTIAL_CONSTRAINTS rc ON rc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA AND rc.TABLE_NAME = tc.TABLE_NAME AND rc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME WHERE tc.TABLE_SCHEMA = ${namespace} AND tc.TABLE_NAME = ${name} AND tc.CONSTRAINT_NAME = ${collector.add(object.name)}`;
         break;
       case "index":
@@ -3716,15 +4243,15 @@ function objectQuery(params) {
         text = `SELECT TABLE_TYPE AS type, ENGINE AS engine, TABLE_COLLATION AS collation FROM information_schema.TABLES WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name}`;
         break;
       default:
-        throw unsupportedCapability22({ dialect: "mysql", feature: `inspect:${object.kind}` });
+        throw unsupportedCapability23({ dialect: "mysql", feature: `inspect:${object.kind}` });
     }
   } else {
     if (physical.namespace !== "main" && physical.namespace !== "temp")
-      throw unsupportedCapability22({ dialect: "sqlite", feature: "attachedSchemaInspection" });
+      throw unsupportedCapability23({ dialect: "sqlite", feature: "attachedSchemaInspection" });
     const catalog = `${dialect.quoteIdent({ name: physical.namespace })}.sqlite_schema`;
     const kind = object.kind === "table" || object.kind === "view" ? object.kind : object.kind === "trigger" ? "trigger" : object.kind === "index" ? "index" : "table";
     if (["function", "sequence", "postgresExtension", "enum"].includes(object.kind) || object.kind === "constraint" && object.constraintType === "exclusion")
-      throw unsupportedCapability22({ dialect: "sqlite", feature: `inspect:${object.kind}` });
+      throw unsupportedCapability23({ dialect: "sqlite", feature: `inspect:${object.kind}` });
     const sqliteParams = new ParamCollector(dialect);
     if (object.kind === "column" || object.kind === "columnDefault" || object.kind === "generatedColumn") {
       text = `SELECT x.type AS type, x."notnull" AS "notNull", x.pk AS primaryKeyPosition, x.hidden AS generated, x.dflt_value AS definition, (SELECT sql FROM ${catalog} WHERE name = ${sqliteParams.add(physical.name)} AND type = 'table') AS tableDefinition FROM pragma_table_xinfo(${sqliteParams.add(physical.name)}, ${sqliteParams.add(physical.namespace)}) x WHERE x.name = ${sqliteParams.add(object.column)}`;
@@ -3754,7 +4281,7 @@ function renderMigrationDependencies(params) {
 }
 function dependencyQuery(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability22({ dialect: params.dialect.name, feature: "catalogDependencies" });
+    throw unsupportedCapability23({ dialect: params.dialect.name, feature: "catalogDependencies" });
   const object = params.identity;
   const collector = params.collector;
   if (object.kind === "namespace") {
@@ -3811,7 +4338,7 @@ function inspectionReferences(params) {
 function renderMigrationObjectBatch(params) {
   const { dialect } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability22({ dialect: dialect.name, feature: "batchedMigrationInspection" });
+    throw unsupportedCapability23({ dialect: dialect.name, feature: "batchedMigrationInspection" });
   const groups = new Map;
   for (const [position, identity] of params.identities.entries()) {
     const kind = identity.kind === "constraint" ? `${identity.kind}:${identity.constraintType}` : identity.kind === "generatedColumn" ? "columnDefault" : identity.kind;
@@ -3844,16 +4371,16 @@ function renderMigrationNamespace(params) {
 }
 function renderCheckProbe(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability22({ dialect: params.dialect.name, feature: "rollbackCheckProbe" });
+    throw unsupportedCapability23({ dialect: params.dialect.name, feature: "rollbackCheckProbe" });
   const q = (name) => params.dialect.quoteIdent({ name });
   return { text: `ALTER TABLE ${q(params.table.namespace)}.${q(params.table.name)} ADD CONSTRAINT ${q(params.name)} CHECK (${params.expression}) NOT VALID`, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/postgres-migration.ts
-import { VibeError as VibeError11, unsupportedCapability as unsupportedCapability23 } from "@vibeorm/schema";
+import { VibeError as VibeError15, unsupportedCapability as unsupportedCapability24 } from "@vibeorm/schema";
 var SETTING_VALUE = /^[0-9]+(?:\.[0-9]+)?\s*(?:us|ms|s|min|h|d)?$/;
 function requirePostgres2(params) {
   if (params.dialect.name !== "postgres") {
-    throw unsupportedCapability23({ dialect: params.dialect.name, feature: params.feature });
+    throw unsupportedCapability24({ dialect: params.dialect.name, feature: params.feature });
   }
 }
 function renderMigrationSessionRead(params) {
@@ -3868,7 +4395,7 @@ function renderMigrationSessionSet(params) {
   requirePostgres2({ dialect: params.dialect, feature: "migrationSessionSettings" });
   const { milliseconds, setting } = params;
   if (!Number.isSafeInteger(milliseconds) || milliseconds < 0) {
-    throw new VibeError11({
+    throw new VibeError15({
       code: "VIBE_MIGRATION",
       message: `${setting} must be a non-negative integer number of milliseconds (got ${String(milliseconds)})`,
       meta: { reason: "execution-metadata-invalid", setting, value: milliseconds }
@@ -3981,14 +4508,26 @@ export {
   SQLITE_SESSION_SQL,
   SQL_DEFAULT_CELL,
   SQL_DIALECTS,
+  assertSqlParamBuilding,
   chainVetoToken,
   compileExclusion,
+  compileReusableSqlCommand,
+  compileReusableSqlQuery,
   compileSql,
+  compileSqlCommand,
+  compileSqlQuery,
   containsPattern,
+  createReusableSqlCommand,
+  createReusableSqlQuery,
+  createSqlCommand,
+  createSqlInput,
+  createSqlInputScope,
+  createSqlQuery,
   dbNowMarker,
   decode,
   decodeIsNoop,
   describeRowLock,
+  encode,
   endsWithPattern,
   enumMembershipCodec,
   escapeGlobPattern,
@@ -4003,9 +4542,15 @@ export {
   isJsonParamCell,
   isListSetOperation,
   isNativeEnumArrayParameter,
+  isReusableSqlCommand,
+  isReusableSqlQuery,
   isSetOperation,
+  isSqlBindingCollector,
+  isSqlCommand,
   isSqlDefaultCell,
   isSqlFragment,
+  isSqlParam,
+  isSqlQuery,
   isStepColumnRef,
   jsonListParameter,
   jsonParamCell,
@@ -4013,12 +4558,15 @@ export {
   mysqlDialect,
   nativeEnumArrayParameter,
   parseDateTimeText,
+  parseJsonText,
   parsePgArrayLiteral,
   parsePgArrayLiteralNested,
   parsePostgresTypeName,
   postgresArrayElementFromText,
   postgresDialect,
   projectionOutputName,
+  recordSqlBinding,
+  recordSqlBindingCheck,
   renderAdvisoryLock,
   renderCheckProbe,
   renderColumnStateQuery,
@@ -4082,9 +4630,14 @@ export {
   renderSqliteFtsUpdateTrigger,
   renderSqliteRebuildObjects,
   renderStatement,
+  resultScalarContract,
   returningColumnName,
+  sealSqlInputScope,
   shortestFloat32,
+  snapshotSqlValue,
   sql,
+  sqlInputContract,
+  sqlParamContract,
   sqlUsesIncoming,
   sqliteColumnClauses,
   sqliteDialect,
@@ -4098,4 +4651,4 @@ export {
   toPgArrayLiteral
 };
 
-//# debugId=67799F9417158D9264756E2164756E21
+//# debugId=B8D70B32D9F5E99064756E2164756E21