@minnowdb/core 0.6.9 → 0.7.1

package/dist/engine/sql-domains.js

@@ -1,8 +1,7 @@
 import { assertWellFormedString } from "../block-format/unicode.js";
 import { dateIsoString } from "../date-value.js";
-import { MAX_SQL_SCALAR_RESULT_CHARACTERS, MAX_SQL_NUMERIC_DIGITS, MAX_SQL_STRUCTURED_VALUE_DEPTH, MAX_SQL_STRUCTURED_VALUE_ITEMS, } from "./cache-limits.js";
-/** Internal string encodings for PostgreSQL value domains carried by string vectors. */
-const PREFIX = "\u0000minnow-domain:";
+import { MAX_SQL_SCALAR_RESULT_CHARACTERS, MAX_SQL_NUMERIC_DIGITS, MAX_SQL_STRUCTURED_VALUE_DEPTH, MAX_SQL_STRUCTURED_VALUE_ITEMS } from "./cache-limits.js";
+const PREFIX = "\0minnow-domain:";
 const TEXT_VALUE = `${PREFIX}text:`;
 const NUMERIC = `${PREFIX}numeric:`;
 const JSON_VALUE = `${PREFIX}json:`;
@@ -14,773 +13,688 @@ const INTERVAL_VALUE = `${PREFIX}interval:`;
 const ARRAY_VALUE = `${PREFIX}array:`;
 const COLLATION_VALUE = `${PREFIX}collation:`;
 const ENUM_VALUE = `${PREFIX}enum:`;
-/**
- * Protects an ordinary SQL string that happens to use the internal domain namespace. Physical
- * TEXT remains unchanged on disk; this wrapper is applied at execution boundaries so a user
- * value can never be mistaken for NUMERIC, INTERVAL, enum, or another tagged logical value.
- */
-export function protectedSqlTextValue(value) {
-    return value.startsWith(PREFIX) ? TEXT_VALUE + value : value;
-}
-/** Removes only the ordinary-TEXT wrapper, leaving real domain values tagged. */
-export function externalSqlTextValue(value) {
-    return typeof value === "string" && value.startsWith(TEXT_VALUE)
-        ? value.slice(TEXT_VALUE.length)
-        : value;
+function protectedSqlTextValue(value) {
+  return value.startsWith(PREFIX) ? TEXT_VALUE + value : value;
+}
+function externalSqlTextValue(value) {
+  return typeof value === "string" && value.startsWith(TEXT_VALUE) ? value.slice(TEXT_VALUE.length) : value;
 }
 function pow10(exponent) {
-    if (!Number.isSafeInteger(exponent) || exponent < 0 || exponent > 100_000) {
-        throw new RangeError(`Decimal scale is outside the supported range: ${String(exponent)}`);
-    }
-    // Retaining every intermediate power up to 100,000 consumes quadratic memory in the number
-    // of decimal digits. Native exponentiation constructs only the requested result.
-    return 10n ** BigInt(exponent);
+  if (!Number.isSafeInteger(exponent) || exponent < 0 || exponent > 1e5) {
+    throw new RangeError(`Decimal scale is outside the supported range: ${String(exponent)}`);
+  }
+  return 10n ** BigInt(exponent);
 }
 function decimalParts(value) {
-    const source = String(value).trim();
-    assertBoundedDomainString(source, "NUMERIC value");
-    const match = /^([+-]?)(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:[eE]([+-]?\d+))?$/.exec(source);
-    if (match === null)
-        throw new TypeError(`Invalid NUMERIC value: ${String(value)}`);
-    const fraction = match[3] ?? match[4] ?? "";
-    const digits = `${match[2] ?? "0"}${fraction}`.replace(/^0+(?=\d)/, "");
-    if (digits.length > MAX_SQL_NUMERIC_DIGITS) {
-        throw new RangeError(`NUMERIC value exceeds ${String(MAX_SQL_NUMERIC_DIGITS)} significant digits`);
-    }
-    const exponent = Number(match[5] ?? 0);
-    if (!Number.isSafeInteger(exponent))
-        throw new RangeError(`Invalid NUMERIC exponent: ${source}`);
-    let coefficient = BigInt(digits || "0") * (match[1] === "-" ? -1n : 1n);
-    let scale = fraction.length - exponent;
-    if (scale < 0) {
-        if (-scale > 100_000) {
-            throw new RangeError(`NUMERIC exponent is outside the supported range: ${source}`);
-        }
-        coefficient *= pow10(-scale);
-        scale = 0;
-    }
-    return { coefficient, scale };
+  const source = String(value).trim();
+  assertBoundedDomainString(source, "NUMERIC value");
+  const match = /^([+-]?)(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:[eE]([+-]?\d+))?$/.exec(source);
+  if (match === null)
+    throw new TypeError(`Invalid NUMERIC value: ${String(value)}`);
+  const fraction = match[3] ?? match[4] ?? "";
+  const digits = `${match[2] ?? "0"}${fraction}`.replace(/^0+(?=\d)/, "");
+  if (digits.length > MAX_SQL_NUMERIC_DIGITS) {
+    throw new RangeError(`NUMERIC value exceeds ${String(MAX_SQL_NUMERIC_DIGITS)} significant digits`);
+  }
+  const exponent = Number(match[5] ?? 0);
+  if (!Number.isSafeInteger(exponent))
+    throw new RangeError(`Invalid NUMERIC exponent: ${source}`);
+  let coefficient = BigInt(digits || "0") * (match[1] === "-" ? -1n : 1n);
+  let scale = fraction.length - exponent;
+  if (scale < 0) {
+    if (-scale > 1e5) {
+      throw new RangeError(`NUMERIC exponent is outside the supported range: ${source}`);
+    }
+    coefficient *= pow10(-scale);
+    scale = 0;
+  }
+  return { coefficient, scale };
 }
 function normalizeDecimal(parts) {
-    let { coefficient, scale } = parts;
-    while (scale > 0 && coefficient % 10n === 0n) {
-        coefficient /= 10n;
-        scale -= 1;
-    }
-    return { coefficient, scale };
+  let { coefficient, scale } = parts;
+  while (scale > 0 && coefficient % 10n === 0n) {
+    coefficient /= 10n;
+    scale -= 1;
+  }
+  return { coefficient, scale };
 }
 function rescaleDecimal(parts, scale) {
-    if (!Number.isSafeInteger(scale) || scale < 0 || scale > 100_000) {
-        throw new RangeError(`NUMERIC scale is outside the supported range: ${String(scale)}`);
-    }
-    if (parts.scale <= scale) {
-        return { coefficient: parts.coefficient * pow10(scale - parts.scale), scale };
-    }
-    const divisor = pow10(parts.scale - scale);
-    let quotient = parts.coefficient / divisor;
-    const remainder = parts.coefficient % divisor;
-    if ((remainder < 0n ? -remainder : remainder) * 2n >= divisor) {
-        quotient += parts.coefficient < 0n ? -1n : 1n;
-    }
-    return { coefficient: quotient, scale };
+  if (!Number.isSafeInteger(scale) || scale < 0 || scale > 1e5) {
+    throw new RangeError(`NUMERIC scale is outside the supported range: ${String(scale)}`);
+  }
+  if (parts.scale <= scale) {
+    return { coefficient: parts.coefficient * pow10(scale - parts.scale), scale };
+  }
+  const divisor = pow10(parts.scale - scale);
+  let quotient = parts.coefficient / divisor;
+  const remainder = parts.coefficient % divisor;
+  if ((remainder < 0n ? -remainder : remainder) * 2n >= divisor) {
+    quotient += parts.coefficient < 0n ? -1n : 1n;
+  }
+  return { coefficient: quotient, scale };
 }
 function formatDecimal(parts) {
-    const negative = parts.coefficient < 0n;
-    const digits = (negative ? -parts.coefficient : parts.coefficient).toString();
-    if (parts.scale === 0)
-        return `${negative ? "-" : ""}${digits}`;
-    const padded = digits.padStart(parts.scale + 1, "0");
-    const split = padded.length - parts.scale;
-    return `${negative ? "-" : ""}${padded.slice(0, split)}.${padded.slice(split)}`;
+  const negative = parts.coefficient < 0n;
+  const digits = (negative ? -parts.coefficient : parts.coefficient).toString();
+  if (parts.scale === 0)
+    return `${negative ? "-" : ""}${digits}`;
+  const padded = digits.padStart(parts.scale + 1, "0");
+  const split = padded.length - parts.scale;
+  return `${negative ? "-" : ""}${padded.slice(0, split)}.${padded.slice(split)}`;
 }
 function taggedDecimalParts(value) {
-    if (typeof value !== "string" || !value.startsWith(NUMERIC))
-        return undefined;
-    return decimalParts(value.slice(NUMERIC.length));
-}
-export function isExactNumeric(value) {
-    return taggedDecimalParts(value) !== undefined;
-}
-export function exactNumericValue(value, precision, scale) {
-    if (value === null || value === undefined)
-        return null;
-    const raw = taggedDecimalParts(value) ??
-        (typeof value === "number" || typeof value === "string" ? decimalParts(value) : undefined);
-    if (raw === undefined)
-        throw new TypeError("NUMERIC accepts a number or decimal string");
-    const adjusted = scale === undefined ? normalizeDecimal(raw) : rescaleDecimal(raw, scale);
-    if (precision !== undefined) {
-        if (!Number.isSafeInteger(precision) || precision < 1 || precision > 100_000) {
-            throw new RangeError(`NUMERIC precision is outside the supported range: ${String(precision)}`);
-        }
-        const declaredScale = scale ?? 0;
-        if (declaredScale > precision) {
-            throw new TypeError("NUMERIC scale cannot exceed its precision");
-        }
-        const integer = adjusted.coefficient < 0n ? -adjusted.coefficient : adjusted.coefficient;
-        const integerDigits = (integer / pow10(adjusted.scale)).toString().length;
-        if (integer !== 0n && integerDigits > precision - declaredScale) {
-            throw new RangeError(`NUMERIC(${String(precision)}, ${String(declaredScale)}) overflow`);
-        }
-    }
-    return boundedTaggedDomainValue(NUMERIC, formatDecimal(normalizeDecimal(adjusted)), "NUMERIC value");
-}
-/**
- * Tags a SQL numeric constant with its exact digits, as written. Unlike `exactNumericValue`
- * this does not canonicalize: trailing fractional zeros are PostgreSQL display scale, and
- * division selects its result scale from the operands' scales, so a literal's digits are part
- * of its meaning. Scientific notation is the exception — PostgreSQL expands the exponent when
- * it parses the literal, so `1.5e2` is `150` and `1e400` is the full digit string, and the
- * display scale comes from that expansion. The text is still validated and bounded.
- */
-export function exactNumericLiteral(text) {
-    const parts = decimalParts(text);
-    const plain = /[eE]/.test(text) ? formatDecimal(parts) : text;
-    return boundedTaggedDomainValue(NUMERIC, plain, "NUMERIC literal");
-}
-/**
- * The Float64 this exact numeric value reads back identically from — the nearest float's
- * canonical rendering re-parses to the same decimal value, so `0.1` qualifies while
- * `9007199254740993` does not — or undefined when the trip through a number would visibly
- * round. A value that survives stays an ordinary number so every number-typed path keeps
- * running; only visibly rounded values stay tagged NUMERIC.
- */
-export function exactNumericAsNumber(value) {
-    const parts = taggedDecimalParts(value);
-    if (parts === undefined)
-        return undefined;
-    const candidate = Number(value.slice(NUMERIC.length));
-    if (!Number.isFinite(candidate))
-        return undefined;
-    const roundTrip = normalizeDecimal(decimalParts(String(candidate)));
-    const exact = normalizeDecimal(parts);
-    return roundTrip.coefficient === exact.coefficient && roundTrip.scale === exact.scale
-        ? candidate
-        : undefined;
-}
-/**
- * The leading base-10000 digit of a decimal, aligned at the decimal point the way PostgreSQL's
- * NUMERIC digit array is: group k covers the decimal digits at 10^(4k)..10^(4k+3). `weight` is
- * the group index of the first nonzero group and `firstDigit` its value (1..9999); zero reports
- * both as 0, matching PostgreSQL's defaults when no nonzero digit exists.
- */
+  if (typeof value !== "string" || !value.startsWith(NUMERIC))
+    return void 0;
+  return decimalParts(value.slice(NUMERIC.length));
+}
+function isExactNumeric(value) {
+  return taggedDecimalParts(value) !== void 0;
+}
+function exactNumericValue(value, precision, scale) {
+  if (value === null || value === void 0)
+    return null;
+  const raw = taggedDecimalParts(value) ?? (typeof value === "number" || typeof value === "string" ? decimalParts(value) : void 0);
+  if (raw === void 0)
+    throw new TypeError("NUMERIC accepts a number or decimal string");
+  const adjusted = scale === void 0 ? normalizeDecimal(raw) : rescaleDecimal(raw, scale);
+  if (precision !== void 0) {
+    if (!Number.isSafeInteger(precision) || precision < 1 || precision > 1e5) {
+      throw new RangeError(`NUMERIC precision is outside the supported range: ${String(precision)}`);
+    }
+    const declaredScale = scale ?? 0;
+    if (declaredScale > precision) {
+      throw new TypeError("NUMERIC scale cannot exceed its precision");
+    }
+    const integer = adjusted.coefficient < 0n ? -adjusted.coefficient : adjusted.coefficient;
+    const integerDigits = (integer / pow10(adjusted.scale)).toString().length;
+    if (integer !== 0n && integerDigits > precision - declaredScale) {
+      throw new RangeError(`NUMERIC(${String(precision)}, ${String(declaredScale)}) overflow`);
+    }
+  }
+  return boundedTaggedDomainValue(NUMERIC, formatDecimal(normalizeDecimal(adjusted)), "NUMERIC value");
+}
+function exactNumericLiteral(text) {
+  const parts = decimalParts(text);
+  const plain = /[eE]/.test(text) ? formatDecimal(parts) : text;
+  return boundedTaggedDomainValue(NUMERIC, plain, "NUMERIC literal");
+}
+function exactNumericAsNumber(value) {
+  const parts = taggedDecimalParts(value);
+  if (parts === void 0)
+    return void 0;
+  const candidate = Number(value.slice(NUMERIC.length));
+  if (!Number.isFinite(candidate))
+    return void 0;
+  const roundTrip = normalizeDecimal(decimalParts(String(candidate)));
+  const exact = normalizeDecimal(parts);
+  return roundTrip.coefficient === exact.coefficient && roundTrip.scale === exact.scale ? candidate : void 0;
+}
 function nbaseLeading(parts) {
-    const magnitude = parts.coefficient < 0n ? -parts.coefficient : parts.coefficient;
-    if (magnitude === 0n)
-        return { weight: 0, firstDigit: 0 };
-    const fractionGroups = Math.ceil(parts.scale / 4);
-    const aligned = magnitude * pow10(fractionGroups * 4 - parts.scale);
-    const groups = Math.ceil(aligned.toString().length / 4);
-    return {
-        weight: groups - 1 - fractionGroups,
-        firstDigit: Number(aligned / pow10((groups - 1) * 4)),
-    };
+  const magnitude = parts.coefficient < 0n ? -parts.coefficient : parts.coefficient;
+  if (magnitude === 0n)
+    return { weight: 0, firstDigit: 0 };
+  const fractionGroups = Math.ceil(parts.scale / 4);
+  const aligned = magnitude * pow10(fractionGroups * 4 - parts.scale);
+  const groups = Math.ceil(aligned.toString().length / 4);
+  return {
+    weight: groups - 1 - fractionGroups,
+    firstDigit: Number(aligned / pow10((groups - 1) * 4))
+  };
 }
-/**
- * PostgreSQL's `select_div_scale`: the fractional digits a NUMERIC quotient is computed and
- * rounded to. The estimated quotient weight guarantees roughly sixteen significant digits, and
- * the result never displays fewer fractional digits than either operand. `minimumScale` stands
- * in for display scale the canonical encoding cannot carry: PostgreSQL floors this selection at
- * each operand's dscale, which for an AVG over a declared-scale column is that declared scale.
- */
 function quotientScale(a, b, minimumScale) {
-    const leftLeading = nbaseLeading(a);
-    const rightLeading = nbaseLeading(b);
-    let estimatedWeight = leftLeading.weight - rightLeading.weight;
-    if (leftLeading.firstDigit <= rightLeading.firstDigit)
-        estimatedWeight -= 1;
-    const scale = Math.max(16 - estimatedWeight * 4, a.scale, b.scale, minimumScale, 0);
-    return Math.min(scale, 1000);
-}
-export function exactNumericBinary(operator, left, right, minimumQuotientScale = 0, 
-// Stored and returned values are canonical (trailing fractional zeros stripped). Constant
-// folding keeps the computed scale instead: PostgreSQL carries display scale through each
-// step — max for +, -, %, the operands' sum for *, the selected scale for / — and a later
-// division selects its own scale from it, so folding must not strip what execution never sees.
-canonicalize = true) {
-    const leftTagged = taggedDecimalParts(left);
-    const rightTagged = taggedDecimalParts(right);
-    if (leftTagged === undefined && rightTagged === undefined)
-        return undefined;
-    const a = leftTagged ?? decimalParts(typeof left === "number" ? left : String(left));
-    const b = rightTagged ?? decimalParts(typeof right === "number" ? right : String(right));
-    if ((operator === "/" || operator === "%") && b.coefficient === 0n)
-        return null;
-    let result;
-    if (operator === "+" || operator === "-") {
-        const scale = Math.max(a.scale, b.scale);
-        const ac = a.coefficient * pow10(scale - a.scale);
-        const bc = b.coefficient * pow10(scale - b.scale);
-        result = { coefficient: operator === "+" ? ac + bc : ac - bc, scale };
-    }
-    else if (operator === "*") {
-        result = { coefficient: a.coefficient * b.coefficient, scale: a.scale + b.scale };
-    }
-    else if (operator === "%") {
-        const scale = Math.max(a.scale, b.scale);
-        result = {
-            coefficient: (a.coefficient * pow10(scale - a.scale)) % (b.coefficient * pow10(scale - b.scale)),
-            scale,
-        };
-    }
-    else {
-        // PostgreSQL NUMERIC division computes to its selected result scale and rounds the final
-        // digit half away from zero; matching the scale selection keeps every rendered digit in
-        // agreement, deterministically and without ever crossing binary Float64.
-        const scale = quotientScale(a, b, minimumQuotientScale);
-        const numerator = a.coefficient * pow10(scale + b.scale);
-        const denominator = b.coefficient * pow10(a.scale);
-        let coefficient = numerator / denominator;
-        const remainder = numerator % denominator;
-        const magnitude = denominator < 0n ? -denominator : denominator;
-        if ((remainder < 0n ? -remainder : remainder) * 2n >= magnitude) {
-            coefficient += numerator < 0n !== denominator < 0n ? -1n : 1n;
-        }
-        result = { coefficient, scale };
-    }
-    return boundedTaggedDomainValue(NUMERIC, formatDecimal(canonicalize ? normalizeDecimal(result) : result), "NUMERIC result");
-}
-export function exactNumericCompare(left, right) {
-    const leftTagged = taggedDecimalParts(left);
-    const rightTagged = taggedDecimalParts(right);
-    if (leftTagged === undefined && rightTagged === undefined)
-        return undefined;
-    const a = leftTagged ??
-        (typeof left === "number" || typeof left === "string" ? decimalParts(left) : undefined);
-    const b = rightTagged ??
-        (typeof right === "number" || typeof right === "string" ? decimalParts(right) : undefined);
-    if (a === undefined || b === undefined)
-        return undefined;
+  const leftLeading = nbaseLeading(a);
+  const rightLeading = nbaseLeading(b);
+  let estimatedWeight = leftLeading.weight - rightLeading.weight;
+  if (leftLeading.firstDigit <= rightLeading.firstDigit)
+    estimatedWeight -= 1;
+  const scale = Math.max(16 - estimatedWeight * 4, a.scale, b.scale, minimumScale, 0);
+  return Math.min(scale, 1e3);
+}
+function exactNumericBinary(operator, left, right, minimumQuotientScale = 0, canonicalize = true) {
+  const leftTagged = taggedDecimalParts(left);
+  const rightTagged = taggedDecimalParts(right);
+  if (leftTagged === void 0 && rightTagged === void 0)
+    return void 0;
+  const a = leftTagged ?? decimalParts(typeof left === "number" ? left : String(left));
+  const b = rightTagged ?? decimalParts(typeof right === "number" ? right : String(right));
+  if ((operator === "/" || operator === "%") && b.coefficient === 0n)
+    return null;
+  let result;
+  if (operator === "+" || operator === "-") {
     const scale = Math.max(a.scale, b.scale);
     const ac = a.coefficient * pow10(scale - a.scale);
     const bc = b.coefficient * pow10(scale - b.scale);
-    return ac === bc ? 0 : ac < bc ? -1 : 1;
-}
-/**
- * Serializes a JSON value while bounding traversal, nesting, and output before concatenation.
- * Canonical mode sorts object names directly in the wire text (including integer-looking names,
- * which JavaScript object enumeration would otherwise silently reorder).
- */
-export function boundedJsonText(value, canonical, label = "JSON value") {
-    const state = { active: new Set(), pieces: [], items: 0, length: 0 };
-    encodeBoundedJson(value, canonical, label, 0, state);
-    return state.pieces.join("");
+    result = { coefficient: operator === "+" ? ac + bc : ac - bc, scale };
+  } else if (operator === "*") {
+    result = { coefficient: a.coefficient * b.coefficient, scale: a.scale + b.scale };
+  } else if (operator === "%") {
+    const scale = Math.max(a.scale, b.scale);
+    result = {
+      coefficient: a.coefficient * pow10(scale - a.scale) % (b.coefficient * pow10(scale - b.scale)),
+      scale
+    };
+  } else {
+    const scale = quotientScale(a, b, minimumQuotientScale);
+    const numerator = a.coefficient * pow10(scale + b.scale);
+    const denominator = b.coefficient * pow10(a.scale);
+    let coefficient = numerator / denominator;
+    const remainder = numerator % denominator;
+    const magnitude = denominator < 0n ? -denominator : denominator;
+    if ((remainder < 0n ? -remainder : remainder) * 2n >= magnitude) {
+      coefficient += numerator < 0n !== denominator < 0n ? -1n : 1n;
+    }
+    result = { coefficient, scale };
+  }
+  return boundedTaggedDomainValue(NUMERIC, formatDecimal(canonicalize ? normalizeDecimal(result) : result), "NUMERIC result");
+}
+function exactNumericCompare(left, right) {
+  const leftTagged = taggedDecimalParts(left);
+  const rightTagged = taggedDecimalParts(right);
+  if (leftTagged === void 0 && rightTagged === void 0)
+    return void 0;
+  const a = leftTagged ?? (typeof left === "number" || typeof left === "string" ? decimalParts(left) : void 0);
+  const b = rightTagged ?? (typeof right === "number" || typeof right === "string" ? decimalParts(right) : void 0);
+  if (a === void 0 || b === void 0)
+    return void 0;
+  const scale = Math.max(a.scale, b.scale);
+  const ac = a.coefficient * pow10(scale - a.scale);
+  const bc = b.coefficient * pow10(scale - b.scale);
+  return ac === bc ? 0 : ac < bc ? -1 : 1;
+}
+function boundedJsonText(value, canonical, label = "JSON value") {
+  const state = { active: /* @__PURE__ */ new Set(), pieces: [], items: 0, length: 0 };
+  encodeBoundedJson(value, canonical, label, 0, state);
+  return state.pieces.join("");
 }
 function encodeBoundedJson(value, canonical, label, depth, state) {
-    state.items += 1;
-    if (state.items > MAX_SQL_STRUCTURED_VALUE_ITEMS) {
+  state.items += 1;
+  if (state.items > MAX_SQL_STRUCTURED_VALUE_ITEMS) {
+    throw new RangeError(`${label} cannot exceed ${String(MAX_SQL_STRUCTURED_VALUE_ITEMS)} values and names`);
+  }
+  if (depth > MAX_SQL_STRUCTURED_VALUE_DEPTH) {
+    throw new RangeError(`${label} cannot exceed ${String(MAX_SQL_STRUCTURED_VALUE_DEPTH)} levels`);
+  }
+  if (value === null) {
+    appendJsonPiece(state, "null", label);
+    return;
+  }
+  if (typeof value === "boolean") {
+    appendJsonPiece(state, value ? "true" : "false", label);
+    return;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new TypeError("JSON numbers must be finite");
+    appendJsonPiece(state, JSON.stringify(value), label);
+    return;
+  }
+  if (typeof value === "string") {
+    assertBoundedDomainString(value, label);
+    appendJsonPiece(state, JSON.stringify(value), label);
+    return;
+  }
+  if (value instanceof Date) {
+    const timestamp = dateIsoString(value);
+    appendJsonPiece(state, JSON.stringify(timestamp), label);
+    return;
+  }
+  if (typeof value !== "object")
+    throw new TypeError(`${label} cannot be represented as JSON`);
+  const object = value;
+  if (state.active.has(object))
+    throw new TypeError(`${label} cannot contain a cycle`);
+  state.active.add(object);
+  try {
+    if (Array.isArray(value)) {
+      appendJsonPiece(state, "[", label);
+      for (let index = 0; index < value.length; index += 1) {
+        if (index > 0)
+          appendJsonPiece(state, ",", label);
+        encodeBoundedJson(value[index], canonical, label, depth + 1, state);
+      }
+      appendJsonPiece(state, "]", label);
+      return;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError(`${label} accepts only JSON objects, arrays, and scalar values`);
+    }
+    const record = value;
+    const keys = [];
+    for (const key in record) {
+      if (!Object.hasOwn(record, key))
+        continue;
+      if (keys.length >= MAX_SQL_STRUCTURED_VALUE_ITEMS - state.items) {
         throw new RangeError(`${label} cannot exceed ${String(MAX_SQL_STRUCTURED_VALUE_ITEMS)} values and names`);
-    }
-    if (depth > MAX_SQL_STRUCTURED_VALUE_DEPTH) {
-        throw new RangeError(`${label} cannot exceed ${String(MAX_SQL_STRUCTURED_VALUE_DEPTH)} levels`);
-    }
-    if (value === null) {
-        appendJsonPiece(state, "null", label);
-        return;
-    }
-    if (typeof value === "boolean") {
-        appendJsonPiece(state, value ? "true" : "false", label);
-        return;
-    }
-    if (typeof value === "number") {
-        if (!Number.isFinite(value))
-            throw new TypeError("JSON numbers must be finite");
-        appendJsonPiece(state, JSON.stringify(value), label);
-        return;
-    }
-    if (typeof value === "string") {
-        assertBoundedDomainString(value, label);
-        appendJsonPiece(state, JSON.stringify(value), label);
-        return;
-    }
-    if (value instanceof Date) {
-        const timestamp = dateIsoString(value);
-        appendJsonPiece(state, JSON.stringify(timestamp), label);
-        return;
-    }
-    if (typeof value !== "object")
-        throw new TypeError(`${label} cannot be represented as JSON`);
-    const object = value;
-    if (state.active.has(object))
-        throw new TypeError(`${label} cannot contain a cycle`);
-    state.active.add(object);
-    try {
-        if (Array.isArray(value)) {
-            appendJsonPiece(state, "[", label);
-            for (let index = 0; index < value.length; index += 1) {
-                if (index > 0)
-                    appendJsonPiece(state, ",", label);
-                encodeBoundedJson(value[index], canonical, label, depth + 1, state);
-            }
-            appendJsonPiece(state, "]", label);
-            return;
-        }
-        const prototype = Object.getPrototypeOf(value);
-        if (prototype !== Object.prototype && prototype !== null) {
-            throw new TypeError(`${label} accepts only JSON objects, arrays, and scalar values`);
-        }
-        const record = value;
-        // Object.keys() would allocate one array slot per property before the item cap can fire.
-        // Plain JSON objects need no prototype walk, so collect at most the admitted count instead.
-        const keys = [];
-        for (const key in record) {
-            if (!Object.hasOwn(record, key))
-                continue;
-            if (keys.length >= MAX_SQL_STRUCTURED_VALUE_ITEMS - state.items) {
-                throw new RangeError(`${label} cannot exceed ${String(MAX_SQL_STRUCTURED_VALUE_ITEMS)} values and names`);
-            }
-            keys.push(key);
-        }
-        if (canonical)
-            keys.sort();
-        appendJsonPiece(state, "{", label);
-        for (let index = 0; index < keys.length; index += 1) {
-            const key = keys[index] ?? "";
-            state.items += 1;
-            if (state.items > MAX_SQL_STRUCTURED_VALUE_ITEMS) {
-                throw new RangeError(`${label} cannot exceed ${String(MAX_SQL_STRUCTURED_VALUE_ITEMS)} values and names`);
-            }
-            assertBoundedDomainString(key, `${label} object name`);
-            if (index > 0)
-                appendJsonPiece(state, ",", label);
-            appendJsonPiece(state, JSON.stringify(key), label);
-            appendJsonPiece(state, ":", label);
-            encodeBoundedJson(record[key], canonical, label, depth + 1, state);
-        }
-        appendJsonPiece(state, "}", label);
-    }
-    finally {
-        state.active.delete(object);
-    }
+      }
+      keys.push(key);
+    }
+    if (canonical)
+      keys.sort();
+    appendJsonPiece(state, "{", label);
+    for (let index = 0; index < keys.length; index += 1) {
+      const key = keys[index] ?? "";
+      state.items += 1;
+      if (state.items > MAX_SQL_STRUCTURED_VALUE_ITEMS) {
+        throw new RangeError(`${label} cannot exceed ${String(MAX_SQL_STRUCTURED_VALUE_ITEMS)} values and names`);
+      }
+      assertBoundedDomainString(key, `${label} object name`);
+      if (index > 0)
+        appendJsonPiece(state, ",", label);
+      appendJsonPiece(state, JSON.stringify(key), label);
+      appendJsonPiece(state, ":", label);
+      encodeBoundedJson(record[key], canonical, label, depth + 1, state);
+    }
+    appendJsonPiece(state, "}", label);
+  } finally {
+    state.active.delete(object);
+  }
 }
 function appendJsonPiece(state, piece, label) {
-    const next = state.length + piece.length;
-    if (!Number.isSafeInteger(next) || next > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
-        throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
-    }
-    state.length = next;
-    state.pieces.push(piece);
+  const next = state.length + piece.length;
+  if (!Number.isSafeInteger(next) || next > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+    throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+  }
+  state.length = next;
+  state.pieces.push(piece);
 }
 function assertBoundedDomainString(value, label) {
-    if (value.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
-        throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
-    }
-    assertWellFormedString(value, label);
-}
-export function jsonDomainValue(value, binary) {
-    if (value === null || value === undefined)
-        return null;
-    let parsed = value;
-    if (typeof value === "string") {
-        const prefix = value.startsWith(JSONB_VALUE)
-            ? JSONB_VALUE
-            : value.startsWith(JSON_VALUE)
-                ? JSON_VALUE
-                : undefined;
-        const source = prefix === undefined ? value : value.slice(prefix.length);
-        assertBoundedDomainString(source, "JSON value");
-        try {
-            parsed = JSON.parse(source);
-        }
-        catch {
-            throw new TypeError("Invalid JSON value");
-        }
-    }
-    const text = boundedJsonText(parsed, binary, binary ? "JSONB value" : "JSON value");
-    return boundedTaggedDomainValue(binary ? JSONB_VALUE : JSON_VALUE, text, binary ? "JSONB value" : "JSON value");
-}
-/** Returns the JSON document carried by an internal JSON/JSONB scalar, if any. */
-export function jsonDomainDocument(value) {
-    if (typeof value !== "string")
-        return undefined;
-    if (value.startsWith(JSONB_VALUE))
-        return value.slice(JSONB_VALUE.length);
-    if (value.startsWith(JSON_VALUE))
-        return value.slice(JSON_VALUE.length);
-    return undefined;
-}
-/**
- * Tags already-constructed JSON without parsing and re-stringifying it. The validation parse
- * rejects malformed documents, while retaining duplicate object names and the constructor's
- * exact member order for embedding in an outer JSON value.
- */
-export function preservedJsonDomainValue(document, binary = false) {
-    assertBoundedDomainString(document, binary ? "JSONB value" : "JSON value");
+  if (value.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+    throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+  }
+  assertWellFormedString(value, label);
+}
+function jsonDomainValue(value, binary) {
+  if (value === null || value === void 0)
+    return null;
+  let parsed = value;
+  if (typeof value === "string") {
+    const prefix = value.startsWith(JSONB_VALUE) ? JSONB_VALUE : value.startsWith(JSON_VALUE) ? JSON_VALUE : void 0;
+    const source = prefix === void 0 ? value : value.slice(prefix.length);
+    assertBoundedDomainString(source, "JSON value");
     try {
-        JSON.parse(document);
-    }
-    catch {
-        throw new TypeError("Invalid JSON value");
-    }
-    return boundedTaggedDomainValue(binary ? JSONB_VALUE : JSON_VALUE, document, binary ? "JSONB value" : "JSON value");
-}
-export function uuidDomainValue(value) {
-    if (value === null || value === undefined)
-        return null;
-    if (typeof value !== "string")
-        throw new TypeError("UUID accepts a string value");
-    assertBoundedDomainString(value, "UUID value");
-    const source = (value.startsWith(UUID_VALUE) ? value.slice(UUID_VALUE.length) : value).toLowerCase();
-    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(source)) {
-        throw new TypeError(`Invalid UUID value: ${value}`);
-    }
-    return UUID_VALUE + source;
-}
-/** Canonical, zoneless SQL DATE value. No JavaScript time zone participates in validation. */
-export function dateDomainValue(value) {
-    if (value === null || value === undefined)
-        return null;
-    let source;
-    if (value instanceof Date) {
-        if (!Number.isFinite(value.getTime()))
-            throw new TypeError("DATE accepts a valid Date value");
-        source = dateIsoString(value).slice(0, 10);
-    }
-    else if (typeof value === "string") {
-        assertBoundedDomainString(value, "DATE value");
-        source = value.startsWith(DATE_VALUE) ? value.slice(DATE_VALUE.length) : value;
-    }
-    else {
-        throw new TypeError("DATE accepts a YYYY-MM-DD string value");
-    }
-    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(source);
-    const year = Number(match?.[1]);
-    const month = Number(match?.[2]);
-    const day = Number(match?.[3]);
-    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-    const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-    if (match === null ||
-        year < 1 ||
-        month < 1 ||
-        month > 12 ||
-        day < 1 ||
-        day > (days[month - 1] ?? 0)) {
-        throw new TypeError(`Invalid DATE value: ${String(value)}`);
-    }
-    return DATE_VALUE + source;
-}
-export function isDateDomainValue(value) {
-    return typeof value === "string" && value.startsWith(DATE_VALUE);
-}
-export function timeDomainValue(value) {
-    if (value === null || value === undefined)
-        return null;
-    if (typeof value !== "string")
-        throw new TypeError("TIME accepts a string value");
-    assertBoundedDomainString(value, "TIME value");
-    const source = value.startsWith(TIME_VALUE) ? value.slice(TIME_VALUE.length) : value;
-    const match = /^(\d{2}):(\d{2})(?::(\d{2})(\.\d{1,6})?)?$/.exec(source);
-    const hours = match?.[1];
-    const minutes = match?.[2];
-    if (match === null ||
-        hours === undefined ||
-        minutes === undefined ||
-        Number(hours) > 23 ||
-        Number(minutes) > 59 ||
-        Number(match[3] ?? 0) > 59) {
-        throw new TypeError(`Invalid TIME value: ${value}`);
-    }
-    return TIME_VALUE + `${hours}:${minutes}:${match[3] ?? "00"}${match[4] ?? ""}`;
-}
-export function intervalDomainValue(value) {
-    if (value === null || value === undefined)
-        return null;
-    if (typeof value !== "string")
-        throw new TypeError("INTERVAL accepts a string value");
-    assertBoundedDomainString(value, "INTERVAL value");
-    if (value.startsWith(INTERVAL_VALUE)) {
-        const source = value.slice(INTERVAL_VALUE.length);
-        let decoded;
-        try {
-            decoded = JSON.parse(source);
-        }
-        catch {
-            throw new TypeError("Invalid tagged INTERVAL value");
-        }
-        if (!Array.isArray(decoded) ||
-            decoded.length !== 3 ||
-            !decoded.every((part) => Number.isSafeInteger(part)) ||
-            JSON.stringify(decoded) !== source) {
-            throw new TypeError("Invalid tagged INTERVAL value");
-        }
-        return value;
-    }
-    const source = value.trim();
-    let months = 0;
-    let days = 0;
-    let microseconds = 0;
-    let matched = 0;
-    const partPattern = /([+-]?\d+(?:\.\d+)?)\s*([a-zA-Z]+)/g;
-    const units = new Map([
-        ["year", (amount) => (months += amount * 12)],
-        ["month", (amount) => (months += amount)],
-        ["week", (amount) => (days += amount * 7)],
-        ["day", (amount) => (days += amount)],
-        ["hour", (amount) => (microseconds += amount * 3_600_000_000)],
-        ["minute", (amount) => (microseconds += amount * 60_000_000)],
-        ["second", (amount) => (microseconds += amount * 1_000_000)],
-    ]);
-    for (const part of source.matchAll(partPattern)) {
-        const unit = (part[2] ?? "").toLowerCase().replace(/s$/, "");
-        const apply = units.get(unit);
-        if (apply === undefined)
-            throw new TypeError(`Unknown INTERVAL unit: ${unit}`);
-        const amount = Number(part[1]);
-        if ((unit === "year" || unit === "month" || unit === "week" || unit === "day") &&
-            !Number.isInteger(amount)) {
-            throw new TypeError(`INTERVAL ${unit} must be a whole number`);
-        }
-        apply(amount);
-        matched += 1;
+      parsed = JSON.parse(source);
+    } catch {
+      throw new TypeError("Invalid JSON value");
+    }
+  }
+  const text = boundedJsonText(parsed, binary, binary ? "JSONB value" : "JSON value");
+  return boundedTaggedDomainValue(binary ? JSONB_VALUE : JSON_VALUE, text, binary ? "JSONB value" : "JSON value");
+}
+function jsonDomainDocument(value) {
+  if (typeof value !== "string")
+    return void 0;
+  if (value.startsWith(JSONB_VALUE))
+    return value.slice(JSONB_VALUE.length);
+  if (value.startsWith(JSON_VALUE))
+    return value.slice(JSON_VALUE.length);
+  return void 0;
+}
+function preservedJsonDomainValue(document, binary = false) {
+  assertBoundedDomainString(document, binary ? "JSONB value" : "JSON value");
+  try {
+    JSON.parse(document);
+  } catch {
+    throw new TypeError("Invalid JSON value");
+  }
+  return boundedTaggedDomainValue(binary ? JSONB_VALUE : JSON_VALUE, document, binary ? "JSONB value" : "JSON value");
+}
+function uuidDomainValue(value) {
+  if (value === null || value === void 0)
+    return null;
+  if (typeof value !== "string")
+    throw new TypeError("UUID accepts a string value");
+  assertBoundedDomainString(value, "UUID value");
+  const source = (value.startsWith(UUID_VALUE) ? value.slice(UUID_VALUE.length) : value).toLowerCase();
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(source)) {
+    throw new TypeError(`Invalid UUID value: ${value}`);
+  }
+  return UUID_VALUE + source;
+}
+function dateDomainValue(value) {
+  if (value === null || value === void 0)
+    return null;
+  let source;
+  if (value instanceof Date) {
+    if (!Number.isFinite(value.getTime()))
+      throw new TypeError("DATE accepts a valid Date value");
+    source = dateIsoString(value).slice(0, 10);
+  } else if (typeof value === "string") {
+    assertBoundedDomainString(value, "DATE value");
+    source = value.startsWith(DATE_VALUE) ? value.slice(DATE_VALUE.length) : value;
+  } else {
+    throw new TypeError("DATE accepts a YYYY-MM-DD string value");
+  }
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(source);
+  const year = Number(match?.[1]);
+  const month = Number(match?.[2]);
+  const day = Number(match?.[3]);
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  if (match === null || year < 1 || month < 1 || month > 12 || day < 1 || day > (days[month - 1] ?? 0)) {
+    throw new TypeError(`Invalid DATE value: ${String(value)}`);
+  }
+  return DATE_VALUE + source;
+}
+function isDateDomainValue(value) {
+  return typeof value === "string" && value.startsWith(DATE_VALUE);
+}
+function timeDomainValue(value) {
+  if (value === null || value === void 0)
+    return null;
+  if (typeof value !== "string")
+    throw new TypeError("TIME accepts a string value");
+  assertBoundedDomainString(value, "TIME value");
+  const source = value.startsWith(TIME_VALUE) ? value.slice(TIME_VALUE.length) : value;
+  const match = /^(\d{2}):(\d{2})(?::(\d{2})(\.\d{1,6})?)?$/.exec(source);
+  const hours = match?.[1];
+  const minutes = match?.[2];
+  if (match === null || hours === void 0 || minutes === void 0 || Number(hours) > 23 || Number(minutes) > 59 || Number(match[3] ?? 0) > 59) {
+    throw new TypeError(`Invalid TIME value: ${value}`);
+  }
+  return TIME_VALUE + `${hours}:${minutes}:${match[3] ?? "00"}${match[4] ?? ""}`;
+}
+function intervalDomainValue(value) {
+  if (value === null || value === void 0)
+    return null;
+  if (typeof value !== "string")
+    throw new TypeError("INTERVAL accepts a string value");
+  assertBoundedDomainString(value, "INTERVAL value");
+  if (value.startsWith(INTERVAL_VALUE)) {
+    const source2 = value.slice(INTERVAL_VALUE.length);
+    let decoded;
+    try {
+      decoded = JSON.parse(source2);
+    } catch {
+      throw new TypeError("Invalid tagged INTERVAL value");
     }
-    const residue = source.replace(partPattern, "").trim();
-    if (matched === 0 ||
-        residue !== "" ||
-        !Number.isSafeInteger(months) ||
-        !Number.isSafeInteger(days) ||
-        !Number.isSafeInteger(microseconds)) {
-        throw new TypeError(`Invalid INTERVAL value: ${value}`);
+    if (!Array.isArray(decoded) || decoded.length !== 3 || !decoded.every((part) => Number.isSafeInteger(part)) || JSON.stringify(decoded) !== source2) {
+      throw new TypeError("Invalid tagged INTERVAL value");
     }
-    return boundedTaggedDomainValue(INTERVAL_VALUE, JSON.stringify([months, days, microseconds]), "INTERVAL value");
-}
-export function arrayDomainValue(values) {
-    return boundedTaggedDomainValue(ARRAY_VALUE, boundedJsonText(values.map(externalSqlDomainValue), true, "ARRAY value"), "ARRAY value");
+    return value;
+  }
+  const source = value.trim();
+  let months = 0;
+  let days = 0;
+  let microseconds = 0;
+  let matched = 0;
+  const partPattern = /([+-]?\d+(?:\.\d+)?)\s*([a-zA-Z]+)/g;
+  const units = /* @__PURE__ */ new Map([
+    ["year", (amount) => months += amount * 12],
+    ["month", (amount) => months += amount],
+    ["week", (amount) => days += amount * 7],
+    ["day", (amount) => days += amount],
+    ["hour", (amount) => microseconds += amount * 36e8],
+    ["minute", (amount) => microseconds += amount * 6e7],
+    ["second", (amount) => microseconds += amount * 1e6]
+  ]);
+  for (const part of source.matchAll(partPattern)) {
+    const unit = (part[2] ?? "").toLowerCase().replace(/s$/, "");
+    const apply = units.get(unit);
+    if (apply === void 0)
+      throw new TypeError(`Unknown INTERVAL unit: ${unit}`);
+    const amount = Number(part[1]);
+    if ((unit === "year" || unit === "month" || unit === "week" || unit === "day") && !Number.isInteger(amount)) {
+      throw new TypeError(`INTERVAL ${unit} must be a whole number`);
+    }
+    apply(amount);
+    matched += 1;
+  }
+  const residue = source.replace(partPattern, "").trim();
+  if (matched === 0 || residue !== "" || !Number.isSafeInteger(months) || !Number.isSafeInteger(days) || !Number.isSafeInteger(microseconds)) {
+    throw new TypeError(`Invalid INTERVAL value: ${value}`);
+  }
+  return boundedTaggedDomainValue(INTERVAL_VALUE, JSON.stringify([months, days, microseconds]), "INTERVAL value");
+}
+function arrayDomainValue(values) {
+  return boundedTaggedDomainValue(ARRAY_VALUE, boundedJsonText(values.map(externalSqlDomainValue), true, "ARRAY value"), "ARRAY value");
 }
 function enumDomainValue(value, name, values) {
-    if (value === null || value === undefined)
-        return null;
-    if (typeof value !== "string")
-        throw new TypeError(`Enum ${name} accepts a string value`);
-    assertBoundedDomainString(value, `Enum ${name} value`);
-    let source = value;
-    // Enum labels are arbitrary strings. Prefer an exact declared label before recognizing the
-    // internal tag namespace, so a legal label can begin with that prefix just like ordinary TEXT.
-    if (!values.includes(value) && value.startsWith(ENUM_VALUE)) {
-        const encoded = value.slice(ENUM_VALUE.length);
-        let decoded;
-        try {
-            decoded = JSON.parse(encoded);
-        }
-        catch {
-            throw new TypeError(`Invalid tagged enum ${name} value`);
-        }
-        if (!Array.isArray(decoded) ||
-            decoded.length !== 3 ||
-            decoded[0] !== name ||
-            !Number.isSafeInteger(decoded[1]) ||
-            typeof decoded[2] !== "string" ||
-            JSON.stringify(decoded) !== encoded) {
-            throw new TypeError(`Invalid tagged enum ${name} value`);
-        }
-        source = decoded[2];
-    }
-    const index = values.indexOf(source);
-    if (index === -1)
-        throw new TypeError(`${source} is not a value of enum ${name}`);
-    return boundedTaggedDomainValue(ENUM_VALUE, boundedJsonText([name, index, source], false, `Enum ${name} value`), `Enum ${name} value`);
-}
-export function enumDomainCompare(left, right) {
-    if (typeof left !== "string" ||
-        typeof right !== "string" ||
-        !left.startsWith(ENUM_VALUE) ||
-        !right.startsWith(ENUM_VALUE)) {
-        return undefined;
-    }
-    const a = JSON.parse(left.slice(ENUM_VALUE.length));
-    const b = JSON.parse(right.slice(ENUM_VALUE.length));
-    if (a[0] !== b[0])
-        throw new TypeError("Cannot compare values of different enum types");
-    return a[1] - b[1];
-}
-export function normalizeSqlDomainValue(domain, value) {
-    if (domain.kind === "numeric") {
-        return exactNumericValue(value, domain.precision, domain.scale);
-    }
-    if (domain.kind === "json")
-        return jsonDomainValue(value, false);
-    if (domain.kind === "jsonb")
-        return jsonDomainValue(value, true);
-    if (domain.kind === "uuid")
-        return uuidDomainValue(value);
-    if (domain.kind === "date")
-        return dateDomainValue(value);
-    if (domain.kind === "time")
-        return timeDomainValue(value);
-    if (domain.kind === "interval")
-        return intervalDomainValue(value);
-    if (domain.kind === "enum")
-        return enumDomainValue(value, domain.name, domain.values);
-    if (value === null || value === undefined)
-        return null;
-    if (typeof value !== "string")
-        throw new TypeError("ARRAY columns accept JSON array text");
-    const source = value.startsWith(ARRAY_VALUE) ? value.slice(ARRAY_VALUE.length) : value;
-    assertBoundedDomainString(source, "ARRAY value");
-    let parsed;
+  if (value === null || value === void 0)
+    return null;
+  if (typeof value !== "string")
+    throw new TypeError(`Enum ${name} accepts a string value`);
+  assertBoundedDomainString(value, `Enum ${name} value`);
+  let source = value;
+  if (!values.includes(value) && value.startsWith(ENUM_VALUE)) {
+    const encoded = value.slice(ENUM_VALUE.length);
+    let decoded;
     try {
-        parsed = JSON.parse(source);
-    }
-    catch {
-        throw new TypeError("Invalid ARRAY value");
-    }
-    if (!Array.isArray(parsed))
-        throw new TypeError("ARRAY value must be an array");
-    // JSON array text contains ordinary JSON strings. Do not interpret a string that happens to
-    // begin with Minnow's internal domain prefix as an already-tagged SQL scalar.
-    return boundedTaggedDomainValue(ARRAY_VALUE, boundedJsonText(parsed, true, "ARRAY value"), "ARRAY value");
-}
-const collators = new Map();
+      decoded = JSON.parse(encoded);
+    } catch {
+      throw new TypeError(`Invalid tagged enum ${name} value`);
+    }
+    if (!Array.isArray(decoded) || decoded.length !== 3 || decoded[0] !== name || !Number.isSafeInteger(decoded[1]) || typeof decoded[2] !== "string" || JSON.stringify(decoded) !== encoded) {
+      throw new TypeError(`Invalid tagged enum ${name} value`);
+    }
+    source = decoded[2];
+  }
+  const index = values.indexOf(source);
+  if (index === -1)
+    throw new TypeError(`${source} is not a value of enum ${name}`);
+  return boundedTaggedDomainValue(ENUM_VALUE, boundedJsonText([name, index, source], false, `Enum ${name} value`), `Enum ${name} value`);
+}
+function enumDomainCompare(left, right) {
+  if (typeof left !== "string" || typeof right !== "string" || !left.startsWith(ENUM_VALUE) || !right.startsWith(ENUM_VALUE)) {
+    return void 0;
+  }
+  const a = JSON.parse(left.slice(ENUM_VALUE.length));
+  const b = JSON.parse(right.slice(ENUM_VALUE.length));
+  if (a[0] !== b[0])
+    throw new TypeError("Cannot compare values of different enum types");
+  return a[1] - b[1];
+}
+function normalizeSqlDomainValue(domain, value) {
+  if (domain.kind === "numeric") {
+    return exactNumericValue(value, domain.precision, domain.scale);
+  }
+  if (domain.kind === "json")
+    return jsonDomainValue(value, false);
+  if (domain.kind === "jsonb")
+    return jsonDomainValue(value, true);
+  if (domain.kind === "uuid")
+    return uuidDomainValue(value);
+  if (domain.kind === "date")
+    return dateDomainValue(value);
+  if (domain.kind === "time")
+    return timeDomainValue(value);
+  if (domain.kind === "interval")
+    return intervalDomainValue(value);
+  if (domain.kind === "enum")
+    return enumDomainValue(value, domain.name, domain.values);
+  if (value === null || value === void 0)
+    return null;
+  if (typeof value !== "string")
+    throw new TypeError("ARRAY columns accept JSON array text");
+  const source = value.startsWith(ARRAY_VALUE) ? value.slice(ARRAY_VALUE.length) : value;
+  assertBoundedDomainString(source, "ARRAY value");
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch {
+    throw new TypeError("Invalid ARRAY value");
+  }
+  if (!Array.isArray(parsed))
+    throw new TypeError("ARRAY value must be an array");
+  return boundedTaggedDomainValue(ARRAY_VALUE, boundedJsonText(parsed, true, "ARRAY value"), "ARRAY value");
+}
+const collators = /* @__PURE__ */ new Map();
 const MAX_COLLATOR_CACHE_ENTRIES = 64;
-export function collatedDomainValue(value, collation) {
-    if (value === null || value === undefined)
-        return null;
-    value = externalSqlDomainValue(value);
-    if (typeof value !== "string" || typeof collation !== "string") {
-        throw new TypeError("COLLATE requires a string value and collation name");
-    }
-    assertBoundedDomainString(value, "COLLATE value");
-    assertBoundedDomainString(collation, "COLLATE name");
-    const locale = collation === "POSIX" ? "C" : collation;
-    if (locale !== "C")
-        collatorFor(locale, collation);
-    return boundedTaggedDomainValue(COLLATION_VALUE, boundedJsonText([locale, value], false, "COLLATE value"), "COLLATE value");
+function collatedDomainValue(value, collation) {
+  if (value === null || value === void 0)
+    return null;
+  value = externalSqlDomainValue(value);
+  if (typeof value !== "string" || typeof collation !== "string") {
+    throw new TypeError("COLLATE requires a string value and collation name");
+  }
+  assertBoundedDomainString(value, "COLLATE value");
+  assertBoundedDomainString(collation, "COLLATE name");
+  const locale = collation === "POSIX" ? "C" : collation;
+  if (locale !== "C")
+    collatorFor(locale, collation);
+  return boundedTaggedDomainValue(COLLATION_VALUE, boundedJsonText([locale, value], false, "COLLATE value"), "COLLATE value");
 }
 function boundedTaggedDomainValue(prefix, value, label) {
-    // The prefix is an internal physical tag and is removed at the JavaScript boundary. Limit the
-    // user-visible payload, while the fixed tag adds only a few bounded bytes in storage.
-    if (value.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
-        throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
-    }
-    return prefix + value;
-}
-export function collatedDomainCompare(left, right) {
-    const decode = (value) => typeof value === "string" && value.startsWith(COLLATION_VALUE)
-        ? JSON.parse(value.slice(COLLATION_VALUE.length))
-        : undefined;
-    const a = decode(left);
-    const b = decode(right);
-    if (a === undefined && b === undefined)
-        return undefined;
-    if (a === undefined && typeof left !== "string")
-        return undefined;
-    if (b === undefined && typeof right !== "string")
-        return undefined;
-    const locale = a?.[0] ?? b?.[0] ?? "C";
-    if ((a !== undefined && a[0] !== locale) || (b !== undefined && b[0] !== locale)) {
-        throw new TypeError("Cannot compare values with different collations");
-    }
-    const leftValue = a?.[1] ?? left;
-    const rightValue = b?.[1] ?? right;
-    if (locale === "C")
-        return leftValue === rightValue ? 0 : leftValue < rightValue ? -1 : 1;
-    return collatorFor(locale, locale).compare(leftValue, rightValue);
+  if (value.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+    throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+  }
+  return prefix + value;
+}
+function collatedDomainCompare(left, right) {
+  const decode = (value) => typeof value === "string" && value.startsWith(COLLATION_VALUE) ? JSON.parse(value.slice(COLLATION_VALUE.length)) : void 0;
+  const a = decode(left);
+  const b = decode(right);
+  if (a === void 0 && b === void 0)
+    return void 0;
+  if (a === void 0 && typeof left !== "string")
+    return void 0;
+  if (b === void 0 && typeof right !== "string")
+    return void 0;
+  const locale = a?.[0] ?? b?.[0] ?? "C";
+  if (a !== void 0 && a[0] !== locale || b !== void 0 && b[0] !== locale) {
+    throw new TypeError("Cannot compare values with different collations");
+  }
+  const leftValue = a?.[1] ?? left;
+  const rightValue = b?.[1] ?? right;
+  if (locale === "C")
+    return leftValue === rightValue ? 0 : leftValue < rightValue ? -1 : 1;
+  return collatorFor(locale, locale).compare(leftValue, rightValue);
 }
 function collatorFor(locale, displayName) {
-    const cached = collators.get(locale);
-    if (cached !== undefined) {
-        collators.delete(locale);
-        collators.set(locale, cached);
-        return cached;
-    }
-    let created;
-    try {
-        created = new Intl.Collator(locale, { usage: "sort", sensitivity: "variant" });
-    }
-    catch {
-        throw new TypeError(`Unsupported collation: ${displayName}`);
-    }
-    if (collators.size >= MAX_COLLATOR_CACHE_ENTRIES) {
-        const oldest = collators.keys().next().value;
-        if (oldest !== undefined)
-            collators.delete(oldest);
-    }
-    collators.set(locale, created);
-    return created;
-}
-/**
- * Renders one result value at the JavaScript boundary using its column's logical domain.
- * A NUMERIC column with a declared scale displays PostgreSQL-style at exactly that scale:
- * the physical encoding is canonical (trailing fractional zeros stripped), so the declared
- * scale is restored by padding — never rounding — and a value carrying more fractional
- * digits than the declaration keeps every digit it has. Every other domain, and every value
- * without one, renders exactly as externalSqlDomainValue.
- */
-export function externalSqlDomainColumnValue(value, domain) {
-    if (domain?.kind === "numeric" &&
-        domain.scale !== undefined &&
-        domain.scale > 0 &&
-        typeof value === "string" &&
-        value.startsWith(NUMERIC)) {
-        const text = value.slice(NUMERIC.length);
-        const dot = text.indexOf(".");
-        const fractionDigits = dot === -1 ? 0 : text.length - dot - 1;
-        if (fractionDigits >= domain.scale)
-            return text;
-        return (dot === -1 ? `${text}.` : text) + "0".repeat(domain.scale - fractionDigits);
-    }
-    return externalSqlDomainValue(value);
-}
-export function externalSqlDomainValue(value) {
-    if (typeof value !== "string")
-        return value;
-    if (value.startsWith(TEXT_VALUE))
-        return value.slice(TEXT_VALUE.length);
-    for (const prefix of [NUMERIC, JSON_VALUE, JSONB_VALUE, UUID_VALUE, DATE_VALUE, TIME_VALUE]) {
-        if (value.startsWith(prefix))
-            return value.slice(prefix.length);
-    }
-    if (value.startsWith(INTERVAL_VALUE)) {
-        const decoded = JSON.parse(value.slice(INTERVAL_VALUE.length));
-        return `${String(decoded[0])} mons ${String(decoded[1])} days ${String(decoded[2])} usecs`;
-    }
-    if (value.startsWith(ARRAY_VALUE))
-        return value.slice(ARRAY_VALUE.length);
-    if (value.startsWith(COLLATION_VALUE)) {
-        return JSON.parse(value.slice(COLLATION_VALUE.length))[1];
-    }
-    if (value.startsWith(ENUM_VALUE)) {
-        return JSON.parse(value.slice(ENUM_VALUE.length))[2];
-    }
+  const cached = collators.get(locale);
+  if (cached !== void 0) {
+    collators.delete(locale);
+    collators.set(locale, cached);
+    return cached;
+  }
+  let created;
+  try {
+    created = new Intl.Collator(locale, { usage: "sort", sensitivity: "variant" });
+  } catch {
+    throw new TypeError(`Unsupported collation: ${displayName}`);
+  }
+  if (collators.size >= MAX_COLLATOR_CACHE_ENTRIES) {
+    const oldest = collators.keys().next().value;
+    if (oldest !== void 0)
+      collators.delete(oldest);
+  }
+  collators.set(locale, created);
+  return created;
+}
+function externalSqlDomainColumnValue(value, domain) {
+  if (domain?.kind === "numeric" && domain.scale !== void 0 && domain.scale > 0 && typeof value === "string" && value.startsWith(NUMERIC)) {
+    const text = value.slice(NUMERIC.length);
+    const dot = text.indexOf(".");
+    const fractionDigits = dot === -1 ? 0 : text.length - dot - 1;
+    if (fractionDigits >= domain.scale)
+      return text;
+    return (dot === -1 ? `${text}.` : text) + "0".repeat(domain.scale - fractionDigits);
+  }
+  return externalSqlDomainValue(value);
+}
+function externalSqlDomainValue(value) {
+  if (typeof value !== "string")
     return value;
+  if (value.startsWith(TEXT_VALUE))
+    return value.slice(TEXT_VALUE.length);
+  for (const prefix of [NUMERIC, JSON_VALUE, JSONB_VALUE, UUID_VALUE, DATE_VALUE, TIME_VALUE]) {
+    if (value.startsWith(prefix))
+      return value.slice(prefix.length);
+  }
+  if (value.startsWith(INTERVAL_VALUE)) {
+    const decoded = JSON.parse(value.slice(INTERVAL_VALUE.length));
+    return `${String(decoded[0])} mons ${String(decoded[1])} days ${String(decoded[2])} usecs`;
+  }
+  if (value.startsWith(ARRAY_VALUE))
+    return value.slice(ARRAY_VALUE.length);
+  if (value.startsWith(COLLATION_VALUE)) {
+    return JSON.parse(value.slice(COLLATION_VALUE.length))[1];
+  }
+  if (value.startsWith(ENUM_VALUE)) {
+    return JSON.parse(value.slice(ENUM_VALUE.length))[2];
+  }
+  return value;
 }
-/**
- * The domain kind carried by an internal string value, or undefined for ordinary text. The
- * protected-TEXT wrapper and collated text are both ordinary text to PostgreSQL's operator
- * resolution, so they report no kind.
- */
 function concatenationDomainKind(value) {
-    if (!value.startsWith(PREFIX))
-        return undefined;
-    if (value.startsWith(TEXT_VALUE) || value.startsWith(COLLATION_VALUE))
-        return undefined;
-    const rest = value.slice(PREFIX.length);
-    const colon = rest.indexOf(":");
-    return colon === -1 ? undefined : rest.slice(0, colon);
-}
-/**
- * SQL `||` over internal string values, shared by both executors and constant folding so the
- * three paths cannot disagree. PostgreSQL resolves `||` to text concatenation only when one
- * side is text: its array and JSONB `||` operators are structural concatenation, which this
- * engine does not implement, and two non-text operands have no `||` operator at all. Refusing
- * those shapes keeps `||` from inventing a text concatenation PostgreSQL does not have —
- * and from ever concatenating internal domain encodings.
- */
-export function concatenatedSqlValue(left, right) {
-    const leftKind = concatenationDomainKind(left);
-    const rightKind = concatenationDomainKind(right);
-    for (const kind of [leftKind, rightKind]) {
-        if (kind === "array") {
-            throw new TypeError("PostgreSQL array concatenation (||) is not supported");
-        }
-        if (kind === "jsonb") {
-            throw new TypeError("PostgreSQL JSONB concatenation (||) is not supported");
-        }
-    }
-    if (leftKind !== undefined && rightKind !== undefined) {
-        throw new TypeError(`No || operator for ${leftKind} and ${rightKind} values`);
-    }
-    return protectedSqlTextValue(String(externalSqlDomainValue(left)) + String(externalSqlDomainValue(right)));
-}
-export function isSqlDomainValue(value) {
-    return typeof value === "string" && value.startsWith(PREFIX);
-}
+  if (!value.startsWith(PREFIX))
+    return void 0;
+  if (value.startsWith(TEXT_VALUE) || value.startsWith(COLLATION_VALUE))
+    return void 0;
+  const rest = value.slice(PREFIX.length);
+  const colon = rest.indexOf(":");
+  return colon === -1 ? void 0 : rest.slice(0, colon);
+}
+function concatenatedSqlValue(leftValue, rightValue) {
+  const leftText = typeof leftValue === "string";
+  const rightText = typeof rightValue === "string";
+  if (!leftText && !rightText)
+    throw new TypeError("|| requires a string operand");
+  const left = leftText ? leftValue : concatenationOperandText(leftValue);
+  const right = rightText ? rightValue : concatenationOperandText(rightValue);
+  const leftKind = concatenationDomainKind(left);
+  const rightKind = concatenationDomainKind(right);
+  for (const kind of [leftKind, rightKind]) {
+    if (kind === "array") {
+      throw new TypeError("PostgreSQL array concatenation (||) is not supported");
+    }
+    if (kind === "jsonb") {
+      throw new TypeError("PostgreSQL JSONB concatenation (||) is not supported");
+    }
+  }
+  if (leftKind !== void 0 && rightKind !== void 0) {
+    throw new TypeError(`No || operator for ${leftKind} and ${rightKind} values`);
+  }
+  return protectedSqlTextValue(String(externalSqlDomainValue(left)) + String(externalSqlDomainValue(right)));
+}
+function concatenationOperandText(value) {
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  if (value instanceof Date)
+    return dateIsoString(value);
+  throw new TypeError("|| requires a string operand");
+}
+function intervalDomainCompare(left, right) {
+  if (typeof left !== "string" || typeof right !== "string" || !left.startsWith(INTERVAL_VALUE) || !right.startsWith(INTERVAL_VALUE)) {
+    return void 0;
+  }
+  const total = (value) => {
+    const [months, days, microseconds] = JSON.parse(value.slice(INTERVAL_VALUE.length));
+    return (months * 30 + days) * 864e8 + microseconds;
+  };
+  const difference = total(left) - total(right);
+  return difference === 0 ? 0 : difference < 0 ? -1 : 1;
+}
+function isSqlDomainValue(value) {
+  return typeof value === "string" && value.startsWith(PREFIX);
+}
+export {
+  arrayDomainValue,
+  boundedJsonText,
+  collatedDomainCompare,
+  collatedDomainValue,
+  concatenatedSqlValue,
+  dateDomainValue,
+  enumDomainCompare,
+  exactNumericAsNumber,
+  exactNumericBinary,
+  exactNumericCompare,
+  exactNumericLiteral,
+  exactNumericValue,
+  externalSqlDomainColumnValue,
+  externalSqlDomainValue,
+  externalSqlTextValue,
+  intervalDomainCompare,
+  intervalDomainValue,
+  isDateDomainValue,
+  isExactNumeric,
+  isSqlDomainValue,
+  jsonDomainDocument,
+  jsonDomainValue,
+  normalizeSqlDomainValue,
+  preservedJsonDomainValue,
+  protectedSqlTextValue,
+  timeDomainValue,
+  uuidDomainValue
+};