@minnowdb/core 0.7.2 → 0.7.7

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

@@ -7,7 +7,18 @@ import type { SqlDomain } from "../storage/types.js";
 export declare function protectedSqlTextValue(value: string): string;
 /** Removes only the ordinary-TEXT wrapper, leaving real domain values tagged. */
 export declare function externalSqlTextValue(value: unknown): unknown;
+/** The fractional digits a finite number shows when written as a decimal: 1.25 has 2, 8 has 0. */
+export declare function decimalScaleOfNumber(value: number): number;
 export declare function isExactNumeric(value: unknown): value is string;
+/**
+ * PostgreSQL's numeric ROUND and TRUNC at `digits` fractional places, which may be negative to
+ * work left of the decimal point (`ROUND(12345.67, -1)` is 12350). ROUND is half away from
+ * zero, TRUNC toward zero. The result is canonical; a caller wanting display scale reads it
+ * from the inferred column domain.
+ */
+export declare function exactNumericRounded(value: string, digits: number, mode: "round" | "trunc"): string;
+/** ABS, FLOOR, CEIL, and SIGN over an exact NUMERIC value, as PostgreSQL's numeric variants. */
+export declare function exactNumericUnary(name: "ABS" | "FLOOR" | "CEIL" | "SIGN", value: string): string;
 export declare function exactNumericValue(value: unknown, precision?: number, scale?: number): string | null;
 /**
  * Tags a SQL numeric constant with its exact digits, as written. Unlike `exactNumericValue`

package/dist/engine/sql-domains.js

@@ -87,9 +87,55 @@ function taggedDecimalParts(value) {
     return void 0;
   return decimalParts(value.slice(NUMERIC.length));
 }
+function decimalScaleOfNumber(value) {
+  return normalizeDecimal(decimalParts(value)).scale;
+}
 function isExactNumeric(value) {
   return taggedDecimalParts(value) !== void 0;
 }
+function exactNumericRounded(value, digits, mode) {
+  const parts = taggedDecimalParts(value);
+  if (parts === void 0)
+    throw new TypeError("ROUND and TRUNC take an exact NUMERIC value");
+  if (!Number.isSafeInteger(digits) || digits > 1e5 || digits < -1e5) {
+    throw new RangeError(`NUMERIC scale is outside the supported range: ${String(digits)}`);
+  }
+  let result = parts;
+  if (parts.scale > digits) {
+    const divisor = pow10(parts.scale - digits);
+    let quotient = parts.coefficient / divisor;
+    if (mode === "round") {
+      const remainder = parts.coefficient % divisor;
+      if ((remainder < 0n ? -remainder : remainder) * 2n >= divisor) {
+        quotient += parts.coefficient < 0n ? -1n : 1n;
+      }
+    }
+    result = digits >= 0 ? { coefficient: quotient, scale: digits } : { coefficient: quotient * pow10(-digits), scale: 0 };
+  }
+  return boundedTaggedDomainValue(NUMERIC, formatDecimal(normalizeDecimal(result)), "NUMERIC result");
+}
+function exactNumericUnary(name, value) {
+  const parts = taggedDecimalParts(value);
+  if (parts === void 0)
+    throw new TypeError(`${name} takes an exact NUMERIC value`);
+  const { coefficient, scale } = parts;
+  let result;
+  if (name === "ABS") {
+    result = { coefficient: coefficient < 0n ? -coefficient : coefficient, scale };
+  } else if (name === "SIGN") {
+    result = { coefficient: coefficient === 0n ? 0n : coefficient < 0n ? -1n : 1n, scale: 0 };
+  } else {
+    const divisor = pow10(scale);
+    let quotient = coefficient / divisor;
+    const remainder = coefficient % divisor;
+    if (name === "FLOOR" && remainder < 0n)
+      quotient -= 1n;
+    if (name === "CEIL" && remainder > 0n)
+      quotient += 1n;
+    result = { coefficient: quotient, scale: 0 };
+  }
+  return boundedTaggedDomainValue(NUMERIC, formatDecimal(normalizeDecimal(result)), "NUMERIC result");
+}
 function exactNumericValue(value, precision, scale) {
   if (value === null || value === void 0)
     return null;
@@ -582,6 +628,13 @@ function collatorFor(locale, displayName) {
   return created;
 }
 function externalSqlDomainColumnValue(value, domain) {
+  if (domain?.kind === "numeric" && typeof value === "number" && Number.isFinite(value)) {
+    try {
+      return externalSqlDomainValue(exactNumericValue(value));
+    } catch {
+      return value;
+    }
+  }
   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(".");
@@ -676,11 +729,14 @@ export {
   collatedDomainValue,
   concatenatedSqlValue,
   dateDomainValue,
+  decimalScaleOfNumber,
   enumDomainCompare,
   exactNumericAsNumber,
   exactNumericBinary,
   exactNumericCompare,
   exactNumericLiteral,
+  exactNumericRounded,
+  exactNumericUnary,
   exactNumericValue,
   externalSqlDomainColumnValue,
   externalSqlDomainValue,

package/dist/engine/sql-functions.js

@@ -1,6 +1,6 @@
 import { dateIsoString, dateMilliseconds, dateUtcDate, dateUtcDay, dateUtcFullYear, dateUtcHours, dateUtcMinutes, dateUtcMonth, dateUtcSeconds } from "../date-value.js";
 import { MAX_SQL_SCALAR_RESULT_CHARACTERS } from "./cache-limits.js";
-import { dateDomainValue, externalSqlDomainValue, intervalDomainValue, isDateDomainValue, protectedSqlTextValue } from "./sql-domains.js";
+import { dateDomainValue, exactNumericRounded, exactNumericUnary, externalSqlDomainValue, intervalDomainValue, isDateDomainValue, isExactNumeric, protectedSqlTextValue } from "./sql-domains.js";
 import { compileRegexPattern, parseSqlTimestampText, stringArgument } from "./sql-semantics.js";
 function text(name, value) {
   const source = stringArgument(name, value);
@@ -561,6 +561,12 @@ function ageInterval(later, earlier) {
   }
   return intervalDomainValue(`${String(sign * months)} months ${String(sign * days)} days ${String(sign * milliseconds / 1e3)} seconds`);
 }
+function integerArgument(name, value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+    throw new TypeError(`${name} requires integers`);
+  }
+  return value;
+}
 function nullish(value) {
   return value === null || value === void 0;
 }
@@ -782,6 +788,124 @@ const simpleScalarFunctions = /* @__PURE__ */ new Map([
       }
     }
   ],
+  [
+    "REGEXP_SUBSTR",
+    {
+      minArgs: 2,
+      maxArgs: 3,
+      returns: "string",
+      evaluate: (values) => {
+        const expression = compileRegexPattern(text("SUBSTRING", values[1]), regexFlags("SUBSTRING", values[2]));
+        const match = expression.exec(text("SUBSTRING", values[0]));
+        if (match === null)
+          return null;
+        const group = match.length > 1 ? match[1] : match[0];
+        return group === void 0 ? null : bounded(group, "SUBSTRING");
+      }
+    }
+  ],
+  [
+    "NUM_NONNULLS",
+    {
+      minArgs: 1,
+      maxArgs: Number.POSITIVE_INFINITY,
+      returns: "number",
+      nullOnNull: false,
+      evaluate: (values) => values.filter((value) => !nullish(value)).length
+    }
+  ],
+  [
+    "NUM_NULLS",
+    {
+      minArgs: 1,
+      maxArgs: Number.POSITIVE_INFINITY,
+      returns: "number",
+      nullOnNull: false,
+      evaluate: (values) => values.filter((value) => nullish(value)).length
+    }
+  ],
+  [
+    "GCD",
+    {
+      minArgs: 2,
+      maxArgs: 2,
+      returns: "number",
+      evaluate: (values) => {
+        let a = Math.abs(integerArgument("GCD", values[0]));
+        let b = Math.abs(integerArgument("GCD", values[1]));
+        while (b !== 0)
+          [a, b] = [b, a % b];
+        return a;
+      }
+    }
+  ],
+  [
+    "LCM",
+    {
+      minArgs: 2,
+      maxArgs: 2,
+      returns: "number",
+      evaluate: (values) => {
+        const a = Math.abs(integerArgument("LCM", values[0]));
+        const b = Math.abs(integerArgument("LCM", values[1]));
+        if (a === 0 || b === 0)
+          return 0;
+        let x = a;
+        let y = b;
+        while (y !== 0)
+          [x, y] = [y, x % y];
+        const result = a / x * b;
+        if (!Number.isSafeInteger(result))
+          throw new RangeError("LCM result is out of range");
+        return result;
+      }
+    }
+  ],
+  [
+    "TO_HEX",
+    {
+      minArgs: 1,
+      maxArgs: 1,
+      returns: "string",
+      evaluate: (values) => {
+        const value = values[0];
+        if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+          throw new TypeError("TO_HEX requires an integer");
+        }
+        if (value < 0) {
+          const width = value >= -2147483648 ? 32 : 64;
+          return BigInt.asUintN(width, BigInt(value)).toString(16);
+        }
+        return BigInt(value).toString(16);
+      }
+    }
+  ],
+  [
+    "QUOTE_LITERAL",
+    {
+      minArgs: 1,
+      maxArgs: 1,
+      returns: "string",
+      evaluate: (values) => {
+        const value = values[0];
+        const rendered2 = typeof value === "string" ? value : typeof value === "number" ? String(value) : String(value);
+        const escaped = rendered2.replace(/'/g, "''");
+        return bounded(escaped.includes("\\") ? `E'${escaped.replace(/\\/g, "\\\\")}'` : `'${escaped}'`, "QUOTE_LITERAL");
+      }
+    }
+  ],
+  [
+    "QUOTE_IDENT",
+    {
+      minArgs: 1,
+      maxArgs: 1,
+      returns: "string",
+      evaluate: (values) => {
+        const name = text("QUOTE_IDENT", values[0]);
+        return /^[a-z_][a-z0-9_]*$/.test(name) ? name : bounded(`"${name.replace(/"/g, '""')}"`, "QUOTE_IDENT");
+      }
+    }
+  ],
   [
     "MINNOW_REGEX_MATCH",
     {
@@ -849,7 +973,7 @@ const simpleScalarFunctions = /* @__PURE__ */ new Map([
       minArgs: 1,
       maxArgs: 1,
       returns: "number",
-      evaluate: (values) => Math.sign(number("SIGN", values[0]))
+      evaluate: (values) => isExactNumeric(values[0]) ? exactNumericUnary("SIGN", values[0]) : Math.sign(number("SIGN", values[0]))
     }
   ],
   [
@@ -859,8 +983,10 @@ const simpleScalarFunctions = /* @__PURE__ */ new Map([
       maxArgs: 2,
       returns: "number",
       evaluate: (values) => {
-        const operand = number("TRUNC", values[0]);
         const digits = values.length > 1 ? integer("TRUNC", values[1]) : 0;
+        if (isExactNumeric(values[0]))
+          return exactNumericRounded(values[0], digits, "trunc");
+        const operand = number("TRUNC", values[0]);
         const scale = 10 ** digits;
         return Math.trunc(operand * scale) / scale;
       }

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

@@ -35,4 +35,6 @@ export declare function jsonIsValid(document: unknown, kind: string): boolean;
  * than the default. Constructors return JSON text at the JavaScript boundary.
  */
 export declare function jsonConstructor(name: "JSON_ARRAY" | "JSON_OBJECT", values: readonly unknown[]): string;
+/** to_json(x) / to_jsonb(x): one SQL value as a JSON document (a JSON-domain value as itself). */
+export declare function jsonDocumentOf(value: unknown): string;
 export {};

package/dist/engine/sql-json.js

@@ -175,6 +175,9 @@ function boundedJsonDocument(value, caller) {
   }
   return document;
 }
+function jsonDocumentOf(value) {
+  return boundedJsonValue(value ?? null, "TO_JSON value");
+}
 function boundedJsonValue(value, label) {
   const domainDocument = jsonDomainDocument(value);
   if (domainDocument !== void 0) {
@@ -215,6 +218,7 @@ export {
   jsonArrowStep,
   jsonAtPath,
   jsonConstructor,
+  jsonDocumentOf,
   jsonIsValid,
   parseJsonPath
 };

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

@@ -12,6 +12,13 @@ export declare function parseSqlTimestampText(text: string): Date | undefined;
  * comparable-types error below, so a genuine mismatch still fails.
  */
 export declare function coercedComparable(text: string, other: unknown): unknown;
+/**
+ * Reads an untyped string constant in a primitive column type, the way PostgreSQL types an
+ * unknown-typed literal by its context: a timestamp spelling for datetime, a finite number for
+ * number, `t`/`true`/`1` and `f`/`false`/`0` for boolean. Text that does not parse is returned
+ * unchanged, so the caller's own type check still reports the mismatch.
+ */
+export declare function readUntypedText(type: "datetime" | "number" | "boolean" | "string", text: string): unknown;
 /**
  * Applies the untyped-literal reading to a comparison's two operands: a plain string beside a
  * typed value (datetime, DATE, number, boolean) is read in that value's type when it parses.
@@ -29,7 +36,8 @@ export declare function compareSqlStrings(left: string, right: string): number;
 export declare function encodeSqlEqualityValue(value: unknown): readonly unknown[];
 /**
  * SQLite-compatible ROUND behavior for Minnow's finite number type: precision truncates to an
- * integer and clamps to 0..30, with ties rounded away from zero.
+ * integer and clamps to -30..30, with ties rounded away from zero. A negative precision rounds
+ * left of the decimal point as PostgreSQL does: ROUND(1250, -2) is 1300.
  */
 export declare function roundSqlNumber(value: number, precision?: number): number;
 /** A whole-string SQL pattern matcher. Unlike RegExp, test never coerces its input. */

package/dist/engine/sql-semantics.js

@@ -14,15 +14,24 @@ function parseSqlTimestampText(text) {
 }
 function coercedComparable(text, other) {
   if (other instanceof Date || isDateDomainValue(other))
+    return readUntypedText("datetime", text);
+  if (typeof other === "number")
+    return readUntypedText("number", text);
+  if (typeof other === "boolean")
+    return readUntypedText("boolean", text);
+  return text;
+}
+function readUntypedText(type, text) {
+  if (type === "datetime")
     return parseSqlTimestampText(text) ?? text;
-  if (typeof other === "number") {
+  if (type === "number") {
     const trimmed = text.trim();
     if (trimmed === "")
       return text;
     const parsed = Number(trimmed);
     return Number.isFinite(parsed) ? parsed : text;
   }
-  if (typeof other === "boolean") {
+  if (type === "boolean") {
     const lowered = text.trim().toLowerCase();
     if (lowered === "t" || lowered === "true" || lowered === "1")
       return true;
@@ -133,7 +142,13 @@ function encodeSqlEqualityValue(value) {
   throw new TypeError("Query produced an unsupported value");
 }
 function roundSqlNumber(value, precision = 0) {
-  const digits = Math.min(30, Math.max(0, Math.trunc(precision)));
+  const digits = Math.min(30, Math.max(-30, Math.trunc(precision)));
+  if (digits < 0) {
+    if (!Number.isFinite(value))
+      return value;
+    const scale = 10 ** -digits;
+    return roundSqlNumber(value / scale) * scale;
+  }
   if (digits === 0 && Number.isFinite(value)) {
     const magnitude = Math.abs(value);
     if (magnitude >= 4503599627370496)
@@ -628,6 +643,7 @@ export {
   defineSqlResultProperty,
   encodeSqlEqualityValue,
   parseSqlTimestampText,
+  readUntypedText,
   roundSqlNumber,
   stringArgument
 };

package/dist/engine/vector.js

@@ -2,15 +2,15 @@ import { dateMilliseconds } from "../date-value.js";
 import { crossJoinPlan, isCrossJoinPlan } from "../plan/model.js";
 import { MAX_TEMP_RUN_BATCH_BYTES, MAX_TEMP_RUN_PAGE_BYTES, MAX_TEMP_RUN_PAGES_PER_BATCH } from "../storage/types.js";
 import { throwIfAborted } from "./cancellation.js";
-import { cachedListMembership, childExpressions, distinctFromComparison, nullOrder, isScalarFunctionName, likeMatches, orderOutputName, parseQuantified, quantifiedComparison, scalarFunctionEvaluator, scalarFunctionValue, unknownColumnDomains } from "./query.js";
+import { cachedListMembership, childExpressions, distinctFromComparison, nullOrder, isScalarFunctionName, likeMatches, orderOutputName, parseQuantified, quantifiedComparison, scalarFunctionEvaluator, scalarFunctionValue, unknownColumnDomains, integerQuotient } from "./query.js";
 import { jsonConstructor } from "./sql-json.js";
 import { bm25DocumentScore, cachedQueryTerms, FtsStatsAccumulator, fullTermsMask, renderDocumentValue, termFrequencies, termsMask, tokenize } from "./fts.js";
 import { ByteGroupIndex } from "./group-index.js";
 import { ByteJoinIndex } from "./join-index.js";
 import { UnknownTableError } from "./errors.js";
 import { QueryMemoryBudgetError, QueryMemoryContext } from "./memory.js";
-import { coerceComparisonOperands, compareSqlValues, compileSimilarPattern, defineSqlResultProperty } from "./sql-semantics.js";
-import { concatenatedSqlValue, exactNumericBinary, externalSqlDomainValue, isDateDomainValue, isExactNumeric, preservedJsonDomainValue, protectedSqlTextValue } from "./sql-domains.js";
+import { coerceComparisonOperands, compareSqlValues, compileSimilarPattern, defineSqlResultProperty, readUntypedText } from "./sql-semantics.js";
+import { concatenatedSqlValue, exactNumericBinary, externalSqlDomainValue, isDateDomainValue, isExactNumeric, preservedJsonDomainValue, protectedSqlTextValue, isSqlDomainValue } from "./sql-domains.js";
 import { buildSortKeyColumn, sortKeyIndexes } from "./sort-keys.js";
 const DEFAULT_BATCH_ROWS = 2048;
 const MAX_SPLIT_LIST_MEMBERS = 64;
@@ -899,6 +899,7 @@ function bindExpression(expression, sources, aggregateSpecs, aggregateIndexes, m
       left: bindExpression(expression.left, sources, aggregateSpecs, aggregateIndexes, memory, ftsBySignature, ftsStats),
       right: bindExpression(expression.right, sources, aggregateSpecs, aggregateIndexes, memory, ftsBySignature, ftsStats),
       ...expression.kind === "condition" && expression.escape !== void 0 ? { escape: expression.escape } : {},
+      ...expression.kind === "binary" && expression.integer === true ? { integer: true } : {},
       signature
     };
   }
@@ -3865,7 +3866,7 @@ function evaluateFinalExpression(plan, expression, group) {
     throw new TypeError("Selected full-text expression must appear in GROUP BY");
   }
   if (expression.kind === "binary") {
-    return binaryValue(expression.operator, evaluateFinalExpression(plan, expression.left, group), evaluateFinalExpression(plan, expression.right, group));
+    return binaryValue(expression.operator, evaluateFinalExpression(plan, expression.left, group), evaluateFinalExpression(plan, expression.right, group), expression.integer === true);
   }
   if (expression.name === "COALESCE") {
     for (const argument of expression.arguments) {
@@ -4218,7 +4219,9 @@ function constantBoundExpressionValue(expression) {
     if (left === void 0 || right === void 0)
       return void 0;
     try {
-      return { value: binaryValue(expression.operator, left.value, right.value) };
+      return {
+        value: binaryValue(expression.operator, left.value, right.value, expression.integer === true)
+      };
     } catch {
       return void 0;
     }
@@ -4269,7 +4272,7 @@ function dictionaryNumericExpression(expression) {
       source: column.source,
       vector: column.vector,
       signature: expression.signature,
-      evaluate: columnFirst ? (dictionaryValue) => binaryValue(expression.operator, dictionaryValue, value) : (dictionaryValue) => binaryValue(expression.operator, value, dictionaryValue)
+      evaluate: columnFirst ? (dictionaryValue) => binaryValue(expression.operator, dictionaryValue, value, expression.integer === true) : (dictionaryValue) => binaryValue(expression.operator, value, dictionaryValue, expression.integer === true)
     };
   }
   return void 0;
@@ -4404,10 +4407,12 @@ function booleanTruth(expression, evaluateValue) {
       const distinct = distinctFromComparison(evaluateValue(expression.left), evaluateValue(expression.right));
       return operator === "IS DISTINCT FROM" ? distinct : !distinct;
     }
-    const left = evaluateValue(expression.left);
-    const right = evaluateValue(expression.right);
-    if (left === null || left === void 0 || right === null || right === void 0)
+    const evaluatedLeft = evaluateValue(expression.left);
+    const evaluatedRight = evaluateValue(expression.right);
+    if (evaluatedLeft === null || evaluatedLeft === void 0 || evaluatedRight === null || evaluatedRight === void 0) {
       return null;
+    }
+    const [left, right] = coerceComparisonOperands(evaluatedLeft, evaluatedRight);
     const a = comparable(left);
     const b = comparable(right);
     if (operator === "=")
@@ -4544,9 +4549,10 @@ function compiledBatchExpression(plan, expression) {
     }
     case "binary": {
       const operator = expression.operator;
+      const integer = expression.integer === true;
       const left = compiledBatchExpression(plan, expression.left);
       const right = compiledBatchExpression(plan, expression.right);
-      compiled = (batch, row) => binaryValue(operator, left(batch, row), right(batch, row));
+      compiled = (batch, row) => binaryValue(operator, left(batch, row), right(batch, row), integer);
       break;
     }
     case "case": {
@@ -4659,7 +4665,7 @@ function evaluateExpression(expression, rowsBySource) {
     return expression.op === "match" ? ftsBatchTruth(expression, null, rowsBySource, 0) : ftsBm25BatchValue(expression, null, rowsBySource, 0);
   }
   if (expression.kind === "binary") {
-    return binaryValue(expression.operator, evaluateExpression(expression.left, rowsBySource), evaluateExpression(expression.right, rowsBySource));
+    return binaryValue(expression.operator, evaluateExpression(expression.left, rowsBySource), evaluateExpression(expression.right, rowsBySource), expression.integer === true);
   }
   if (expression.name === "COALESCE") {
     for (const argument of expression.arguments) {
@@ -4673,7 +4679,7 @@ function evaluateExpression(expression, rowsBySource) {
     throw new TypeError(`${expression.name} requires grouped execution`);
   return scalarFunctionValue(expression.name, expression.arguments.map((argument) => evaluateExpression(argument, rowsBySource)));
 }
-function binaryValue(operator, left, right) {
+function binaryValue(operator, left, right, integer = false) {
   if (left === null || left === void 0 || right === null || right === void 0)
     return null;
   if (typeof left === "number" && typeof right === "number") {
@@ -4684,12 +4690,22 @@ function binaryValue(operator, left, right) {
     if (operator === "*")
       return left * right;
     if (operator === "/")
-      return right === 0 ? null : left / right;
+      return integer ? integerQuotient(left, right) : right === 0 ? null : left / right;
     if (operator === "%")
       return right === 0 ? null : left % right;
   }
   if (operator === "||")
     return concatenatedSqlValue(left, right);
+  if (typeof left === "string" && typeof right === "number" && !isSqlDomainValue(left)) {
+    const read = readUntypedText("number", left);
+    if (typeof read === "number")
+      return binaryValue(operator, read, right, integer);
+  }
+  if (typeof right === "string" && typeof left === "number" && !isSqlDomainValue(right)) {
+    const read = readUntypedText("number", right);
+    if (typeof read === "number")
+      return binaryValue(operator, left, read, integer);
+  }
   const exact = exactNumericBinary(operator, left, right);
   if (exact !== void 0)
     return exact;

package/dist/engine/worker-server.js

@@ -554,10 +554,13 @@ class DatabaseRpcServer {
       return handle.session.execute(sql, params);
     }
     if (method === "stage") {
-      const [op, tableName, input] = args;
+      const [op, tableName, input, options] = args;
       if (!isStageOp(op)) {
         throw new Error(`Unsupported write stage operation: ${String(op)}`);
       }
+      if (op === "upsertBatch") {
+        return handle.session.upsertBatch(tableName, input, options);
+      }
       return handle.session[op](tableName, input);
     }
     if (method === "commit")

package/dist/plan/model.d.ts

@@ -17,7 +17,7 @@ export type ComparisonOperator = "=" | "!=" | "<>" | ">" | ">=" | "<" | "<=";
 export type AggregateName = "COUNT" | "SUM" | "AVG" | "MIN" | "MAX" | "JSON_ARRAYAGG" | "STRING_AGG"
 /** Optimizer-only aggregate that enforces scalar-subquery cardinality. */
  | "MINNOW_SINGLE_VALUE";
-export type ScalarFunctionName = "ROUND" | "COALESCE" | "DATE_TRUNC" | "DATE_ADD" | "UPPER" | "LOWER" | "LENGTH" | "ABS" | "TRIM" | "LTRIM" | "RTRIM" | "SUBSTR" | "REPLACE" | "INSTR" | "NULLIF" | "GREATEST" | "LEAST" | "FLOOR" | "CEIL" | "MOD" | "POWER" | "SQRT" | "EXTRACT" | "CAST" | "OCTET_LENGTH" | "LPAD" | "RPAD" | "OVERLAY" | "CURRENT_DATE" | "CURRENT_TIMESTAMP" | "LOCALTIME" | "GROUPING" | "JSON_VALUE" | "JSON_QUERY" | "JSON_EXISTS" | "JSON_OBJECT" | "JSON_ARRAY" | "IS_JSON" | "ARRAY"
+export type ScalarFunctionName = "ROUND" | "COALESCE" | "DATE_TRUNC" | "DATE_ADD" | "UPPER" | "LOWER" | "LENGTH" | "ABS" | "TRIM" | "LTRIM" | "RTRIM" | "SUBSTR" | "REPLACE" | "INSTR" | "NULLIF" | "GREATEST" | "LEAST" | "FLOOR" | "CEIL" | "MOD" | "POWER" | "SQRT" | "EXTRACT" | "CAST" | "OCTET_LENGTH" | "LPAD" | "RPAD" | "OVERLAY" | "CURRENT_DATE" | "CURRENT_TIMESTAMP" | "LOCALTIME" | "GROUPING" | "JSON_VALUE" | "JSON_QUERY" | "JSON_EXISTS" | "JSON_OBJECT" | "JSON_ARRAY" | "TO_JSON" | "IS_JSON" | "ARRAY"
 /** Parser-produced `->` JSON member/element access returning a JSON value. */
  | "MINNOW_JSON_GET"
 /** Parser-produced `->>` JSON member/element access returning text. */
@@ -27,7 +27,7 @@ export type ScalarFunctionName = "ROUND" | "COALESCE" | "DATE_TRUNC" | "DATE_ADD
 /** Parser-produced wrapper carrying one explicit collation through ordering/comparison. */
  | "MINNOW_COLLATE" | "NEXTVAL" | "CURRVAL" | "RANDOM" | "GEN_RANDOM_UUID"
 /** Table-driven PostgreSQL string, math, datetime, regex, and formatting functions. */
- | "CONCAT" | "CONCAT_WS" | "LEFT" | "RIGHT" | "REVERSE" | "REPEAT" | "INITCAP" | "SPLIT_PART" | "STRPOS" | "STARTS_WITH" | "TRANSLATE" | "ASCII" | "CHR" | "BTRIM" | "MD5" | "FORMAT" | "REGEXP_REPLACE" | "MINNOW_REGEX_MATCH" | "EXP" | "LN" | "LOG" | "LOG10" | "SIGN" | "TRUNC" | "PI" | "CBRT" | "DIV" | "WIDTH_BUCKET" | "SIN" | "COS" | "TAN" | "ASIN" | "ACOS" | "ATAN" | "ATAN2" | "DEGREES" | "RADIANS" | "TO_CHAR" | "TO_DATE" | "TO_TIMESTAMP" | "MAKE_DATE" | "MAKE_TIMESTAMP" | "AGE";
+ | "CONCAT" | "CONCAT_WS" | "LEFT" | "RIGHT" | "REVERSE" | "REPEAT" | "INITCAP" | "SPLIT_PART" | "STRPOS" | "STARTS_WITH" | "TRANSLATE" | "ASCII" | "CHR" | "BTRIM" | "MD5" | "REGEXP_SUBSTR" | "NUM_NONNULLS" | "NUM_NULLS" | "GCD" | "LCM" | "TO_HEX" | "QUOTE_LITERAL" | "QUOTE_IDENT" | "FORMAT" | "REGEXP_REPLACE" | "MINNOW_REGEX_MATCH" | "EXP" | "LN" | "LOG" | "LOG10" | "SIGN" | "TRUNC" | "PI" | "CBRT" | "DIV" | "WIDTH_BUCKET" | "SIN" | "COS" | "TAN" | "ASIN" | "ACOS" | "ATAN" | "ATAN2" | "DEGREES" | "RADIANS" | "TO_CHAR" | "TO_DATE" | "TO_TIMESTAMP" | "MAKE_DATE" | "MAKE_TIMESTAMP" | "AGE";
 /** Exact BM25 corpus statistics attached to a cloned scoring node before execution. */
 export interface FtsStats {
     /** Every row of the corpus, including all-null documents. */
@@ -50,6 +50,12 @@ export type Expression = {
      * PostgreSQL types every decimal constant NUMERIC before evaluating it.
      */
     exactText?: string;
+    /**
+     * Written with a decimal point or exponent, or folded from such a constant: PostgreSQL
+     * types it NUMERIC, so it is never an integer operand even when its value is whole
+     * (`7 / 2.0` is 3.5 where `7 / 2` is 3).
+     */
+    decimal?: true;
 }
 /** A `?` or `$n` placeholder; `index` is 0-based. Replaced by a literal at bind time. */
  | {
@@ -68,6 +74,12 @@ export type Expression = {
     operator: BinaryOperator;
     left: Expression;
     right: Expression;
+    /**
+     * Integer division: both operands are integer-typed, so `/` truncates toward zero as
+     * PostgreSQL's integer `/` does. Set by the compiler for constants and by catalog
+     * binding for columns; absent, `/` is ordinary Float64 or exact-NUMERIC division.
+     */
+    integer?: true;
 } | {
     kind: "call";
     name: AggregateName | ScalarFunctionName;

package/dist/storage/indexeddb.js

@@ -3919,7 +3919,12 @@ class IndexedDbBlockStore {
         await assertActiveGarbageCollectionMarker(gcStore, current);
       }
       const updated = updateGarbageCollectionPlanningRecord(current, input);
-      await assertGarbageCollectionCandidateProvenanceInTransaction(transaction, updated);
+      await assertGarbageCollectionCandidateProvenanceInTransaction(transaction, {
+        candidateManifestVersions: input.candidateManifestVersions ?? [],
+        candidateSegmentIds: input.candidateSegmentIds ?? [],
+        candidateBlockIds: input.candidateBlockIds ?? [],
+        candidateTransactionIds: input.candidateTransactionIds ?? []
+      });
       gcStore.put(garbageCollectionJobEnvelope(updated), key);
       await transactionDone(transaction);
       return structuredClone(updated);
@@ -9717,15 +9722,15 @@ function assertGenericTransactionUpdateAllowed(record, update) {
     throw new TypeError("Only commitTransaction can set a committed transaction version");
   }
 }
-async function assertGarbageCollectionCandidateProvenanceInTransaction(transaction, job) {
+async function assertGarbageCollectionCandidateProvenanceInTransaction(transaction, candidates) {
   const manifestStore = transaction.objectStore("manifests");
-  for (const version of job.candidateManifestVersions) {
+  for (const version of candidates.candidateManifestVersions) {
     const value = await requestResult(manifestStore.get(version));
     if (value === void 0) {
       throw new Error(`Garbage collection candidate manifest is missing: ${String(version)}`);
     }
   }
-  for (const id of job.candidateTransactionIds) {
+  for (const id of candidates.candidateTransactionIds) {
     const value = await requestResult(transaction.objectStore("transactions").get(id));
     const record = value === void 0 ? void 0 : asTransactionRecord(value);
     if (record === void 0 || record.status !== "aborted" && (record.status !== "committed" || record.committedVersion === null)) {
@@ -9733,10 +9738,10 @@ async function assertGarbageCollectionCandidateProvenanceInTransaction(transacti
     }
   }
   const manifestProvenBlockIds = /* @__PURE__ */ new Set();
-  const manifestValues = await Promise.all(job.candidateBlockIds.map((id) => requestResult(transaction.objectStore("catalog").get(manifestBlockKey(id)))));
+  const manifestValues = await Promise.all(candidates.candidateBlockIds.map((id) => requestResult(transaction.objectStore("catalog").get(manifestBlockKey(id)))));
   for (const [index, value] of manifestValues.entries()) {
     if (value !== void 0) {
-      const id = job.candidateBlockIds[index] ?? "";
+      const id = candidates.candidateBlockIds[index] ?? "";
       asManifestBlockRecord(value, id);
       manifestProvenBlockIds.add(id);
     }
@@ -9757,12 +9762,12 @@ async function assertGarbageCollectionCandidateProvenanceInTransaction(transacti
       return isTerminalCompactionJob(record) && (record.sourceBlockIds.includes(id) || record.outputBlockIds.includes(id));
     });
   };
-  for (const id of job.candidateBlockIds) {
+  for (const id of candidates.candidateBlockIds) {
     if (await blockHasProvenance(id))
       continue;
     throw new Error(`Garbage collection block candidate has no persisted provenance: ${id}`);
   }
-  for (const id of job.candidateSegmentIds) {
+  for (const id of candidates.candidateSegmentIds) {
     const segmentValue = await requestResult(transaction.objectStore("segments").get(id));
     if (segmentValue !== void 0)
       continue;

package/dist/storage/memory.d.ts

@@ -3,7 +3,8 @@ import { type BeginSnapshotFrameExportInput, type SnapshotFrameExportSession, ty
  * The in-process store: record semantics live in `RecordCore` (shared with the OPFS store),
  * block and temp-page bytes live in Maps here, and atomicity comes from running every mutating
  * record operation on a promise-chain queue — each queued body is synchronous, so no operation
- * ever observes another mid-mutation.
+ * ever observes another mid-mutation. Every commit acknowledges on the next event-loop turn
+ * (`commitTurn`), so a write loop yields to background work as it would on disk.
  */
 export declare class MemoryBlockStore implements BlockStore {
     #private;