@minnowdb/core 0.3.0 → 0.4.0

package/dist/engine/sql-domains.js

@@ -1,3 +1,6 @@
+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:";
 const TEXT_VALUE = `${PREFIX}text:`;
@@ -24,23 +27,25 @@ export function externalSqlTextValue(value) {
         ? value.slice(TEXT_VALUE.length)
         : value;
 }
-const powersOfTen = [1n];
 function pow10(exponent) {
     if (!Number.isSafeInteger(exponent) || exponent < 0 || exponent > 100_000) {
         throw new RangeError(`Decimal scale is outside the supported range: ${String(exponent)}`);
     }
-    for (let index = powersOfTen.length; index <= exponent; index += 1) {
-        powersOfTen.push((powersOfTen[index - 1] ?? 1n) * 10n);
-    }
-    return powersOfTen[exponent] ?? 1n;
+    // 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);
 }
 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}`);
@@ -114,7 +119,7 @@ export function exactNumericValue(value, precision, scale) {
             throw new RangeError(`NUMERIC(${String(precision)}, ${String(declaredScale)}) overflow`);
         }
     }
-    return NUMERIC + formatDecimal(normalizeDecimal(adjusted));
+    return boundedTaggedDomainValue(NUMERIC, formatDecimal(normalizeDecimal(adjusted)), "NUMERIC value");
 }
 export function exactNumericBinary(operator, left, right) {
     const leftTagged = taggedDecimalParts(left);
@@ -156,7 +161,7 @@ export function exactNumericBinary(operator, left, right) {
         }
         result = { coefficient, scale };
     }
-    return NUMERIC + formatDecimal(normalizeDecimal(result));
+    return boundedTaggedDomainValue(NUMERIC, formatDecimal(normalizeDecimal(result)), "NUMERIC result");
 }
 export function exactNumericCompare(left, right) {
     const leftTagged = taggedDecimalParts(left);
@@ -174,25 +179,116 @@ export function exactNumericCompare(left, right) {
     const bc = b.coefficient * pow10(scale - b.scale);
     return ac === bc ? 0 : ac < bc ? -1 : 1;
 }
-function canonicalJson(value) {
-    const normalize = (item) => {
-        if (item === null || typeof item === "boolean" || typeof item === "string")
-            return item;
-        if (typeof item === "number") {
-            if (!Number.isFinite(item))
-                throw new TypeError("JSON numbers must be finite");
-            return item;
+/**
+ * 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("");
+}
+function encodeBoundedJson(value, canonical, label, depth, state) {
+    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;
+        // 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 (Array.isArray(item))
-            return item.map(normalize);
-        if (typeof item === "object") {
-            return Object.fromEntries(Object.keys(item)
-                .sort()
-                .map((key) => [key, normalize(item[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);
         }
-        throw new TypeError("Value cannot be represented as JSON");
-    };
-    return JSON.stringify(normalize(value));
+        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);
+}
+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)
@@ -205,6 +301,7 @@ export function jsonDomainValue(value, binary) {
                 ? JSON_VALUE
                 : undefined;
         const source = prefix === undefined ? value : value.slice(prefix.length);
+        assertBoundedDomainString(source, "JSON value");
         try {
             parsed = JSON.parse(source);
         }
@@ -212,14 +309,15 @@ export function jsonDomainValue(value, binary) {
             throw new TypeError("Invalid JSON value");
         }
     }
-    const text = binary ? canonicalJson(parsed) : JSON.stringify(parsed);
-    return (binary ? JSONB_VALUE : JSON_VALUE) + text;
+    const text = boundedJsonText(parsed, binary, binary ? "JSONB value" : "JSON value");
+    return boundedTaggedDomainValue(binary ? JSONB_VALUE : JSON_VALUE, text, 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}`);
@@ -231,6 +329,7 @@ export function timeDomainValue(value) {
         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];
@@ -248,10 +347,26 @@ export function timeDomainValue(value) {
 export function intervalDomainValue(value) {
     if (value === null || value === undefined)
         return null;
-    if (typeof value === "string" && value.startsWith(INTERVAL_VALUE))
-        return value;
     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;
@@ -288,23 +403,43 @@ export function intervalDomainValue(value) {
         !Number.isSafeInteger(microseconds)) {
         throw new TypeError(`Invalid INTERVAL value: ${value}`);
     }
-    return INTERVAL_VALUE + JSON.stringify([months, days, microseconds]);
+    return boundedTaggedDomainValue(INTERVAL_VALUE, JSON.stringify([months, days, microseconds]), "INTERVAL value");
 }
 export function arrayDomainValue(values) {
-    return ARRAY_VALUE + canonicalJson(values.map(externalSqlDomainValue));
+    return boundedTaggedDomainValue(ARRAY_VALUE, boundedJsonText(values.map(externalSqlDomainValue), true, "ARRAY value"), "ARRAY value");
 }
 export 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`);
-    const source = value.startsWith(ENUM_VALUE)
-        ? JSON.parse(value.slice(ENUM_VALUE.length))[2]
-        : 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 ENUM_VALUE + JSON.stringify([name, index, source]);
+    return boundedTaggedDomainValue(ENUM_VALUE, boundedJsonText([name, index, source], false, `Enum ${name} value`), `Enum ${name} value`);
 }
 export function enumDomainCompare(left, right) {
     if (typeof left !== "string" ||
@@ -340,6 +475,7 @@ export function normalizeSqlDomainValue(domain, value) {
     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);
@@ -349,9 +485,12 @@ export function normalizeSqlDomainValue(domain, value) {
     }
     if (!Array.isArray(parsed))
         throw new TypeError("ARRAY value must be an array");
-    return arrayDomainValue(parsed);
+    // 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();
+const MAX_COLLATOR_CACHE_ENTRIES = 64;
 export function collatedDomainValue(value, collation) {
     if (value === null || value === undefined)
         return null;
@@ -359,16 +498,20 @@ export function collatedDomainValue(value, collation) {
     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" && !collators.has(locale)) {
-        try {
-            collators.set(locale, new Intl.Collator(locale, { usage: "sort", sensitivity: "variant" }));
-        }
-        catch {
-            throw new TypeError(`Unsupported collation: ${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 COLLATION_VALUE + JSON.stringify([locale, value]);
+    return prefix + value;
 }
 export function collatedDomainCompare(left, right) {
     const decode = (value) => typeof value === "string" && value.startsWith(COLLATION_VALUE)
@@ -390,7 +533,29 @@ export function collatedDomainCompare(left, right) {
     const rightValue = b?.[1] ?? right;
     if (locale === "C")
         return leftValue === rightValue ? 0 : leftValue < rightValue ? -1 : 1;
-    return (collators.get(locale) ?? new Intl.Collator(locale)).compare(leftValue, rightValue);
+    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;
 }
 export function externalSqlDomainValue(value) {
     if (typeof value !== "string")
@@ -418,4 +583,3 @@ export function externalSqlDomainValue(value) {
 export function isSqlDomainValue(value) {
     return typeof value === "string" && value.startsWith(PREFIX);
 }
-//# sourceMappingURL=sql-domains.js.map

package/dist/engine/sql-driver.d.ts

@@ -1,5 +1,5 @@
 import type { Catalog } from "./catalog.js";
-import type { ExecuteResult, QueryOptions } from "./database.js";
+import type { ExecuteResult, QueryCursorOptions, QueryOptions } from "./database.js";
 import type { QueryResult, QueryValue } from "./query.js";
 /**
  * The stable SQL boundary used by clients and third-party adapters.
@@ -10,10 +10,10 @@ import type { QueryResult, QueryValue } from "./query.js";
  */
 export interface MinnowSqlExecutor {
     query(sql: string, options?: QueryOptions): Promise<QueryResult>;
+    queryCursor(sql: string, options?: QueryCursorOptions): AsyncIterableIterator<QueryResult>;
     execute(sql: string, params?: readonly QueryValue[]): Promise<ExecuteResult>;
 }
 /** SQL execution plus the catalog surface schema-aware adapters need. */
 export interface MinnowSqlDriver extends MinnowSqlExecutor {
     introspect(): Promise<Catalog>;
 }
-//# sourceMappingURL=sql-driver.d.ts.map

package/dist/engine/sql-driver.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=sql-driver.js.map

package/dist/engine/sql-json.d.ts

@@ -26,4 +26,3 @@ export declare function jsonValueOf(value: unknown): unknown;
  */
 export declare function jsonConstructor(name: "JSON_ARRAY" | "JSON_OBJECT", values: readonly unknown[]): string;
 export {};
-//# sourceMappingURL=sql-json.d.ts.map

package/dist/engine/sql-json.js

@@ -1,7 +1,11 @@
 import { stringArgument } from "./sql-semantics.js";
 import { externalSqlDomainValue } from "./sql-domains.js";
+import { MAX_CACHEABLE_TEXT_CHARACTERS, MAX_SQL_SCALAR_RESULT_CHARACTERS } from "./cache-limits.js";
 export function parseJsonPath(path, caller) {
     const text = stringArgument(caller, path).trim();
+    if (text.length > MAX_CACHEABLE_TEXT_CHARACTERS) {
+        throw new RangeError(`${caller} path exceeds ${String(MAX_CACHEABLE_TEXT_CHARACTERS)} characters`);
+    }
     if (!text.startsWith("$"))
         throw new TypeError(`${caller} paths start at $`);
     const steps = [];
@@ -42,8 +46,9 @@ export function parseJsonPath(path, caller) {
 export function jsonAtPath(document, path, caller) {
     const steps = parseJsonPath(path, caller);
     let current;
+    const source = boundedJsonDocument(document, caller);
     try {
-        current = JSON.parse(stringArgument(caller, externalSqlDomainValue(document)));
+        current = JSON.parse(source);
     }
     catch {
         // A document that is not JSON selects nothing rather than failing the whole statement,
@@ -75,6 +80,9 @@ export function jsonIsValid(document, kind) {
     document = externalSqlDomainValue(document);
     if (typeof document !== "string")
         return false;
+    if (document.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+        throw new RangeError(`JSON document exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+    }
     let parsed;
     try {
         parsed = JSON.parse(document);
@@ -97,7 +105,7 @@ export function jsonIsValid(document, kind) {
 /** A SQL value as its JSON counterpart: datetimes serialize as ISO text, like every cast. */
 export function jsonValueOf(value) {
     const external = externalSqlDomainValue(value);
-    return external instanceof Date ? external.toISOString() : external;
+    return external instanceof Date ? dateIsoString(external) : external;
 }
 /**
  * JSON_ARRAY(v, ...) and JSON_OBJECT(k, v, ...) (T811/T812). The omitted null-handling clause is
@@ -106,7 +114,8 @@ export function jsonValueOf(value) {
  */
 export function jsonConstructor(name, values) {
     if (name === "JSON_ARRAY") {
-        return JSON.stringify(values.map((value) => jsonValueOf(value ?? null)));
+        const members = values.map((value) => boundedJsonValue(value ?? null, "JSON_ARRAY value"));
+        return joinBoundedJson("[", members, "]", "JSON_ARRAY result");
     }
     const members = [];
     for (let index = 0; index + 1 < values.length; index += 2) {
@@ -116,7 +125,7 @@ export function jsonConstructor(name, values) {
         }
         let key;
         if (rawKey instanceof Date)
-            key = rawKey.toISOString();
+            key = dateIsoString(rawKey);
         else if (typeof rawKey === "string")
             key = rawKey;
         else if (typeof rawKey === "number" || typeof rawKey === "boolean")
@@ -127,8 +136,45 @@ export function jsonConstructor(name, values) {
         // Build JSON text directly. WITHOUT UNIQUE KEYS is the default, so duplicate names must be
         // preserved; assigning through a JavaScript object would collapse them and mishandle
         // special names such as "__proto__".
-        members.push(`${JSON.stringify(key)}:${JSON.stringify(jsonValueOf(member ?? null))}`);
+        const encodedKey = boundedJsonValue(key, "JSON_OBJECT key");
+        const encodedValue = boundedJsonValue(member ?? null, "JSON_OBJECT value");
+        members.push(`${encodedKey}:${encodedValue}`);
+    }
+    return joinBoundedJson("{", members, "}", "JSON_OBJECT result");
+}
+function boundedJsonDocument(value, caller) {
+    const document = stringArgument(caller, externalSqlDomainValue(value));
+    if (document.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+        throw new RangeError(`${caller} document exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+    }
+    return document;
+}
+function boundedJsonValue(value, label) {
+    const normalized = jsonValueOf(value);
+    if (typeof normalized === "string" && normalized.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+        throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+    }
+    const encoded = JSON.stringify(normalized);
+    if (typeof encoded !== "string")
+        throw new TypeError(`${label} is not JSON serializable`);
+    if (encoded.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+        throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+    }
+    return encoded;
+}
+function joinBoundedJson(prefix, members, suffix, label) {
+    let length = prefix.length + suffix.length;
+    for (const member of members) {
+        length += member.length;
+        if (!Number.isSafeInteger(length) || length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+            throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+        }
+    }
+    if (members.length > 1)
+        length += members.length - 1;
+    if (!Number.isSafeInteger(length) || length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+        throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
     }
-    return `{${members.join(",")}}`;
+    return `${prefix}${members.join(",")}${suffix}`;
 }
-//# sourceMappingURL=sql-json.js.map
+import { dateIsoString } from "../date-value.js";

package/dist/engine/sql-semantics.d.ts

@@ -18,10 +18,14 @@ export declare function encodeSqlEqualityValue(value: unknown): readonly unknown
  * integer and clamps to 0..30, with ties rounded away from zero.
  */
 export declare function roundSqlNumber(value: number, precision?: number): number;
-/** Compiles SQL LIKE (% = any run, _ = one codepoint) into a bounded cached RegExp. */
-export declare function compileLikePattern(pattern: string, caseInsensitive?: boolean, escape?: string): RegExp;
-/** PostgreSQL SIMILAR TO: SQL wildcards plus the SQL regular-expression operators, whole-string. */
-export declare function compileSimilarPattern(pattern: string, escape?: string): RegExp;
+/** A whole-string SQL pattern matcher. Unlike RegExp, test never coerces its input. */
+export interface SqlPatternMatcher {
+    test(value: string): boolean;
+}
+/** Compiles SQL LIKE without exposing input to the host regular-expression engine. */
+export declare function compileLikePattern(pattern: string, caseInsensitive?: boolean, escape?: string): SqlPatternMatcher;
+/** PostgreSQL SIMILAR TO compiled to a Thompson NFA with bounded deterministic work. */
+export declare function compileSimilarPattern(pattern: string, escape?: string): SqlPatternMatcher;
 /** Defines an own enumerable result-column property, including the special name `__proto__`. */
 export declare function defineSqlResultProperty(target: Record<string, unknown>, name: string, value: unknown): void;
 /**
@@ -30,4 +34,3 @@ export declare function defineSqlResultProperty(target: Record<string, unknown>,
  * a silent coercion here would make `LENGTH(42)` answer instead of failing.
  */
 export declare function stringArgument(name: string, value: unknown): string;
-//# sourceMappingURL=sql-semantics.d.ts.map