@vibeorm/sql 2.0.2 → 2.1.0

package/dist/index.js

@@ -1,4 +1,878 @@
 // @bun
+// packages/sql/src/composable.ts
+import { VibeError } from "@vibeorm/schema";
+
+// packages/sql/src/params.ts
+class ParamCollector {
+  dialect;
+  values;
+  constructor(dialect) {
+    this.dialect = dialect;
+    this.values = [];
+  }
+  add(value) {
+    this.values.push(value);
+    return this.dialect.placeholder({ index: this.values.length });
+  }
+  addMany(values) {
+    return values.map((value) => this.add(value));
+  }
+}
+
+// packages/sql/src/composable.ts
+var fragments = new WeakMap;
+function invalid(message) {
+  throw new VibeError({ 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 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);
+  },
+  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)))
+      invalid("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 });
+  return partsOf(params.fragment).map((part) => {
+    if (typeof part === "string")
+      return part;
+    if ("value" in part) {
+      if (part.value === undefined)
+        invalid("SQL parameters cannot be undefined; use null explicitly");
+      return collector.add(part.decoder === undefined ? part.value : part.decoder.encode({ value: part.value, dialect: dialect.name }));
+    }
+    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 })}`;
+    }
+    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)`));
+  }).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 ("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 VibeError3 } 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;
+  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;
+}
+
+// packages/sql/src/codecs.ts
+import { VibeError as VibeError2, invalidStoredData } 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 VibeError2({
+        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" || typeof value === "number")
+      return BigInt(value);
+    return 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})?)?$/;
+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 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 VibeError2({ 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 VibeError2({ 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);
+    return value instanceof Date ? value.toISOString() : value;
+  },
+  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 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 VibeError2({
+        code: "VIBE_INTERNAL",
+        message: "a Json column returned text that is not valid JSON",
+        meta: { value },
+        cause
+      });
+    }
+  }
+};
+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 VibeError3({ 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)
+      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);
+    }
+  });
+}
+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 VibeError3({ 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 VibeError5, fieldTypeIdentity as fieldTypeIdentity2, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
+
+// packages/sql/src/predicate.ts
+import { VibeError as VibeError4, fieldTypeIdentity, isEnumType, unsupportedCapability } from "@vibeorm/schema";
+function renderPredicate(params) {
+  if (params.usage === "exclusionPredicate" && !params.dialect.capabilities.exclusionConstraints)
+    throw unsupportedCapability({ dialect: params.dialect.name, feature: "exclusionConstraints" });
+  if (params.usage === "indexPredicate" && !params.dialect.capabilities.partialIndexes) {
+    throw unsupportedCapability({ dialect: params.dialect.name, feature: "partialIndexes" });
+  }
+  const context = {
+    model: params.model,
+    dialect: params.dialect,
+    enums: params.enums ?? [],
+    usage: params.usage,
+    site: params.site
+  };
+  return renderNode({ node: params.predicate, context });
+}
+var PRECEDENCE = {
+  or: 1,
+  and: 2,
+  not: 3,
+  compare: 4,
+  inList: 4,
+  isNull: 4
+};
+var COMPARISON_SQL = {
+  eq: "=",
+  ne: "<>",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<="
+};
+var EXACT_INTEGER = /^-?(0|[1-9]\d*)$/;
+var EXACT_DECIMAL = /^-?(0|[1-9]\d*)(\.\d+)?$/;
+var INT32_MIN = -2147483648n;
+var INT32_MAX = 2147483647n;
+var INT64_MIN = -(2n ** 63n);
+var INT64_MAX = 2n ** 63n - 1n;
+function refuse2(params) {
+  const { context, rule, message } = params;
+  throw new VibeError4({
+    code: "VIBE_SCHEMA_INVALID",
+    message: `${context.site} on "${context.model.name}": ${message}`,
+    meta: { rule, model: context.model.name, site: context.site, ...params.meta ?? {} }
+  });
+}
+function renderChild(params) {
+  const { node, parent, context } = params;
+  if ((node.kind === "and" || node.kind === "or") && node.operands.length === 1) {
+    return renderChild({ node: node.operands[0], parent, context });
+  }
+  const text = renderNode({ node, context });
+  return PRECEDENCE[node.kind] < PRECEDENCE[parent] ? `(${text})` : text;
+}
+function renderNode(params) {
+  const { node, context } = params;
+  switch (node.kind) {
+    case "and":
+    case "or": {
+      if (node.operands.length === 0) {
+        refuse2({
+          context,
+          rule: "predicate-empty",
+          message: `${node.kind === "and" ? "and()" : "or()"} has no operands \u2014 an empty boolean group has no honest SQL spelling`
+        });
+      }
+      if (node.operands.length === 1)
+        return renderNode({ node: node.operands[0], context });
+      const separator = node.kind === "and" ? " AND " : " OR ";
+      return node.operands.map((operand) => renderChild({ node: operand, parent: node.kind, context })).join(separator);
+    }
+    case "not":
+      return `NOT ${renderChild({ node: node.operand, parent: "not", context })}`;
+    case "isNull": {
+      const field = resolveField({ name: node.field.name, context });
+      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}`;
+    }
+    case "inList": {
+      if (node.values.length === 0) {
+        refuse2({
+          context,
+          rule: "predicate-empty",
+          message: `inList("${node.field.name}") has no values \u2014 an empty IN list is UNKNOWN on every row and never what an author means`,
+          meta: { field: node.field.name }
+        });
+      }
+      const field = resolveField({ name: node.field.name, context });
+      const values = node.values.map((value) => renderLiteral({ value, field, context })).join(", ");
+      return `${compareColumn({ field, context })} ${node.negate === true ? "NOT IN" : "IN"} (${values})`;
+    }
+  }
+}
+function resolveField(params) {
+  const { name, context } = params;
+  const field = context.model.fields.find((candidate) => candidate.name === name);
+  if (field === undefined) {
+    refuse2({
+      context,
+      rule: "predicate-unknown-field",
+      message: `references field "${name}", which the model does not declare`,
+      meta: { field: name }
+    });
+  }
+  if (field.isList) {
+    refuse2({
+      context,
+      rule: "predicate-list-field",
+      message: `compares scalar list "${name}" \u2014 array operators differ per dialect; use a raw expression for them`,
+      meta: { field: name }
+    });
+  }
+  if (field.isUnsupported === true) {
+    refuse2({
+      context,
+      rule: "predicate-unsupported-type",
+      message: `references "${name}", an Unsupported("${field.nativeType ?? "?"}") column whose operators VibeORM does not model \u2014 use a raw expression`,
+      meta: { field: name }
+    });
+  }
+  if (field.type === "Json" || field.type === "Bytes") {
+    refuse2({
+      context,
+      rule: "predicate-unsupported-type",
+      message: `references ${field.type} column "${name}" \u2014 ${field.type} comparison operators differ per dialect; use a raw expression`,
+      meta: { field: name, type: field.type }
+    });
+  }
+  if (context.usage === "check" && context.dialect.name === "mysql" && field.default?.kind === "autoincrement") {
+    throw unsupportedCapability({
+      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"
+    });
+  }
+  return field;
+}
+function quoteColumn(params) {
+  const { field, context } = params;
+  return context.dialect.quoteIdent({ name: field.dbName ?? field.name });
+}
+function compareColumn(params) {
+  const { field, context } = params;
+  const quoted = quoteColumn({ field, context });
+  return context.dialect.name === "sqlite" && field.type === "Decimal" ? `CAST(${quoted} AS REAL)` : quoted;
+}
+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 leftType = fieldTypeIdentity({ type: field.type });
+  const rightType = fieldTypeIdentity({ type: other.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 }
+    });
+  }
+  return compareColumn({ field: other, context });
+}
+function renderLiteral(params) {
+  const { field, context } = params;
+  const { value } = params.value;
+  const type = field.type;
+  const wrongCarrier = (expected) => refuse2({
+    context,
+    rule: "predicate-type-mismatch",
+    message: `compares ${fieldTypeIdentity({ type })} field "${field.name}" with ${describe({ value })} \u2014 ${expected}`,
+    meta: { field: field.name, fieldType: fieldTypeIdentity({ type }), value }
+  });
+  if (isEnumType(type)) {
+    if (typeof value !== "string")
+      return wrongCarrier(`enum ${type.enum} takes one of its member names as a string`);
+    const declared = context.enums.find((entry) => entry.name === type.enum);
+    if (declared !== undefined && !declared.values.includes(value)) {
+      refuse2({
+        context,
+        rule: "predicate-enum-member",
+        message: `compares "${field.name}" with "${value}", which is not a member of enum ${type.enum} (${declared.values.join(", ")})`,
+        meta: { field: field.name, enum: type.enum, value, members: [...declared.values] }
+      });
+    }
+    return stringLiteral({ value, context, field });
+  }
+  switch (type) {
+    case "String":
+      if (typeof value !== "string")
+        return wrongCarrier("a String column takes a string literal");
+      return stringLiteral({ value, context, field });
+    case "Boolean":
+      if (typeof value !== "boolean")
+        return wrongCarrier("a Boolean column takes `true` or `false`");
+      return value ? context.dialect.booleanLiteral.true : context.dialect.booleanLiteral.false;
+    case "Int":
+      return integerLiteral({ value, field, context, min: INT32_MIN, max: INT32_MAX, label: "Int" });
+    case "BigInt":
+      return integerLiteral({ value, field, context, min: INT64_MIN, max: INT64_MAX, label: "BigInt" });
+    case "Float": {
+      if (typeof value !== "number")
+        return wrongCarrier("a Float column takes a number");
+      if (!Number.isFinite(value)) {
+        refuse2({
+          context,
+          rule: "predicate-literal-invalid",
+          message: `compares "${field.name}" with ${String(value)} \u2014 a Float literal must be finite`,
+          meta: { field: field.name, value: String(value) }
+        });
+      }
+      return String(value);
+    }
+    case "Decimal": {
+      if (typeof value !== "string") {
+        return wrongCarrier('a Decimal column takes exact decimal TEXT ("0", "19.99") \u2014 a JS number cannot carry an exact decimal');
+      }
+      if (!EXACT_DECIMAL.test(value)) {
+        refuse2({
+          context,
+          rule: "predicate-literal-invalid",
+          message: `compares "${field.name}" with "${value}", which is not an exact decimal literal`,
+          meta: { field: field.name, value }
+        });
+      }
+      return value;
+    }
+    case "DateTime":
+      refuse2({
+        context,
+        rule: "predicate-unsupported-literal",
+        message: `compares DateTime field "${field.name}" with a literal \u2014 DateTime literals are spelled differently on postgres, mysql and sqlite, so VibeORM does not guess one. Compare two DateTime columns, or write a raw expression for a fixed instant`,
+        meta: { field: field.name }
+      });
+    case "Json":
+    case "Bytes":
+      return wrongCarrier(`${type} columns take no predicate literal`);
+  }
+}
+function integerLiteral(params) {
+  const { value, field, context, min, max, label } = params;
+  let text;
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value)) {
+      refuse2({
+        context,
+        rule: "predicate-literal-invalid",
+        message: `compares "${field.name}" with ${String(value)} \u2014 an ${label} literal must be an exact integer JavaScript can represent; pass a bigint or a decimal string for larger values`,
+        meta: { field: field.name, value: String(value) }
+      });
+    }
+    text = String(value);
+  } else if (typeof value === "string") {
+    if (!EXACT_INTEGER.test(value)) {
+      refuse2({
+        context,
+        rule: "predicate-literal-invalid",
+        message: `compares "${field.name}" with "${value}", which is not an exact integer literal`,
+        meta: { field: field.name, value }
+      });
+    }
+    text = value;
+  } else {
+    refuse2({
+      context,
+      rule: "predicate-type-mismatch",
+      message: `compares ${label} field "${field.name}" with ${describe({ value })} \u2014 an ${label} column takes an integer`,
+      meta: { field: field.name, value }
+    });
+  }
+  const parsed = BigInt(text);
+  if (parsed < min || parsed > max) {
+    refuse2({
+      context,
+      rule: "predicate-literal-invalid",
+      message: `compares "${field.name}" with ${text}, which is outside the range an ${label} column can hold (${min}\u2026${max})`,
+      meta: { field: field.name, value: text }
+    });
+  }
+  return text;
+}
+function stringLiteral(params) {
+  const { value, context, field } = params;
+  if (value.includes("\x00")) {
+    refuse2({
+      context,
+      rule: "predicate-literal-invalid",
+      message: `compares "${field.name}" with a string containing a NUL byte, which no dialect here can store`,
+      meta: { field: field.name }
+    });
+  }
+  return context.dialect.quoteStringLiteral({ value });
+}
+function describe(params) {
+  const { value } = params;
+  return typeof value === "string" ? `the string ${JSON.stringify(value)}` : `the ${typeof value} ${String(value)}`;
+}
+
+// packages/sql/src/exclusion.ts
+function invalid2(rule) {
+  throw new VibeError5({ 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 unsupportedCapability2({ dialect: dialect.name, feature: "exclusionConstraints" });
+  if (!spec.name || spec.name.includes("\x00"))
+    invalid2("name");
+  if (!["int8range", "tsrange", "tstzrange"].includes(spec.range.type))
+    invalid2("range-type");
+  if (!["[)", "[]", "()", "(]"].includes(spec.range.bounds))
+    invalid2("bounds");
+  const field = (name) => {
+    const value = model.fields.find((entry) => entry.name === name);
+    if (value === undefined || value.isList || value.isUnsupported)
+      invalid2("field");
+    return value;
+  };
+  const endpoint = (value) => {
+    if ("unbounded" in value)
+      return "NULL";
+    const infinity = "infinity" in value ? value.infinity : value.nullAs;
+    if (infinity !== undefined && (spec.range.type === "int8range" || !["infinity", "-infinity"].includes(infinity)))
+      invalid2("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");
+    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");
+    }
+    const sql2 = dialect.quoteIdent({ name: column.dbName ?? column.name });
+    return literal === undefined ? sql2 : `COALESCE(${sql2}, ${literal})`;
+  };
+  const keys = spec.keys.map((key) => {
+    if ("expression" in key) {
+      if (!key.expression.trim() || key.expression.includes("\x00") || key.fields.length === 0)
+        invalid2("expression");
+      key.fields.forEach(field);
+      return `(${key.expression}) WITH =`;
+    }
+    const column = field(key.field);
+    if (column.isOptional)
+      invalid2("nullable-key-requires-expression");
+    if (!["String", "Int", "BigInt", "Float", "Decimal", "Boolean", "DateTime"].includes(fieldTypeIdentity2({ type: column.type })))
+      invalid2("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 &&`);
+  const where = spec.where === undefined ? "" : ` WHERE (${renderPredicate({ predicate: spec.where, model, dialect, usage: "exclusionPredicate", site: spec.name })})`;
+  return { name: spec.name, definition: `EXCLUDE USING gist (${keys.join(", ")})${where}`, source: spec, requiredExtensions: spec.keys.length === 0 ? [] : dialect.capabilities.exclusionExtensions };
+}
+function renderExclusionSetup(params) {
+  if (!params.dialect.capabilities.exclusionConstraints)
+    throw unsupportedCapability2({ 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 unsupportedCapability2({ 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 })};`];
+  return [...renderExclusionSetup({ dialect, exclusion }), `${target} ADD CONSTRAINT ${dialect.quoteIdent({ name: exclusion.name })} ${exclusion.definition};`];
+}
+function renderExclusionCatalog(params) {
+  const { dialect, probe } = params;
+  if (!dialect.capabilities.exclusionConstraints)
+    throw unsupportedCapability2({ dialect: dialect.name, feature: "exclusionConstraints" });
+  const scope = probe === undefined ? "n.nspname = '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 unsupportedCapability2({ dialect: dialect.name, feature: "exclusionConstraints" });
+  return [`CREATE TEMP TABLE ${dialect.quoteIdent({ name: probe })} (LIKE ${dialect.quoteIdent({ name: "public" })}.${dialect.quoteIdent({ name: table })})`, `ALTER TABLE ${dialect.quoteIdent({ name: probe })} ADD CONSTRAINT ${dialect.quoteIdent({ name: `${probe}_x` })} ${definition}`];
+}
 // packages/sql/src/ast.ts
 var SET_OPERATORS = ["increment", "decrement", "multiply", "divide"];
 function isSetOperation(value) {
@@ -48,6 +922,90 @@ function excludedRef(params) {
 function isExcludedRef(value) {
   return typeof value === "object" && value !== null && value.__excluded === true;
 }
+var ADVISORY_LOCK_RESULT_COLUMN = "acquired";
+// packages/sql/src/locks.ts
+import { internalError, unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
+var ROW_LOCK_PROSE = Object.freeze({
+  strengths: Object.freeze({
+    update: "FOR UPDATE",
+    noKeyUpdate: "FOR NO KEY UPDATE",
+    share: "FOR SHARE",
+    keyShare: "FOR KEY SHARE"
+  }),
+  wait: Object.freeze({ wait: "", nowait: " NOWAIT", skipLocked: " SKIP LOCKED" })
+});
+function describeRowLock(params) {
+  const { strength, wait } = params.lock;
+  return `${ROW_LOCK_PROSE.strengths[strength]}${ROW_LOCK_PROSE.wait[wait]}`;
+}
+function renderRowLockClause(params) {
+  const { dialect, lock } = params;
+  const syntax = dialect.rowLockSyntax;
+  if (syntax === null) {
+    if (lock.strength === "update" && lock.wait === "wait")
+      return null;
+    throw unsupportedCapability3({
+      dialect: dialect.name,
+      feature: `a ${describeRowLock({ lock })} locking read`,
+      hint: `${dialect.name} has no locking-read clause at all`
+    });
+  }
+  const strengthText = syntax.strengths[lock.strength];
+  if (strengthText === undefined) {
+    throw unsupportedCapability3({
+      dialect: dialect.name,
+      feature: `the ${describeRowLock({ lock: { ...lock, wait: "wait" } })} row-lock strength`,
+      hint: `${dialect.name} can express: ${Object.keys(syntax.strengths).join(", ")}`
+    });
+  }
+  const waitText = syntax.wait[lock.wait];
+  if (waitText === undefined) {
+    throw unsupportedCapability3({
+      dialect: dialect.name,
+      feature: `the "${lock.wait}" lock wait policy`,
+      hint: `${dialect.name} can express: ${Object.keys(syntax.wait).join(", ")}`
+    });
+  }
+  return `${strengthText}${waitText}`;
+}
+var ADVISORY_KEY_BOUNDS = Object.freeze({
+  single: Object.freeze({ min: -(2n ** 63n), max: 2n ** 63n - 1n }),
+  pair: Object.freeze({ min: -(2 ** 31), max: 2 ** 31 - 1 })
+});
+function isSingleKey(key) {
+  return "key" in key;
+}
+function renderAdvisoryLock(params) {
+  const { dialect, statement, collector } = params;
+  const functions = dialect.advisoryLockFunctions;
+  if (functions === null) {
+    throw unsupportedCapability3({
+      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`
+    });
+  }
+  const mode = statement.mode;
+  const fn = (mode === "exclusive" ? functions.exclusive : functions.shared)[statement.wait];
+  const key = statement.key;
+  const args = isSingleKey(key) ? `${collector.add(key.key.toString())}${functions.keyCast.single}` : `${collector.add(String(assertInt32({ value: key.classId, part: "classId" })))}${functions.keyCast.pair}, ` + `${collector.add(String(assertInt32({ value: key.objectId, part: "objectId" })))}${functions.keyCast.pair}`;
+  const projection = statement.wait === "nowait" ? ` AS ${dialect.quoteIdent({ name: ADVISORY_LOCK_RESULT_COLUMN })}` : "";
+  return {
+    text: `SELECT ${fn}(${args})${projection}`,
+    values: collector.values,
+    returning: "none"
+  };
+}
+function assertInt32(params) {
+  const { value, part } = params;
+  if (!Number.isInteger(value) || value < ADVISORY_KEY_BOUNDS.pair.min || value > ADVISORY_KEY_BOUNDS.pair.max) {
+    throw internalError({
+      message: `advisory lock ${part} must be a 32-bit integer, got ${String(value)}`,
+      meta: { part, value }
+    });
+  }
+  return value;
+}
 // packages/sql/src/json-transport.ts
 var JSON_TRANSPORT = Object.freeze({ chunkSize: 100 });
 function projectionOutputName(params) {
@@ -93,12 +1051,35 @@ var postgresDialect = {
   ],
   jsonParamCast: "::text::jsonb",
   lastInsertIdSql: null,
-  selectForUpdate: " FOR UPDATE",
+  rowLockSyntax: {
+    strengths: Object.freeze({
+      update: "FOR UPDATE",
+      noKeyUpdate: "FOR NO KEY UPDATE",
+      share: "FOR SHARE",
+      keyShare: "FOR KEY SHARE"
+    }),
+    wait: Object.freeze({ wait: "", nowait: " NOWAIT", skipLocked: " SKIP LOCKED" })
+  },
+  advisoryLockFunctions: {
+    exclusive: Object.freeze({
+      wait: "pg_catalog.pg_advisory_xact_lock",
+      nowait: "pg_catalog.pg_try_advisory_xact_lock"
+    }),
+    shared: Object.freeze({
+      wait: "pg_catalog.pg_advisory_xact_lock_shared",
+      nowait: "pg_catalog.pg_try_advisory_xact_lock_shared"
+    }),
+    keyCast: Object.freeze({ single: "::bigint", pair: "::int4" })
+  },
   rowDefaultKeyword: true,
   paramBudget: 30000,
+  booleanLiteral: { true: "true", false: "false" },
   quoteIdent({ name }) {
     return `"${name.replaceAll('"', '""')}"`;
   },
+  quoteStringLiteral({ value }) {
+    return `'${value.replaceAll("'", "''")}'`;
+  },
   placeholder({ index }) {
     return `$${index}`;
   },
@@ -139,248 +1120,92 @@ var sqliteDialect = {
   ],
   jsonParamCast: "",
   lastInsertIdSql: null,
-  selectForUpdate: null,
+  rowLockSyntax: null,
+  advisoryLockFunctions: null,
   rowDefaultKeyword: false,
   paramBudget: 900,
-  quoteIdent({ name }) {
-    return `"${name.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/mysql.ts
-var mysqlDialect = {
-  name: "mysql",
-  capabilities: MYSQL_CAPABILITIES,
-  inArrayStrategy: "expand",
-  tupleInStrategy: "rowValue",
-  upsertForm: "onDuplicateKey",
-  conflictKeyEquality: {
-    foldingScalars: ["Decimal"],
-    defaultStringMaxLength: 191,
-    textIsBinaryByDefault: false,
-    duplicatesInOneStatement: "lastWriteWins"
-  },
-  excludedRowRef: { form: "rowAlias", alias: "new" },
-  doNothingForm: "insertIgnore",
-  insensitiveLike: "lower",
-  strictMatchStrategy: "binary",
-  orderByNullsMode: "emulate",
-  offsetRequiresLimit: { limitText: "18446744073709551615" },
-  likeEscapeClause: null,
-  jsonPathMode: "mysqlExtract",
-  supportedJsonOps: [
-    "equals",
-    "string_contains",
-    "string_starts_with",
-    "string_ends_with",
-    "array_contains",
-    "array_starts_with",
-    "array_ends_with"
-  ],
-  jsonParamCast: "",
-  lastInsertIdSql: "SELECT LAST_INSERT_ID() AS `id`",
-  selectForUpdate: " FOR UPDATE",
-  rowDefaultKeyword: true,
-  paramBudget: 1e4,
-  quoteIdent({ name }) {
-    return `\`${name.replaceAll("`", "``")}\``;
-  },
-  placeholder() {
-    return "?";
-  },
-  renderDbNow({ offsetSeconds, collector }) {
-    if (offsetSeconds === 0)
-      return "NOW(6)";
-    return `DATE_ADD(NOW(6), INTERVAL ${collector.add(offsetSeconds)} SECOND)`;
-  }
-};
-// packages/sql/src/dialects/registry.ts
-var SQL_DIALECTS = {
-  postgres: postgresDialect,
-  sqlite: sqliteDialect,
-  mysql: mysqlDialect
-};
-function getSqlDialect(params) {
-  return SQL_DIALECTS[params.dialect];
-}
-// packages/sql/src/codecs.ts
-import { VibeError, invalidStoredData } 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 wire.dateTime === "native";
-  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" || typeof value === "number")
-      return BigInt(value);
-    return 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})?)?$/;
-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 parsed = new Date(trimmed);
-  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
-}
-var dateNativeCodec = {
-  encode: identity,
-  decode: (value) => {
-    if (value instanceof Date)
-      return value;
-    if (typeof value === "string")
-      return parseDateTimeText({ text: value }) ?? new Date(value);
-    if (typeof value === "number")
-      return new Date(value);
-    return value;
+  booleanLiteral: { true: "1", false: "0" },
+  quoteIdent({ name }) {
+    return `"${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')`;
   }
 };
-var dateTextCodec = {
-  encode: (value) => value instanceof Date ? value.toISOString() : value,
-  decode: dateNativeCodec.decode
-};
-var mysqlDateCodec = {
-  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;
+// packages/sql/src/dialects/mysql.ts
+var mysqlDialect = {
+  name: "mysql",
+  capabilities: MYSQL_CAPABILITIES,
+  inArrayStrategy: "expand",
+  tupleInStrategy: "rowValue",
+  upsertForm: "onDuplicateKey",
+  conflictKeyEquality: {
+    foldingScalars: ["Decimal"],
+    defaultStringMaxLength: 191,
+    textIsBinaryByDefault: false,
+    duplicatesInOneStatement: "lastWriteWins"
   },
-  decode: dateNativeCodec.decode
-};
-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 VibeError({
-        code: "VIBE_INTERNAL",
-        message: "a Json column returned text that is not valid JSON",
-        meta: { value },
-        cause
-      });
-    }
+  excludedRowRef: { form: "rowAlias", alias: "new" },
+  doNothingForm: "insertIgnore",
+  insensitiveLike: "lower",
+  strictMatchStrategy: "binary",
+  orderByNullsMode: "emulate",
+  offsetRequiresLimit: { limitText: "18446744073709551615" },
+  likeEscapeClause: null,
+  jsonPathMode: "mysqlExtract",
+  supportedJsonOps: [
+    "equals",
+    "string_contains",
+    "string_starts_with",
+    "string_ends_with",
+    "array_contains",
+    "array_starts_with",
+    "array_ends_with"
+  ],
+  jsonParamCast: "",
+  lastInsertIdSql: "SELECT LAST_INSERT_ID() AS `id`",
+  rowLockSyntax: {
+    strengths: Object.freeze({ update: "FOR UPDATE", share: "FOR SHARE" }),
+    wait: Object.freeze({ wait: "", nowait: " NOWAIT", skipLocked: " SKIP LOCKED" })
+  },
+  advisoryLockFunctions: null,
+  rowDefaultKeyword: true,
+  paramBudget: 1e4,
+  booleanLiteral: { true: "1", false: "0" },
+  quoteIdent({ name }) {
+    return `\`${name.replaceAll("`", "``")}\``;
+  },
+  quoteStringLiteral({ value }) {
+    return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "''")}'`;
+  },
+  placeholder() {
+    return "?";
+  },
+  renderDbNow({ offsetSeconds, collector }) {
+    if (offsetSeconds === 0)
+      return "NOW(6)";
+    return `DATE_ADD(NOW(6), INTERVAL ${collector.add(offsetSeconds)} SECOND)`;
   }
 };
-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/dialects/registry.ts
+var SQL_DIALECTS = {
+  postgres: postgresDialect,
+  sqlite: sqliteDialect,
+  mysql: mysqlDialect
 };
+function getSqlDialect(params) {
+  return SQL_DIALECTS[params.dialect];
+}
 // packages/sql/src/dialects/diagnostics.ts
-import { unsupportedCapability } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability4 } 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'" }
@@ -388,7 +1213,7 @@ var QUERIES = Object.freeze({
 function renderDiagnostic(params) {
   const query = QUERIES[params.query];
   if (params.dialect.name !== query.dialect) {
-    throw unsupportedCapability({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
+    throw unsupportedCapability4({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
   }
   return { text: query.text, values: [], returning: "none" };
 }
@@ -397,26 +1222,7 @@ function isFixedDiagnostic(params) {
 }
 
 // packages/sql/src/dialects/postgres-diagnostics.ts
-import { VibeError as VibeError2, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
-
-// packages/sql/src/params.ts
-class ParamCollector {
-  dialect;
-  values;
-  constructor(dialect) {
-    this.dialect = dialect;
-    this.values = [];
-  }
-  add(value) {
-    this.values.push(value);
-    return this.dialect.placeholder({ index: this.values.length });
-  }
-  addMany(values) {
-    return values.map((value) => this.add(value));
-  }
-}
-
-// packages/sql/src/dialects/postgres-diagnostics.ts
+import { VibeError as VibeError6, unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
 function renderPostgresExplain(params) {
   const { dialect, query, options } = params;
   requirePostgres({ dialect, feature: "query plan inspection (EXPLAIN)" });
@@ -451,7 +1257,7 @@ var POSTGRES_WORKLOAD_LIMITS = Object.freeze({
 });
 function requirePostgres(params) {
   if (params.dialect.name !== "postgres") {
-    throw unsupportedCapability2({
+    throw unsupportedCapability5({
       dialect: params.dialect.name,
       feature: params.feature,
       hint: "plan inspection and workload statistics are PostgreSQL-shaped; portable operation tracing works on every dialect"
@@ -469,7 +1275,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 VibeError2({
+      throw new VibeError6({
         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 }
@@ -488,7 +1294,7 @@ function renderPostgresWorkload(params) {
 function requireArg(params) {
   const { value, name, query } = params;
   if (value === undefined || value.length === 0) {
-    throw new VibeError2({
+    throw new VibeError6({
       code: "VIBE_CONFIG",
       message: `the "${query}" diagnostic read requires a ${name}`,
       meta: { query, argument: name }
@@ -498,10 +1304,10 @@ function requireArg(params) {
 }
 
 // packages/sql/src/dialects/postgres-rls-readiness.ts
-import { unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-rls.ts
-import { RlsContextError, VibeError as VibeError3, assertValidSchemaIR, unsupportedCapability as unsupportedCapability3, validateRlsContextIR } from "@vibeorm/schema";
+import { RlsContextError, VibeError as VibeError7, assertValidSchemaIR, unsupportedCapability as unsupportedCapability6, 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" } },
@@ -514,20 +1320,20 @@ var COLUMN_TYPES = {
 };
 function requireRls(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability3({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability6({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
   }
 }
-function identifier(params) {
+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 VibeError3({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS identifiers must be nonempty PostgreSQL identifiers of at most 63 bytes" });
+    throw new VibeError7({ 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 unsupportedCapability3({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: "Only public tables and temporary policy probes are supported" });
+    throw unsupportedCapability6({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: "Only public tables and temporary policy probes are supported" });
   }
-  return `${identifier({ dialect: params.dialect, name: params.schema ?? NATIVE_RLS.tableSchema })}.${identifier({ dialect: params.dialect, name: params.table })}`;
+  return `${identifier2({ dialect: params.dialect, name: params.schema ?? NATIVE_RLS.tableSchema })}.${identifier2({ dialect: params.dialect, name: params.table })}`;
 }
 function query(params) {
   return { text: params.text, values: params.values ?? [], returning: "none" };
@@ -550,7 +1356,7 @@ function renderRlsNoForce({ dialect, table }) {
 }
 function renderRlsDropPolicy({ dialect, table, policyName }) {
   requireRls({ dialect });
-  const name = identifier({ dialect, name: policyName ?? NATIVE_RLS.policyName });
+  const name = identifier2({ dialect, name: policyName ?? NATIVE_RLS.policyName });
   return query({ text: `DROP POLICY ${name} ON ${tableRef({ dialect, table })}` });
 }
 function renderRlsColumnType(params) {
@@ -566,14 +1372,14 @@ function renderRlsColumnType(params) {
     if (native !== undefined)
       return native;
   }
-  throw unsupportedCapability3({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
+  throw unsupportedCapability6({ 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 VibeError3({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
+    throw new VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
   }
   return model;
 }
@@ -589,7 +1395,7 @@ function predicate(params) {
   if (typeof rule === "object" && "where" in rule) {
     return Object.entries(rule.where).map(([name, ref]) => {
       const field = model.fields.find((entry) => entry.name === name);
-      const column = identifier({ dialect, name: field.dbName ?? field.name });
+      const column = identifier2({ dialect, name: field.dbName ?? field.name });
       const physicalType = renderRlsColumnType({ dialect, field });
       return `(${column} = NULLIF(current_setting('${NATIVE_RLS.settingPrefix}${ref.context}', true), '')::${physicalType})`;
     }).join(" AND ");
@@ -597,21 +1403,21 @@ function predicate(params) {
   if (typeof rule === "object" && "through" in rule) {
     const relation = model.relations.find((entry) => entry.name === rule.through);
     const parent = schema.models.find((entry) => entry.name === relation.targetModel);
-    const alias = identifier({ dialect, name: NATIVE_RLS.parentAlias });
-    const child = identifier({ dialect, name: model.dbName ?? model.name });
+    const alias = identifier2({ dialect, name: NATIVE_RLS.parentAlias });
+    const child = identifier2({ dialect, name: model.dbName ?? model.name });
     const join = relation.fields.map((name, index) => {
       const childField = model.fields.find((field) => field.name === name);
       const parentField = parent.fields.find((field) => field.name === relation.references[index]);
-      return `(${alias}.${identifier({ dialect, name: parentField.dbName ?? parentField.name })} = ${child}.${identifier({ dialect, name: childField.dbName ?? childField.name })})`;
+      return `(${alias}.${identifier2({ dialect, name: parentField.dbName ?? parentField.name })} = ${child}.${identifier2({ dialect, name: childField.dbName ?? childField.name })})`;
     }).join(" AND ");
     return `EXISTS (SELECT 1 FROM ${tableRef({ dialect, table: parent.dbName ?? parent.name })} AS ${alias} WHERE ${join})`;
   }
-  throw new VibeError3({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
+  throw new VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
 }
 function renderRlsPolicy(params) {
   const model = protectedModel(params);
   const expression = predicate({ dialect: params.dialect, schema: params.schema, model });
-  const name = identifier({ dialect: params.dialect, name: params.policyName ?? NATIVE_RLS.policyName });
+  const name = identifier2({ dialect: params.dialect, name: params.policyName ?? NATIVE_RLS.policyName });
   const table = tableRef({ dialect: params.dialect, table: model.dbName ?? model.name, schema: params.targetSchema });
   return query({ text: `CREATE POLICY ${name} ON ${table} AS PERMISSIVE FOR ALL TO PUBLIC USING (${expression}) WITH CHECK (${expression})` });
 }
@@ -640,7 +1446,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 VibeError3({ code: "VIBE_CONFIG", message: "PGlite native RLS requires a trusted nonempty runtime role name" });
+    throw new VibeError7({ 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 });
@@ -775,7 +1581,7 @@ ORDER BY c.relname, t.tgname`,
 });
 function requireRls2(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability4({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability7({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
   }
 }
 function renderRlsReadinessQuery(params) {
@@ -807,7 +1613,7 @@ function renderRlsPolicyPath(params) {
 }
 
 // packages/sql/src/render.ts
-import { internalError, unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
+import { internalError as internalError2, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
 
 // packages/sql/src/like.ts
 function escapeLikePattern(params) {
@@ -853,6 +1659,8 @@ function renderStatement(params) {
     }
     case "select":
       return renderSelect({ dialect, statement, collector });
+    case "advisoryLock":
+      return renderAdvisoryLock({ dialect, statement, collector });
     case "insert":
       return renderInsert({ dialect, statement, collector });
     case "update":
@@ -888,7 +1696,7 @@ function quoteCol(dialect, column) {
   const ref = column.table === undefined ? name : `${dialect.quoteIdent({ name: column.table })}.${name}`;
   if (column.castReal === true) {
     if (dialect.name !== "sqlite") {
-      throw internalError({ message: "ColRef.castReal is a sqlite Decimal construct" });
+      throw internalError2({ message: "ColRef.castReal is a sqlite Decimal construct" });
     }
     return `CAST(${ref} AS REAL)`;
   }
@@ -902,7 +1710,7 @@ function quoteProjection(dialect, column) {
     return `${base} AS ${dialect.quoteIdent({ name: column.alias })}`;
   }
   if (dialect.name !== "postgres") {
-    throw internalError({ message: "ColRef.transform is a postgres lateral-join construct" });
+    throw internalError2({ message: "ColRef.transform is a postgres lateral-join construct" });
   }
   const ref = quoteCol(dialect, column);
   const alias = dialect.quoteIdent({ name: column.name });
@@ -918,10 +1726,10 @@ function renderTable(dialect, table) {
 }
 function assertCount(value, what) {
   if (!Number.isSafeInteger(value) || value < 0) {
-    throw internalError({ message: `${what} must be a non-negative integer, got ${value}` });
+    throw internalError2({ message: `${what} must be a non-negative integer, got ${value}` });
   }
 }
-var COMPARISON_SQL = {
+var COMPARISON_SQL2 = {
   eq: "=",
   ne: "<>",
   gt: ">",
@@ -950,7 +1758,7 @@ function renderAggRef(dialect, agg) {
 function assertScalarArrays(dialect, feature) {
   if (dialect.capabilities.scalarArrays)
     return;
-  throw unsupportedCapability5({
+  throw unsupportedCapability8({
     dialect: dialect.name,
     feature,
     hint: "only postgres has native array columns \u2014 model the list as a related table instead"
@@ -960,9 +1768,9 @@ function renderExpr(params) {
   const { dialect, expr, collector } = params;
   switch (expr.kind) {
     case "cmp": {
-      const op = COMPARISON_SQL[expr.op];
+      const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError2({ message: `unknown comparison operator "${expr.op}"` });
       }
       if (isDbNowMarker(expr.value)) {
         return `${quoteCol(dialect, expr.column)} ${op} ${dialect.renderDbNow({ offsetSeconds: expr.value.offsetSeconds, collector })}`;
@@ -970,9 +1778,9 @@ function renderExpr(params) {
       return `${quoteCol(dialect, expr.column)} ${op} ${collector.add(expr.value)}`;
     }
     case "cmpCol": {
-      const op = COMPARISON_SQL[expr.op];
+      const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError2({ message: `unknown comparison operator "${expr.op}"` });
       }
       return `${quoteCol(dialect, expr.left)} ${op} ${quoteCol(dialect, expr.right)}`;
     }
@@ -992,11 +1800,11 @@ function renderExpr(params) {
     }
     case "tupleIn": {
       if (expr.columns.length === 0) {
-        throw internalError({ message: "tupleIn needs at least one column" });
+        throw internalError2({ message: "tupleIn needs at least one column" });
       }
       for (const row of expr.rows) {
         if (row.length !== expr.columns.length) {
-          throw internalError({
+          throw internalError2({
             message: `tupleIn row has ${row.length} values for ${expr.columns.length} columns`
           });
         }
@@ -1068,9 +1876,9 @@ function renderExpr(params) {
     case "not":
       return `NOT (${renderExpr({ dialect, expr: expr.operand, collector })})`;
     case "aggCmp": {
-      const op = COMPARISON_SQL[expr.op];
+      const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError2({ message: `unknown comparison operator "${expr.op}"` });
       }
       return `${renderAggRef(dialect, expr.agg)} ${op} ${collector.add(expr.value)}`;
     }
@@ -1098,6 +1906,8 @@ function renderExpr(params) {
       const sub = renderSelect({ dialect, statement: expr.select, collector });
       return `${expr.negate === true ? "NOT " : ""}EXISTS (${sub.text})`;
     }
+    case "composed":
+      return `(${renderSqlFragment({ dialect, fragment: expr.fragment, collector })})`;
     case "fragment":
       return renderFragment({ dialect, fragment: expr.fragment, collector });
     case "raw":
@@ -1134,7 +1944,7 @@ function jsonPathString(path) {
 function jsonStringPattern(params) {
   const { expr } = params;
   if (typeof expr.value !== "string") {
-    throw internalError({ message: `json ${expr.op} expects a string operand` });
+    throw internalError2({ message: `json ${expr.op} expects a string operand` });
   }
   if (expr.op === "string_contains")
     return containsPattern({ raw: expr.value });
@@ -1158,7 +1968,7 @@ function renderJsonLike(params) {
 function renderJsonFilter(params) {
   const { dialect, expr, collector } = params;
   if (!dialect.supportedJsonOps.includes(expr.op)) {
-    throw unsupportedCapability5({
+    throw unsupportedCapability8({
       dialect: dialect.name,
       feature: `the json filter "${expr.op}"`,
       hint: `this dialect can express: ${dialect.supportedJsonOps.join(", ")}`
@@ -1213,7 +2023,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 unsupportedCapability5({
+            throw unsupportedCapability8({
               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"
@@ -1225,7 +2035,7 @@ function renderJsonFilter(params) {
         return tests.length === 0 ? guard : `(${[guard, ...tests].join(" AND ")})`;
       }
       default:
-        throw internalError({ message: `json op "${expr.op}" leaked past supportedJsonOps on sqlite` });
+        throw internalError2({ message: `json op "${expr.op}" leaked past supportedJsonOps on sqlite` });
     }
   }
   const column = quoteCol(dialect, expr.column);
@@ -1280,11 +2090,11 @@ function renderSelectExpr(params) {
 function renderPositionalRow(params) {
   const { dialect, join, subAlias } = params;
   if (join.select.columns.length === 0 || join.select.selectExpr !== undefined || (join.select.aggregates?.length ?? 0) > 0 || join.select.rowNumber !== undefined) {
-    throw internalError({ message: "positional lateral rows require an explicit column-only projection" });
+    throw internalError2({ message: "positional lateral rows require an explicit column-only projection" });
   }
   const names = join.select.columns.map((column) => projectionOutputName({ column }));
   if (new Set(names).size !== names.length) {
-    throw internalError({ message: "positional lateral projection has duplicate output names" });
+    throw internalError2({ message: "positional lateral projection has duplicate output names" });
   }
   const values = names.map((name) => `${subAlias}.${dialect.quoteIdent({ name })}`);
   const chunks = [];
@@ -1292,7 +2102,7 @@ function renderPositionalRow(params) {
     chunks.push(`json_build_array(${values.slice(index, index + JSON_TRANSPORT.chunkSize).join(", ")})`);
   }
   if (chunks.length > JSON_TRANSPORT.chunkSize) {
-    throw internalError({ message: "positional lateral projection exceeds the transport width limit" });
+    throw internalError2({ message: "positional lateral projection exceeds the transport width limit" });
   }
   return chunks.length === 1 ? chunks[0] : `json_build_array(${chunks.join(", ")})`;
 }
@@ -1301,7 +2111,7 @@ function renderLateralJoin(params) {
   const inner = renderSelect({ dialect, statement: join.select, collector });
   if (join.agg === "count") {
     if (join.rowFormat === "positional" || join.select.columns.length !== 0 || join.select.selectExpr?.kind !== "countAll" || join.select.selectExpr.alias !== join.columnAlias || join.select.groupBy !== undefined || join.select.having !== undefined || join.select.limit !== undefined || join.select.offset !== undefined || join.select.distinctOn !== undefined) {
-      throw internalError({ message: "count lateral must return one ungrouped COUNT(*) under its column alias" });
+      throw internalError2({ message: "count lateral must return one ungrouped COUNT(*) under its column alias" });
     }
     return `LEFT JOIN LATERAL (${inner.text}) AS ${dialect.quoteIdent({ name: join.alias })} ON true`;
   }
@@ -1336,10 +2146,10 @@ function applyReturning(params) {
 function renderSelect(params) {
   const { dialect, statement, collector } = params;
   if (statement.selectExpr !== undefined && statement.columns.length > 0 && statement.selectExpr.kind !== "countAll") {
-    throw internalError({ message: "only countAll can combine with a column list" });
+    throw internalError2({ message: "only countAll can combine with a column list" });
   }
   if (statement.selectExpr !== undefined && statement.aggregates !== undefined && statement.aggregates.length > 0) {
-    throw internalError({ message: "selectExpr and aggregates cannot combine" });
+    throw internalError2({ message: "selectExpr and aggregates cannot combine" });
   }
   const columnList = statement.columns.map((column) => quoteProjection(dialect, column));
   if (statement.selectExpr !== undefined) {
@@ -1353,7 +2163,7 @@ function renderSelect(params) {
   if (statement.rowNumber !== undefined) {
     const rowNumber = statement.rowNumber;
     if (rowNumber.partitionBy.length === 0) {
-      throw internalError({ message: "rowNumber needs at least one partition column" });
+      throw internalError2({ message: "rowNumber needs at least one partition column" });
     }
     const partition = rowNumber.partitionBy.map((column) => quoteCol(dialect, column)).join(", ");
     const order = rowNumber.orderBy.length === 0 ? "" : ` ORDER BY ${rowNumber.orderBy.map((term) => renderOrderTerm({ dialect, term, collector })).join(", ")}`;
@@ -1362,7 +2172,7 @@ function renderSelect(params) {
   let distinctPrefix = "";
   if (statement.distinctOn !== undefined && statement.distinctOn.length > 0) {
     if (!dialect.capabilities.distinctOn) {
-      throw unsupportedCapability5({
+      throw unsupportedCapability8({
         dialect: dialect.name,
         feature: "SELECT DISTINCT ON",
         hint: "postgres-only \u2014 the runtime emulates distinct client-side on this dialect"
@@ -1374,7 +2184,7 @@ function renderSelect(params) {
   let from;
   if (statement.fromSelect !== undefined) {
     if (statement.table.alias !== undefined) {
-      throw internalError({ message: "fromSelect uses table.name as the subquery alias \u2014 table.alias must be unset" });
+      throw internalError2({ message: "fromSelect uses table.name as the subquery alias \u2014 table.alias must be unset" });
     }
     const inner = renderSelect({ dialect, statement: statement.fromSelect, collector });
     from = `(${inner.text}) AS ${dialect.quoteIdent({ name: statement.table.name })}`;
@@ -1385,7 +2195,7 @@ function renderSelect(params) {
   if (statement.innerJoins !== undefined && statement.innerJoins.length > 0) {
     for (const join of statement.innerJoins) {
       if (join.on.length === 0) {
-        throw internalError({ message: "inner join needs at least one ON pair" });
+        throw internalError2({ message: "inner join needs at least one ON pair" });
       }
       const on = join.on.map((pair) => `${quoteCol(dialect, pair.left)} = ${quoteCol(dialect, pair.right)}`).join(" AND ");
       text += ` INNER JOIN ${renderTable(dialect, join.table)} ON ${on}`;
@@ -1393,7 +2203,7 @@ function renderSelect(params) {
   }
   if (statement.lateralJoins !== undefined && statement.lateralJoins.length > 0) {
     if (!dialect.capabilities.lateralJoin) {
-      throw unsupportedCapability5({
+      throw unsupportedCapability8({
         dialect: dialect.name,
         feature: "LATERAL JOIN relation loading",
         hint: 'use the portable "query" relation strategy on this dialect'
@@ -1427,22 +2237,24 @@ function renderSelect(params) {
     }
     text += ` OFFSET ${statement.offset}`;
   }
-  if (statement.lockForUpdate === true && dialect.selectForUpdate !== null) {
-    text += dialect.selectForUpdate;
+  if (statement.rowLock !== undefined) {
+    const clause = renderRowLockClause({ dialect, lock: statement.rowLock });
+    if (clause !== null)
+      text += ` ${clause}`;
   }
   return { text, values: collector.values, returning: "none" };
 }
 function renderInsert(params) {
   const { dialect, statement, collector } = params;
   if (statement.columns.length === 0) {
-    throw internalError({ message: "insert requires at least one column" });
+    throw internalError2({ message: "insert requires at least one column" });
   }
   if (statement.rows.length === 0) {
-    throw internalError({ message: "insert requires at least one row" });
+    throw internalError2({ message: "insert requires at least one row" });
   }
   for (const row of statement.rows) {
     if (row.length !== statement.columns.length) {
-      throw internalError({
+      throw internalError2({
         message: `insert row has ${row.length} values but ${statement.columns.length} columns`
       });
     }
@@ -1460,14 +2272,14 @@ function renderInsert(params) {
     if (!isSqlDefaultCell(value))
       return collector.add(value);
     if (!dialect.rowDefaultKeyword) {
-      throw internalError({
+      throw internalError2({
         message: `${dialect.name} cannot render a per-row DEFAULT cell \u2014 rows must be grouped by column set`
       });
     }
     return "DEFAULT";
   }).join(", ")})`).join(", ");
   let text = `${insertKeyword} ${renderTable(dialect, statement.table)} (${columnList}) VALUES ${rowsSql}`;
-  if (onConflict !== undefined && !("doNothing" in onConflict) && dialect.excludedRowRef.form === "rowAlias" && Object.values(onConflict.update).some((value) => isExcludedRef(value))) {
+  if (onConflict !== undefined && !("doNothing" in onConflict) && dialect.excludedRowRef.form === "rowAlias" && Object.values(onConflict.update).some((value) => isExcludedRef(value) || isSqlFragment(value) && sqlUsesIncoming({ fragment: value }))) {
     text += ` AS ${dialect.quoteIdent({ name: dialect.excludedRowRef.alias })}`;
   }
   if (onConflict !== undefined) {
@@ -1476,7 +2288,7 @@ function renderInsert(params) {
         let target = "";
         if (onConflict.constraint !== undefined) {
           if (dialect.name !== "postgres") {
-            throw unsupportedCapability5({
+            throw unsupportedCapability8({
               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"
@@ -1491,7 +2303,7 @@ function renderInsert(params) {
         }
         text += ` ON CONFLICT${target} DO NOTHING`;
       } else if (onConflict.constraint !== undefined || onConflict.conflictWhere !== undefined) {
-        throw unsupportedCapability5({
+        throw unsupportedCapability8({
           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"
@@ -1500,23 +2312,23 @@ function renderInsert(params) {
     } else {
       const updates = Object.entries(onConflict.update);
       if (updates.length === 0) {
-        throw internalError({ message: "upsert update must set at least one column" });
+        throw internalError2({ message: "upsert update must set at least one column" });
       }
       const selfRef = dialect.quoteIdent({ name: statement.table.name });
-      const assignments = renderAssignments({ dialect, entries: updates, collector, selfRef, allowExcluded: true });
+      const assignments = renderAssignments({ dialect, entries: updates, collector, selfRef, allowExcluded: true, tableName: statement.table.name });
       if (dialect.upsertForm === "onConflict") {
         if (onConflict.lastInsertIdColumn !== undefined) {
-          throw internalError({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
+          throw internalError2({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
         }
         if (onConflict.constraint !== undefined && dialect.name !== "postgres") {
-          throw unsupportedCapability5({
+          throw unsupportedCapability8({
             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"
           });
         }
         if (onConflict.constraint !== undefined && onConflict.conflictWhere !== undefined) {
-          throw internalError({
+          throw internalError2({
             message: "a named-constraint conflict target already identifies the index \u2014 it cannot carry a partial predicate too"
           });
         }
@@ -1525,14 +2337,14 @@ function renderInsert(params) {
         text += ` ON CONFLICT${target} DO UPDATE SET ${assignments}`;
       } else {
         if (onConflict.constraint !== undefined) {
-          throw unsupportedCapability5({
+          throw unsupportedCapability8({
             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 unsupportedCapability5({
+          throw unsupportedCapability8({
             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"
@@ -1550,7 +2362,7 @@ function renderUpdate(params) {
   const { dialect, statement, collector } = params;
   const assignments = Object.entries(statement.set);
   if (assignments.length === 0) {
-    throw internalError({ message: "update must set at least one column" });
+    throw internalError2({ message: "update must set at least one column" });
   }
   const setSql = renderAssignments({ dialect, entries: assignments, collector });
   let text = `UPDATE ${renderTable(dialect, statement.table)} SET ${setSql}`;
@@ -1571,9 +2383,14 @@ function renderAssignments(params) {
   return entries.map(([name, value]) => {
     const column = dialect.quoteIdent({ name });
     const read = selfRef === undefined ? column : `${selfRef}.${column}`;
+    if (isSqlFragment(value)) {
+      if (params.allowExcluded !== true || selfRef === undefined)
+        throw internalError2({ message: "SQL assignment fragments require a conflict update" });
+      return `${column} = ${renderSqlFragment({ dialect, fragment: value, collector, conflict: { table: params.tableName } })}`;
+    }
     if (isExcludedRef(value)) {
       if (params.allowExcluded !== true) {
-        throw internalError({
+        throw internalError2({
           message: `an incoming-row reference (${value.column}) is only meaningful inside an upsert's update arm`
         });
       }
@@ -1607,12 +2424,377 @@ function renderDelete(params) {
   const returning = applyReturning({ dialect, requested: statement.returning });
   return { text: text + returning.suffix, values: collector.values, returning: returning.status };
 }
+// packages/sql/src/dialects/sqlite-table-definition.ts
+import { VibeError as VibeError8 } from "@vibeorm/schema";
+function tableDefinitionParts(params) {
+  const sql2 = params.sql;
+  if (!/^\s*CREATE\s+(?:TEMP(?:ORARY)?\s+)?TABLE\b/i.test(sql2))
+    throw unavailable();
+  const parts = [];
+  let start = -1;
+  let depth = 0;
+  let quote;
+  for (let index = 0;index < sql2.length; index++) {
+    const char = sql2[index];
+    if (quote !== undefined) {
+      if (char === quote) {
+        if (quote !== "]" && sql2[index + 1] === quote)
+          index++;
+        else
+          quote = undefined;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "[") {
+      quote = "]";
+      continue;
+    }
+    if (char === "-" && sql2[index + 1] === "-") {
+      const end = sql2.indexOf(`
+`, index + 2);
+      if (end < 0)
+        break;
+      index = end;
+      continue;
+    }
+    if (char === "/" && sql2[index + 1] === "*") {
+      const end = sql2.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(sql2.slice(start, index).trim());
+        return { clauses: parts, suffix: sql2.slice(index + 1) };
+      }
+    } else if (char === "," && depth === 1) {
+      parts.push(sql2.slice(start, index).trim());
+      start = index + 1;
+    }
+  }
+  throw unavailable();
+}
+function unavailable() {
+  return new VibeError8({ 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/constraint-owned-index.ts
+import { unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
+function renderConstraintOwnedIndexDrop(params) {
+  if (params.dialect.name !== "postgres")
+    throw unsupportedCapability9({ 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 unsupportedCapability10 } from "@vibeorm/schema";
+function renderMysqlCheckProbe(params) {
+  if (params.dialect.name !== "mysql")
+    throw unsupportedCapability10({ 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 unsupportedCapability10({ 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 unsupportedCapability10({ 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(`,
+`)}
+)${parts.suffix}`, values: [], returning: "none" };
+    }
+    case "read":
+      return { text: `SHOW CREATE TABLE ${probe}`, values: [], returning: "none" };
+    case "drop":
+      return { text: `DROP TEMPORARY TABLE ${probe}`, values: [], returning: "none" };
+  }
+}
+// packages/sql/src/dialects/migration-history.ts
+function renderMigrationHistoryQuery(params) {
+  const q = (name) => params.dialect.quoteIdent({ name });
+  return { text: `SELECT ${q("name")}, ${q("checksum")}, ${q("statement_index")}, ${q("error")} FROM ${q(params.namespace)}.${q("_vibe_migrations")} ORDER BY ${q("id")}`, values: [], returning: "none" };
+}
+// packages/sql/src/dialects/sqlite-constraints.ts
+var IDENTIFIER = '(?:"(?:[^" ]| |"")+"|`(?:[^`]|``)+`|\\[[^\\]]+\\]|[A-Za-z_][A-Za-z_0-9]*)';
+function identifier3(value) {
+  const text = value.trim();
+  if (text.startsWith('"'))
+    return text.slice(1, -1).replaceAll('""', '"');
+  if (text.startsWith("`"))
+    return text.slice(1, -1).replaceAll("``", "`");
+  if (text.startsWith("["))
+    return text.slice(1, -1);
+  return text;
+}
+function sqliteTableConstraints(params) {
+  const result = [];
+  for (const clause of tableDefinitionParts(params).clauses) {
+    const named = new RegExp(`^CONSTRAINT\\s+(${IDENTIFIER})\\s+`, "i").exec(clause);
+    const body = named === null ? clause : clause.slice(named[0].length);
+    const kind = /^(CHECK|FOREIGN\s+KEY|UNIQUE|PRIMARY\s+KEY)\s*\(/i.exec(body);
+    if (kind === null)
+      continue;
+    const type = /^CHECK$/i.test(kind[1]) ? "check" : /^FOREIGN/i.test(kind[1]) ? "foreignKey" : /^PRIMARY/i.test(kind[1]) ? "primaryKey" : "unique";
+    const parts = tableDefinitionParts({ sql: `CREATE TABLE x ${body.slice(kind[0].indexOf("("))}` });
+    const columns = type === "check" ? [] : parts.clauses.map(identifier3);
+    result.push({ name: named === null ? `@sqlite:${type}:${result.length}` : identifier3(named[1]), named: named !== null, type, sql: body, columns });
+  }
+  return result;
+}
+// packages/sql/src/dialects/migration-visibility.ts
+import { unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
+function renderMigrationVisibility(params) {
+  if (params.dialect.name !== "mysql")
+    throw unsupportedCapability11({ 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 unsupportedCapability12 } from "@vibeorm/schema";
+function renderSqliteColumnInventory(params) {
+  if (params.dialect.name !== "sqlite")
+    throw unsupportedCapability12({ 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 unsupportedCapability12({ 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 unsupportedCapability12({ 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) {
+  const collector = new ParamCollector(params.dialect);
+  const namespace = collector.add(params.namespace);
+  if (params.dialect.name === "postgres") {
+    return { text: `WITH relations AS (
+  SELECT c.oid, c.relname, c.relkind FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+  WHERE n.nspname = ${namespace} AND c.relname <> '_vibe_migrations'
+    AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend jd JOIN pg_catalog.pg_class jt ON jt.oid = jd.refobjid WHERE jd.classid = 'pg_class'::regclass AND jd.objid = c.oid AND jd.refclassid = 'pg_class'::regclass AND jt.relname = '_vibe_migrations' AND jt.relnamespace = c.relnamespace)
+    AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_class'::regclass AND d.objid = c.oid AND d.deptype = 'e')
+)
+SELECT CASE WHEN r.relkind IN ('v','m') THEN 'view' WHEN r.relkind = 'S' THEN 'sequence' ELSE 'table' END AS kind, r.relname::text AS name, NULL::text AS parent, NULL::text AS subtype, NULL::text AS signature, NULL::text AS backing FROM relations r WHERE r.relkind IN ('r','p','v','m','S')
+UNION ALL SELECT 'constraint', con.conname::text, r.relname::text, con.contype::text, NULL, NULL FROM relations r JOIN pg_catalog.pg_constraint con ON con.conrelid = r.oid WHERE con.contype IN ('c','f','x','u','p')
+UNION ALL SELECT 'index', ix.relname::text, r.relname::text, NULL, NULL, con.conname::text FROM relations r JOIN pg_catalog.pg_index i ON i.indrelid = r.oid JOIN pg_catalog.pg_class ix ON ix.oid = i.indexrelid LEFT JOIN pg_catalog.pg_constraint con ON con.conindid = i.indexrelid AND con.contype IN ('p','u','x')
+UNION ALL SELECT 'trigger', t.tgname::text, r.relname::text, NULL, NULL, NULL FROM relations r JOIN pg_catalog.pg_trigger t ON t.tgrelid = r.oid WHERE NOT t.tgisinternal
+UNION ALL SELECT 'column', a.attname::text, r.relname::text, NULL, NULL, NULL FROM relations r JOIN pg_catalog.pg_attribute a ON a.attrelid = r.oid WHERE a.attnum > 0 AND NOT a.attisdropped AND r.relkind IN ('r','p')
+UNION ALL SELECT CASE WHEN a.attgenerated <> '' THEN 'generatedColumn' ELSE 'columnDefault' END, a.attname::text, r.relname::text, NULL, NULL, NULL FROM relations r JOIN pg_catalog.pg_attribute a ON a.attrelid = r.oid JOIN pg_catalog.pg_attrdef d ON d.adrelid = r.oid AND d.adnum = a.attnum WHERE a.attnum > 0 AND NOT a.attisdropped
+UNION ALL SELECT 'function', p.proname::text, NULL, NULL, COALESCE((SELECT json_agg(json_build_object('namespace', tn.nspname, 'name', t.typname) ORDER BY a.ord)::text FROM unnest(p.proargtypes) WITH ORDINALITY a(oid, ord) JOIN pg_catalog.pg_type t ON t.oid = a.oid JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace), '[]'), NULL FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = ${namespace} AND p.prokind = 'f' AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_proc'::regclass AND d.objid = p.oid AND d.deptype = 'e')
+ORDER BY kind, parent, name`, values: collector.values, returning: "none" };
+  }
+  if (params.dialect.name === "mysql") {
+    const n = () => collector.add(params.namespace);
+    return { text: `SELECT CASE WHEN TABLE_TYPE = 'VIEW' THEN 'view' ELSE 'table' END AS kind, TABLE_NAME AS name, NULL AS parent, NULL AS subtype, NULL AS signature, NULL AS backing FROM information_schema.TABLES WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME <> '_vibe_migrations'
+UNION ALL SELECT 'constraint', CONSTRAINT_NAME, TABLE_NAME, CONSTRAINT_TYPE, NULL, NULL FROM information_schema.TABLE_CONSTRAINTS WHERE TABLE_SCHEMA = ${n()} AND TABLE_NAME <> '_vibe_migrations'
+UNION ALL SELECT 'index', s.INDEX_NAME, s.TABLE_NAME, NULL, NULL, tc.CONSTRAINT_NAME FROM information_schema.STATISTICS s LEFT JOIN information_schema.TABLE_CONSTRAINTS tc ON tc.TABLE_SCHEMA = s.TABLE_SCHEMA AND tc.TABLE_NAME = s.TABLE_NAME AND tc.CONSTRAINT_NAME = s.INDEX_NAME AND tc.CONSTRAINT_TYPE IN ('UNIQUE', 'PRIMARY KEY') WHERE s.TABLE_SCHEMA = ${n()} AND s.TABLE_NAME <> '_vibe_migrations' GROUP BY s.INDEX_NAME, s.TABLE_NAME, tc.CONSTRAINT_NAME
+UNION ALL SELECT 'trigger', TRIGGER_NAME, EVENT_OBJECT_TABLE, NULL, NULL, NULL FROM information_schema.TRIGGERS WHERE TRIGGER_SCHEMA = ${n()}
+UNION ALL SELECT 'column', COLUMN_NAME, TABLE_NAME, NULL, NULL, NULL FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ${n()} AND TABLE_NAME <> '_vibe_migrations'
+UNION ALL SELECT CASE WHEN GENERATION_EXPRESSION <> '' THEN 'generatedColumn' ELSE 'columnDefault' END, COLUMN_NAME, TABLE_NAME, NULL, NULL, NULL FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ${n()} AND TABLE_NAME <> '_vibe_migrations' AND (COLUMN_DEFAULT IS NOT NULL OR GENERATION_EXPRESSION <> '')
+UNION ALL SELECT 'function', ROUTINE_NAME, NULL, NULL, '[]', NULL FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ${n()} AND ROUTINE_TYPE = 'FUNCTION'
+ORDER BY kind, parent, name`, values: collector.values, returning: "none" };
+  }
+  const schema = params.dialect.quoteIdent({ name: params.namespace });
+  return { text: `SELECT type AS kind, name, tbl_name AS parent, sql AS definition FROM ${schema}.sqlite_schema WHERE name NOT LIKE 'sqlite_%' AND name <> '_vibe_migrations' ORDER BY type, tbl_name, name`, values: [], returning: "none" };
+}
+// packages/sql/src/dialects/migration-objects.ts
+import { unsupportedCapability as unsupportedCapability13 } from "@vibeorm/schema";
+function renderMigrationObjectQuery(params) {
+  const { dialect, identity: object } = params;
+  const collector = new ParamCollector(dialect);
+  const physical = "table" in object ? object.table : object.name;
+  const namespace = collector.add(physical.namespace);
+  const name = collector.add(physical.name);
+  let text;
+  if (dialect.name === "postgres") {
+    const relation = `FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace`;
+    const where = `n.nspname = ${namespace} AND c.relname = ${name}`;
+    switch (object.kind) {
+      case "constraint": {
+        const enforcement = object.constraintType === "foreignKey" ? `, (SELECT bool_and(t.tgenabled IN ('O', 'A')) FROM pg_catalog.pg_trigger t WHERE t.tgconstraint = con.oid) AS "triggersEnabled"` : "";
+        text = `SELECT con.contype::text AS "type", pg_catalog.pg_get_constraintdef(con.oid, false) AS "definition", con.convalidated AS "validated", con.condeferrable AS "deferrable", con.condeferred AS "deferred"${enforcement} ${relation} JOIN pg_catalog.pg_constraint con ON con.conrelid = c.oid WHERE ${where} AND con.conname = ${collector.add(object.name)}`;
+        break;
+      }
+      case "trigger":
+        text = `SELECT pg_catalog.pg_get_triggerdef(t.oid, false) AS "definition", t.tgenabled::text AS "enabled", pn.nspname::text AS "functionNamespace", p.proname::text AS "functionName", pg_catalog.pg_get_function_identity_arguments(p.oid) AS "functionArguments" ${relation} JOIN pg_catalog.pg_trigger t ON t.tgrelid = c.oid JOIN pg_catalog.pg_proc p ON p.oid = t.tgfoid JOIN pg_catalog.pg_namespace pn ON pn.oid = p.pronamespace WHERE ${where} AND t.tgname = ${collector.add(object.name)} AND NOT t.tgisinternal`;
+        break;
+      case "function":
+        text = `SELECT pg_catalog.pg_get_functiondef(p.oid) AS "definition", p.provolatile::text AS "volatility", p.prosecdef AS "securityDefiner", p.proisstrict AS "strict", p.proconfig::text AS "config", pg_catalog.pg_get_function_result(p.oid) AS "result" FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = ${namespace} AND p.proname = ${name} AND p.prokind = 'f' AND ARRAY(SELECT tn.nspname || '.' || t.typname FROM unnest(p.proargtypes) WITH ORDINALITY a(oid, ord) JOIN pg_catalog.pg_type t ON t.oid = a.oid JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace ORDER BY a.ord) = ${collector.add(object.argumentTypes.map((type) => `${type.namespace}.${type.name}`))}::text[]`;
+        break;
+      case "view":
+        text = `SELECT pg_catalog.pg_get_viewdef(c.oid, false) AS "definition", c.relkind::text AS "type", c.reloptions::text AS "options" ${relation} WHERE ${where} AND c.relkind IN ('v', 'm')`;
+        break;
+      case "sequence":
+        text = `SELECT pg_catalog.format_type(s.seqtypid, NULL) AS "type", s.seqstart::text AS "start", s.seqincrement::text AS "increment", s.seqmax::text AS "max", s.seqmin::text AS "min", s.seqcache::text AS "cache", s.seqcycle AS "cycle" ${relation} JOIN pg_catalog.pg_sequence s ON s.seqrelid = c.oid WHERE ${where}`;
+        break;
+      case "column":
+      case "columnDefault":
+      case "generatedColumn":
+        text = `SELECT pg_catalog.format_type(a.atttypid, a.atttypmod) AS "type", a.attnotnull AS "notNull", a.attgenerated::text AS "generated", a.attidentity::text AS "identity", pg_catalog.pg_get_expr(d.adbin, d.adrelid, false) AS "definition" ${relation} JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid LEFT JOIN pg_catalog.pg_attrdef d ON d.adrelid = c.oid AND d.adnum = a.attnum WHERE ${where} AND a.attname = ${collector.add(object.column)} AND a.attnum > 0 AND NOT a.attisdropped`;
+        break;
+      case "index":
+        text = `SELECT pg_catalog.pg_get_indexdef(i.indexrelid, 0, false) AS "definition", i.indisunique AS "unique", i.indisvalid AS "valid", i.indisready AS "ready", con.conname::text AS "constraint", con.contype::text AS "constraintType" ${relation} JOIN pg_catalog.pg_index i ON i.indrelid = c.oid JOIN pg_catalog.pg_class ix ON ix.oid = i.indexrelid LEFT JOIN pg_catalog.pg_constraint con ON con.conindid = i.indexrelid AND con.contype IN ('p', 'u', 'x') WHERE ${where} AND ix.relname = ${collector.add(object.name)}`;
+        break;
+      case "table":
+        text = `SELECT c.relkind::text AS "type", c.relrowsecurity AS "rls", c.relforcerowsecurity AS "forceRls" ${relation} WHERE ${where} AND c.relkind IN ('r', 'p')`;
+        break;
+      case "postgresExtension":
+        text = `SELECT e.extversion::text AS "version", e.extrelocatable AS "relocatable" FROM pg_catalog.pg_extension e JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace WHERE n.nspname = ${namespace} AND e.extname = ${name}`;
+        break;
+    }
+  } else if (dialect.name === "mysql") {
+    switch (object.kind) {
+      case "view":
+        text = `SELECT VIEW_DEFINITION AS definition, CHECK_OPTION AS checkOption, SECURITY_TYPE AS securityType, DEFINER AS definer FROM information_schema.VIEWS WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name}`;
+        break;
+      case "trigger":
+        text = `SELECT ACTION_STATEMENT AS definition, ACTION_TIMING AS timing, EVENT_MANIPULATION AS event, ACTION_ORDER AS actionOrder, SQL_MODE AS sqlMode, DEFINER AS definer FROM information_schema.TRIGGERS WHERE TRIGGER_SCHEMA = ${namespace} AND EVENT_OBJECT_TABLE = ${name} AND TRIGGER_NAME = ${collector.add(object.name)}`;
+        break;
+      case "function":
+        text = `SELECT ROUTINE_DEFINITION AS definition, DTD_IDENTIFIER AS result, IS_DETERMINISTIC AS deterministic, SQL_DATA_ACCESS AS dataAccess, SECURITY_TYPE AS securityType, SQL_MODE AS sqlMode, DEFINER AS definer FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ${namespace} AND ROUTINE_NAME = ${name} AND ROUTINE_TYPE = 'FUNCTION'`;
+        break;
+      case "column":
+      case "columnDefault":
+      case "generatedColumn":
+        text = `SELECT COLUMN_TYPE AS type, IS_NULLABLE AS nullable, COLUMN_DEFAULT AS definition, GENERATION_EXPRESSION AS generated, EXTRA AS extra, COLLATION_NAME AS collation FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name} AND COLUMN_NAME = ${collector.add(object.column)}`;
+        break;
+      case "constraint":
+        if (object.constraintType === "exclusion")
+          throw unsupportedCapability13({ 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":
+        text = `SELECT INDEX_NAME AS name, NON_UNIQUE AS nonUnique, INDEX_TYPE AS method, IS_VISIBLE AS visible FROM information_schema.STATISTICS WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name} AND INDEX_NAME = ${collector.add(object.name)} GROUP BY INDEX_NAME, NON_UNIQUE, INDEX_TYPE, IS_VISIBLE`;
+        break;
+      case "table":
+        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 unsupportedCapability13({ dialect: "mysql", feature: `inspect:${object.kind}` });
+    }
+  } else {
+    if (physical.namespace !== "main" && physical.namespace !== "temp")
+      throw unsupportedCapability13({ 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"].includes(object.kind) || object.kind === "constraint" && object.constraintType === "exclusion")
+      throw unsupportedCapability13({ 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)}`;
+      return { text, values: sqliteParams.values, returning: "none" };
+    }
+    const objectName = object.kind === "trigger" || object.kind === "index" ? object.name : physical.name;
+    text = `SELECT sql AS definition, type AS type FROM ${catalog} WHERE name = ${sqliteParams.add(objectName)} AND type = ${sqliteParams.add(kind)}`;
+    return { text, values: sqliteParams.values, returning: "none" };
+  }
+  return { text, values: collector.values, returning: "none" };
+}
+function renderMysqlObjectMembers(params) {
+  if (params.dialect.name !== "mysql")
+    return;
+  const object = params.identity;
+  if (object.kind !== "function" && object.kind !== "index" && object.kind !== "constraint")
+    return;
+  const collector = new ParamCollector(params.dialect);
+  const physical = "table" in object ? object.table : object.name;
+  const namespace = collector.add(physical.namespace);
+  const name = collector.add(physical.name);
+  const text = object.kind === "function" ? `SELECT PARAMETER_MODE AS mode, PARAMETER_NAME AS name, DTD_IDENTIFIER AS type, CHARACTER_SET_NAME AS characterSet, COLLATION_NAME AS collation FROM information_schema.PARAMETERS WHERE SPECIFIC_SCHEMA = ${namespace} AND SPECIFIC_NAME = ${name} ORDER BY ORDINAL_POSITION` : object.kind === "index" ? `SELECT COLUMN_NAME AS name, EXPRESSION AS expression, SUB_PART AS prefixLength, COLLATION AS collation FROM information_schema.STATISTICS WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name} AND INDEX_NAME = ${collector.add(object.name)} ORDER BY SEQ_IN_INDEX` : `SELECT COLUMN_NAME AS name, REFERENCED_TABLE_SCHEMA AS referenceNamespace, REFERENCED_TABLE_NAME AS referenceTable, REFERENCED_COLUMN_NAME AS referenceColumn FROM information_schema.KEY_COLUMN_USAGE WHERE CONSTRAINT_SCHEMA = ${namespace} AND TABLE_NAME = ${name} AND CONSTRAINT_NAME = ${collector.add(object.name)} ORDER BY ORDINAL_POSITION`;
+  return { text, values: collector.values, returning: "none" };
+}
+function renderMigrationDependencies(params) {
+  if (params.dialect.name !== "postgres")
+    throw unsupportedCapability13({ dialect: params.dialect.name, feature: "catalogDependencies" });
+  const object = params.identity;
+  const physical = "table" in object ? object.table : object.name;
+  const collector = new ParamCollector(params.dialect);
+  const namespace = collector.add(physical.namespace);
+  const name = collector.add(physical.name);
+  const relation = `SELECT c.oid FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = ${namespace} AND c.relname = ${name}`;
+  let source;
+  switch (object.kind) {
+    case "constraint":
+      source = `SELECT 'pg_constraint'::regclass AS classid, con.oid AS objid, 0 AS objsubid FROM pg_catalog.pg_constraint con WHERE con.conrelid = (${relation}) AND con.conname = ${collector.add(object.name)}`;
+      break;
+    case "trigger":
+      source = `SELECT 'pg_trigger'::regclass AS classid, t.oid AS objid, 0 AS objsubid FROM pg_catalog.pg_trigger t WHERE t.tgrelid = (${relation}) AND t.tgname = ${collector.add(object.name)}`;
+      break;
+    case "columnDefault":
+    case "generatedColumn":
+      source = `SELECT 'pg_attrdef'::regclass AS classid, d.oid AS objid, 0 AS objsubid FROM pg_catalog.pg_attrdef d JOIN pg_catalog.pg_attribute a ON a.attrelid = d.adrelid AND a.attnum = d.adnum WHERE a.attrelid = (${relation}) AND a.attname = ${collector.add(object.column)}`;
+      break;
+    case "column":
+      source = `SELECT 'pg_class'::regclass AS classid, a.attrelid AS objid, a.attnum AS objsubid FROM pg_catalog.pg_attribute a WHERE a.attrelid = (${relation}) AND a.attname = ${collector.add(object.column)}`;
+      break;
+    case "view":
+      source = `SELECT 'pg_rewrite'::regclass AS classid, r.oid AS objid, 0 AS objsubid FROM pg_catalog.pg_rewrite r WHERE r.ev_class = (${relation})`;
+      break;
+    case "index":
+      source = `SELECT 'pg_class'::regclass AS classid, i.indexrelid AS objid, 0 AS objsubid FROM pg_catalog.pg_index i JOIN pg_catalog.pg_class c ON c.oid = i.indexrelid WHERE i.indrelid = (${relation}) AND c.relname = ${collector.add(object.name)}`;
+      break;
+    case "function":
+      source = `SELECT 'pg_proc'::regclass AS classid, p.oid AS objid, 0 AS objsubid FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = ${namespace} AND p.proname = ${name} AND ARRAY(SELECT tn.nspname || '.' || t.typname FROM unnest(p.proargtypes) WITH ORDINALITY a(oid, ord) JOIN pg_catalog.pg_type t ON t.oid = a.oid JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace ORDER BY a.ord) = ${collector.add(object.argumentTypes.map((type) => `${type.namespace}.${type.name}`))}::text[]`;
+      break;
+    case "postgresExtension":
+      source = `SELECT 'pg_extension'::regclass AS classid, e.oid AS objid, 0 AS objsubid FROM pg_catalog.pg_extension e JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace WHERE n.nspname = ${namespace} AND e.extname = ${name}`;
+      break;
+    default:
+      source = `SELECT 'pg_class'::regclass AS classid, c.oid AS objid, 0 AS objsubid FROM pg_catalog.pg_class c WHERE c.oid = (${relation})`;
+      break;
+  }
+  return { text: `SELECT DISTINCT json_build_array(d.deptype, a.type, a.object_names, a.object_args)::text AS address FROM (${source}) s JOIN pg_catalog.pg_depend d ON d.classid = s.classid AND d.objid = s.objid AND d.objsubid = s.objsubid CROSS JOIN LATERAL pg_catalog.pg_identify_object_as_address(d.refclassid, d.refobjid, d.refobjsubid) a ORDER BY address`, values: collector.values, returning: "none" };
+}
+function renderMigrationServerVersion(params) {
+  return { text: params.dialect.name === "sqlite" ? "SELECT sqlite_version() AS version" : "SELECT version() AS version", values: [], returning: "none" };
+}
+function renderMigrationNamespace(params) {
+  return { text: params.dialect.name === "mysql" ? "SELECT DATABASE() AS namespace" : params.dialect.name === "sqlite" ? "SELECT 'main' AS namespace" : "SELECT 'public' AS namespace", values: [], returning: "none" };
+}
+function renderCheckProbe(params) {
+  if (params.dialect.name !== "postgres")
+    throw unsupportedCapability13({ 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 VibeError4, unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
+import { VibeError as VibeError9, unsupportedCapability as unsupportedCapability14 } 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 unsupportedCapability6({ dialect: params.dialect.name, feature: params.feature });
+    throw unsupportedCapability14({ dialect: params.dialect.name, feature: params.feature });
   }
 }
 function renderMigrationSessionRead(params) {
@@ -1627,7 +2809,7 @@ function renderMigrationSessionSet(params) {
   requirePostgres2({ dialect: params.dialect, feature: "migrationSessionSettings" });
   const { milliseconds, setting } = params;
   if (!Number.isSafeInteger(milliseconds) || milliseconds < 0) {
-    throw new VibeError4({
+    throw new VibeError9({
       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 }
@@ -1714,63 +2896,21 @@ WHERE n.nspname = pg_catalog.current_schema() AND c.relname = ${table} AND a.att
     returning: "none"
   };
 }
-// 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;
-  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;
-}
 export {
   toPgArrayLiteral,
   strictMatchPattern,
   startsWithPattern,
+  sqliteTableConstraints,
   sqliteDialect,
+  sqliteColumnClauses,
+  sqlUsesIncoming,
+  sql,
   renderStatement,
+  renderSqliteRebuildObjects,
+  renderSqliteForeignKeyInventory,
+  renderSqliteColumnInventory,
+  renderSqlFragment,
+  renderRowLockClause,
   renderRlsRole,
   renderRlsReadinessQuery,
   renderRlsProbeTable,
@@ -1785,23 +2925,42 @@ export {
   renderRlsContext,
   renderRlsColumnType,
   renderRelationStateQuery,
+  renderPredicate,
   renderPostgresWorkload,
   renderPostgresExplain,
+  renderMysqlObjectMembers,
+  renderMysqlCheckProbe,
+  renderMigrationVisibility,
   renderMigrationSessionSet,
   renderMigrationSessionRestore,
   renderMigrationSessionRead,
+  renderMigrationServerVersion,
+  renderMigrationObjectQuery,
+  renderMigrationNamespace,
+  renderMigrationInventory,
+  renderMigrationHistoryQuery,
+  renderMigrationDependencies,
   renderIndexStateQuery,
   renderFragment,
   renderExpr,
+  renderExclusionSetup,
+  renderExclusionProbe,
+  renderExclusionDdl,
+  renderExclusionCatalog,
   renderDiagnostic,
   renderConstraintStateQuery,
+  renderConstraintOwnedIndexDrop,
   renderColumnStateQuery,
+  renderCheckProbe,
+  renderAdvisoryLock,
   projectionOutputName,
   postgresDialect,
   parsePgArrayLiteral,
   parseDateTimeText,
   mysqlDialect,
+  mapConflictColumns,
   jsonParamCell,
+  isSqlFragment,
   isSqlDefaultCell,
   isSetOperation,
   isListSetOperation,
@@ -1815,9 +2974,13 @@ export {
   escapeGlobPattern,
   enumMembershipCodec,
   endsWithPattern,
+  describeRowLock,
   decodeIsNoop,
+  decode,
   dbNowMarker,
   containsPattern,
+  compileSql,
+  compileExclusion,
   SQL_DIALECTS,
   SQL_DEFAULT_CELL,
   SQLITE_CODECS,
@@ -1834,7 +2997,9 @@ export {
   MYSQL_CAPABILITIES,
   JSON_TRANSPORT,
   DIALECT_CODECS,
-  DIALECT_CAPABILITIES
+  DIALECT_CAPABILITIES,
+  ADVISORY_LOCK_RESULT_COLUMN,
+  ADVISORY_KEY_BOUNDS
 };
 
-//# debugId=2783254C4B92111564756E2164756E21
+//# debugId=F9D013AFDDCCA77864756E2164756E21