@minnowdb/core 0.6.5 → 0.6.6

package/dist/engine/sort-keys.d.ts

@@ -19,7 +19,7 @@
  * next, so what a multi-term sort pays for its later terms is proportional to how many rows tie
  * on the earlier ones.
  */
-export interface SortKeyColumn {
+interface SortKeyColumn {
     /**
      * Ascending comparison with NULL smallest. This is the column's raw comparison, not SQL's
      * default placement: the sorter applies PostgreSQL's NULLS LAST for ASC and NULLS FIRST for
@@ -45,8 +45,6 @@ export interface SortKeyTerm {
     readonly descending: boolean;
     readonly nulls: "first" | "last" | undefined;
 }
-/** Unwraps a datetime to the number the comparisons use; every other value passes through. */
-export declare function comparableSortValue(value: unknown): unknown;
 /**
  * Extracts one term's values into a comparison-ready column. `valueAt` is called once per row,
  * so a caller that reads through a row object or a vector pays that cost once rather than once
@@ -72,3 +70,4 @@ export declare function buildSortKeyColumn(count: number, valueAt: (index: numbe
  * is already in order before doing anything else, since a scan often arrives sorted.
  */
 export declare function sortKeyIndexes(count: number, terms: readonly SortKeyTerm[]): Uint32Array;
+export {};

package/dist/engine/sort-keys.js

@@ -1,7 +1,7 @@
 import { dateMilliseconds } from "../date-value.js";
 import { compareSqlStrings, compareSqlValues } from "./sql-semantics.js";
 /** Unwraps a datetime to the number the comparisons use; every other value passes through. */
-export function comparableSortValue(value) {
+function comparableSortValue(value) {
     return value instanceof Date ? dateMilliseconds(value) : value;
 }
 /**

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

@@ -9,7 +9,24 @@ export declare function protectedSqlTextValue(value: string): string;
 export declare function externalSqlTextValue(value: unknown): unknown;
 export declare function isExactNumeric(value: unknown): value is string;
 export declare function exactNumericValue(value: unknown, precision?: number, scale?: number): string | null;
-export declare function exactNumericBinary(operator: "+" | "-" | "*" | "/" | "%", left: unknown, right: unknown): string | null | undefined;
+/**
+ * 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 declare function exactNumericLiteral(text: string): string;
+/**
+ * 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 declare function exactNumericAsNumber(value: string): number | undefined;
+export declare function exactNumericBinary(operator: "+" | "-" | "*" | "/" | "%", left: unknown, right: unknown, minimumQuotientScale?: number, canonicalize?: boolean): string | null | undefined;
 export declare function exactNumericCompare(left: unknown, right: unknown): number | undefined;
 /**
  * Serializes a JSON value while bounding traversal, nesting, and output before concatenation.
@@ -33,7 +50,6 @@ export declare function isDateDomainValue(value: unknown): value is string;
 export declare function timeDomainValue(value: unknown): string | null;
 export declare function intervalDomainValue(value: unknown): string | null;
 export declare function arrayDomainValue(values: readonly unknown[]): string;
-export declare function enumDomainValue(value: unknown, name: string, values: readonly string[]): string | null;
 export declare function enumDomainCompare(left: unknown, right: unknown): number | undefined;
 export declare function normalizeSqlDomainValue(domain: SqlDomain, value: unknown): string | null;
 export declare function collatedDomainValue(value: unknown, collation: unknown): string | null;
@@ -48,4 +64,13 @@ export declare function collatedDomainCompare(left: unknown, right: unknown): nu
  */
 export declare function externalSqlDomainColumnValue(value: unknown, domain: SqlDomain | null | undefined): unknown;
 export declare function externalSqlDomainValue(value: unknown): unknown;
+/**
+ * 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 declare function concatenatedSqlValue(left: string, right: string): string;
 export declare function isSqlDomainValue(value: unknown): value is string;

package/dist/engine/sql-domains.js

@@ -53,6 +53,9 @@ function decimalParts(value) {
     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;
     }
@@ -122,7 +125,79 @@ export function exactNumericValue(value, precision, scale) {
     }
     return boundedTaggedDomainValue(NUMERIC, formatDecimal(normalizeDecimal(adjusted)), "NUMERIC value");
 }
-export function exactNumericBinary(operator, left, right) {
+/**
+ * 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.
+ */
+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)),
+    };
+}
+/**
+ * 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)
@@ -149,9 +224,10 @@ export function exactNumericBinary(operator, left, right) {
         };
     }
     else {
-        // PostgreSQL NUMERIC division is arbitrary precision. Twenty fractional digits gives a
-        // deterministic exact decimal rounding boundary without ever crossing binary Float64.
-        const scale = Math.max(20, a.scale, b.scale);
+        // 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;
@@ -162,7 +238,7 @@ export function exactNumericBinary(operator, left, right) {
         }
         result = { coefficient, scale };
     }
-    return boundedTaggedDomainValue(NUMERIC, formatDecimal(normalizeDecimal(result)), "NUMERIC result");
+    return boundedTaggedDomainValue(NUMERIC, formatDecimal(canonicalize ? normalizeDecimal(result) : result), "NUMERIC result");
 }
 export function exactNumericCompare(left, right) {
     const leftTagged = taggedDecimalParts(left);
@@ -470,7 +546,7 @@ export function intervalDomainValue(value) {
 export function arrayDomainValue(values) {
     return boundedTaggedDomainValue(ARRAY_VALUE, boundedJsonText(values.map(externalSqlDomainValue), true, "ARRAY value"), "ARRAY value");
 }
-export function enumDomainValue(value, name, values) {
+function enumDomainValue(value, name, values) {
     if (value === null || value === undefined)
         return null;
     if (typeof value !== "string")
@@ -667,6 +743,44 @@ export function externalSqlDomainValue(value) {
     }
     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);
 }

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

@@ -29,8 +29,6 @@ export declare function jsonArrowStep(document: unknown, key: unknown, caller: s
 };
 /** Whether a value is JSON text of the requested shape (T825). */
 export declare function jsonIsValid(document: unknown, kind: string): boolean;
-/** A SQL value as its JSON counterpart: datetimes serialize as ISO text, like every cast. */
-export declare function jsonValueOf(value: unknown): unknown;
 /**
  * JSON_ARRAY(v, ...) and JSON_OBJECT(k, v, ...) (T811/T812). The omitted null-handling clause is
  * `NULL ON NULL`: SQL NULL becomes a JSON null. `ABSENT ON NULL` is a separate spelling rather

package/dist/engine/sql-json.js

@@ -143,7 +143,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) {
+function jsonValueOf(value) {
     const external = externalSqlDomainValue(value);
     return external instanceof Date ? dateIsoString(external) : external;
 }

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

@@ -19,7 +19,7 @@ export declare function encodeSqlEqualityValue(value: unknown): readonly unknown
  */
 export declare function roundSqlNumber(value: number, precision?: number): number;
 /** A whole-string SQL pattern matcher. Unlike RegExp, test never coerces its input. */
-export interface SqlPatternMatcher {
+interface SqlPatternMatcher {
     test(value: string): boolean;
 }
 /** Compiles SQL LIKE without exposing input to the host regular-expression engine. */
@@ -34,3 +34,4 @@ 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;
+export {};

package/dist/engine/vector.d.ts

@@ -2,7 +2,7 @@ import type { DatabaseRow } from "./database.js";
 import type { CompiledQuery, QueryResult, QueryValue } from "./query.js";
 import { type FtsStats } from "./fts.js";
 import { QueryMemoryContext, type QueryMemoryUsage } from "./memory.js";
-export type VectorType = "boolean" | "number" | "string" | "datetime";
+type VectorType = "boolean" | "number" | "string" | "datetime";
 /**
  * A resident slice of a logically longer streamed column. Window arrays index rows relative to
  * `start`; `length` on the vector remains the logical table length.
@@ -16,25 +16,25 @@ interface VectorBase {
     readonly length: number;
     readonly window?: VectorWindow;
 }
-export interface BooleanVector extends VectorBase {
+interface BooleanVector extends VectorBase {
     readonly kind: "boolean";
     readonly values: Uint8Array;
 }
-export interface NumberVector extends VectorBase {
+interface NumberVector extends VectorBase {
     readonly kind: "number";
     readonly values: Float64Array;
 }
-export interface DateTimeVector extends VectorBase {
+interface DateTimeVector extends VectorBase {
     readonly kind: "datetime";
     readonly values: Float64Array;
 }
-export interface StringVector extends VectorBase {
+interface StringVector extends VectorBase {
     readonly kind: "string";
     readonly codes: Uint32Array;
     readonly dictionary: readonly string[];
 }
 export type ColumnVector = BooleanVector | NumberVector | DateTimeVector | StringVector;
-export interface ColumnarColumnInput {
+interface ColumnarColumnInput {
     readonly type: VectorType;
     readonly values: readonly QueryValue[];
 }
@@ -91,7 +91,7 @@ export interface QueryBatchExecutionOptions extends AsyncQueryExecutionOptions {
     /** Maximum result rows handed to the consumer at once. */
     readonly batchRows: number;
 }
-export interface PrepareVectorQueryOptions {
+interface PrepareVectorQueryOptions {
     readonly memoryContext?: QueryMemoryContext;
     /**
      * Exact BM25 corpus statistics served by the persisted full-text index, keyed by each

package/dist/engine/vector.js

@@ -9,7 +9,7 @@ import { ByteJoinIndex } from "./join-index.js";
 import { UnknownTableError } from "./errors.js";
 import { QueryMemoryBudgetError, QueryMemoryContext, } from "./memory.js";
 import { compareSqlValues, compileSimilarPattern, defineSqlResultProperty, } from "./sql-semantics.js";
-import { exactNumericBinary, externalSqlDomainValue, isDateDomainValue, isExactNumeric, preservedJsonDomainValue, protectedSqlTextValue, } from "./sql-domains.js";
+import { concatenatedSqlValue, exactNumericBinary, externalSqlDomainValue, isDateDomainValue, isExactNumeric, preservedJsonDomainValue, protectedSqlTextValue, } from "./sql-domains.js";
 import { buildSortKeyColumn, sortKeyIndexes } from "./sort-keys.js";
 const DEFAULT_BATCH_ROWS = 2_048;
 /** Above this, locating each IN member separately costs more than scanning between them. */
@@ -892,6 +892,9 @@ function bindExpression(expression, sources, aggregateSpecs, aggregateIndexes, m
             ...(expression.distinct === true ? { distinct: true } : {}),
             ...(rawDatetime === undefined ? {} : { rawDatetime }),
             ...(rawNumber === undefined ? {} : { rawNumber }),
+            ...(expression.avgArgumentScale === undefined
+                ? {}
+                : { avgScale: expression.avgArgumentScale }),
         });
     }
     return {
@@ -4029,8 +4032,9 @@ function evaluateFinalExpression(plan, expression, group) {
     if (expression.name === "SUM")
         return isExactNumeric(value) ? value : (group.sums[aggregateIndex] ?? 0);
     if (expression.name === "AVG") {
-        if (isExactNumeric(value))
-            return exactNumericBinary("/", value, count);
+        if (isExactNumeric(value)) {
+            return exactNumericBinary("/", value, count, plan.aggregates[aggregateIndex]?.avgScale);
+        }
         return (group.sums[aggregateIndex] ?? 0) / count;
     }
     // Raw-millisecond datetime extremes re-box into a Date only here, once per surviving group.
@@ -4764,7 +4768,7 @@ function binaryValue(operator, left, right) {
         if (typeof left !== "string" || typeof right !== "string") {
             throw new TypeError("|| requires string operands");
         }
-        return protectedSqlTextValue(String(externalSqlDomainValue(left)) + String(externalSqlDomainValue(right)));
+        return concatenatedSqlValue(left, right);
     }
     const exact = exactNumericBinary(operator, left, right);
     if (exact !== undefined)

package/dist/engine/write-block-planner.d.ts

@@ -4,7 +4,7 @@ export interface WriteColumnValues {
     readonly values: readonly unknown[];
     readonly stringByteLengths?: readonly number[];
 }
-export interface WriteBlockRange {
+interface WriteBlockRange {
     readonly start: number;
     readonly end: number;
 }
@@ -16,3 +16,4 @@ export interface WriteBlockRange {
 export declare function planAlignedWriteBlockRanges(columns: readonly WriteColumnValues[], rowCount: number, maximumRows: number, targetBytes: number, measureString?: (value: string) => number): WriteBlockRange[];
 /** Conservative first estimate used by both physical compaction planners. */
 export declare function estimateCompactionRowsPerOutput(targetBlockBytes: number, maximumEncodedBytesPerRow: number): number;
+export {};

package/dist/plan/model.d.ts

@@ -40,6 +40,14 @@ export type Expression = {
     value: QueryValue;
     internalSqlValue?: true;
     sqlDomain?: SqlDomain;
+    /**
+     * A numeric constant's exact source digits, kept when the value survives the number
+     * boundary but the spelling carries more (`1.000000000000000000000000` is the number 1
+     * with display scale 24).
+     * Constant folding reads these so seeded arithmetic runs in exact decimal space, the way
+     * PostgreSQL types every decimal constant NUMERIC before evaluating it.
+     */
+    exactText?: string;
 }
 /** A `?` or `$n` placeholder; `index` is 0-based. Replaced by a literal at bind time. */
  | {
@@ -68,6 +76,13 @@ export type Expression = {
         direction: "asc" | "desc";
         nulls?: "first" | "last";
     }>;
+    /**
+     * AVG over a declared-scale NUMERIC column: the argument's declared scale, annotated by a
+     * schema-aware pass before execution. PostgreSQL floors its quotient scale at the summed
+     * operand's display scale; canonical NUMERIC encoding strips trailing zeros, so without
+     * this the internal division cannot know the digits the declared scale will render.
+     */
+    avgArgumentScale?: number;
 } | {
     kind: "list";
     items: Expression[];

package/dist/storage/opfs/leader.d.ts

@@ -4,8 +4,6 @@ import { type Placement } from "../toolkit/extents.js";
 /** A failed checkpoint may defer compaction, but the recovery log itself stays bounded. */
 export declare const MAX_OPFS_WAL_BYTES: number;
 export declare const MAX_OPFS_CHECKPOINT_BYTES: number;
-/** Failed physical reclamation cannot permit byte-growing work forever. */
-export declare const MAX_OPFS_CLEANUP_DEBT_BYTES: number;
 interface IdPlacement {
     id: string;
     placement: Placement;
@@ -459,6 +457,4 @@ export declare class OpfsLeader {
 export declare function assertBlockReadBatchByteLimit(placements: ReadonlyArray<{
     length: number;
 } | undefined>): void;
-/** Conservative retained-heap model for one decoded postings chunk and its nested arrays. */
-export declare function modeledFtsChunkBytes(chunk: readonly FtsPosting[]): number;
 export {};

package/dist/storage/opfs/leader.js

@@ -17,7 +17,7 @@ const CHECKPOINT_ENTRIES = 1024;
 export const MAX_OPFS_WAL_BYTES = 256 * 1024 * 1024;
 export const MAX_OPFS_CHECKPOINT_BYTES = 256 * 1024 * 1024;
 /** Failed physical reclamation cannot permit byte-growing work forever. */
-export const MAX_OPFS_CLEANUP_DEBT_BYTES = 64 * 1024 * 1024;
+const MAX_OPFS_CLEANUP_DEBT_BYTES = 64 * 1024 * 1024;
 /** Decoded full-text base cache: bounded primarily by modeled retained heap, count secondarily. */
 const FTS_CHUNK_CACHE_BYTES = 16 * 1024 * 1024;
 const FTS_CHUNK_CACHE_SIZE = 64;
@@ -5035,7 +5035,7 @@ function samePlacement(left, right) {
         left.checksum === right.checksum);
 }
 /** Conservative retained-heap model for one decoded postings chunk and its nested arrays. */
-export function modeledFtsChunkBytes(chunk) {
+function modeledFtsChunkBytes(chunk) {
     let bytes = 64;
     for (const posting of chunk) {
         bytes += 64 + posting.term.length * 2 + posting.rowIds.length * 40;

package/dist/storage/opfs/snapshot-ledger.d.ts

@@ -1,8 +1,8 @@
 import { type SnapshotFrame, type SnapshotFrameKind } from "../types.js";
 import { type Placement } from "../toolkit/extents.js";
 import { OpfsTree } from "./files.js";
-export type SnapshotLedgerKind = "export" | "import" | "completed";
-export interface SnapshotLedgerRecord {
+type SnapshotLedgerKind = "export" | "import" | "completed";
+interface SnapshotLedgerRecord {
     readonly sequence: number;
     readonly kind: SnapshotFrameKind;
     readonly itemCount: number;
@@ -38,3 +38,4 @@ export declare class SnapshotFrameLedger {
     adoptLength(length: number): void;
     close(): void;
 }
+export {};

package/dist/storage/toolkit/index.d.ts

@@ -26,4 +26,4 @@ export { readFully, writeFully, type SyncFileHandle } from "./sync-file.js";
 export { RecordCore, type PhysicalBlocks, type RecordCoreState } from "./record-core.js";
 export { MAX_WAL_FRAME_BYTES, WalWriter, iterateWalFrames, replayWalFrames, type ReplayedWalFrame, } from "./wal.js";
 export { ExtentPool, assertValidExtentMeta, assertValidPlacement, extentPath, validPlacement, type ExtentBatchMark, type ExtentFiles, type ExtentMeta, type ExtentPoolOptions, type Placement, } from "./extents.js";
-export { LOG_FORMAT_VERSION, decodeChunk, decodePostingChunk, decodeRecordJson, decodeSyncCheckpoint, encodeChunk, encodePostingChunk, encodeRecordJson, encodeSyncCheckpoint, } from "./wire.js";
+export { LOG_FORMAT_VERSION, decodeChunk, decodePostingChunk, decodeRecordJson, decodeSyncCheckpoint, encodeChunk, encodePostingChunk, encodeRecordJson, encodeSyncCheckpoint, type PostingChunkEntry, } from "./wire.js";

package/dist/storage/toolkit/record-core.d.ts

@@ -373,7 +373,6 @@ export declare function validateFtsPostingChunks(chunks: unknown, label: string)
 export declare function validateSegmentRuntimeRecord(value: unknown, label: string): SegmentRecord;
 export declare function validateAutoIncrementReservation(count: number, atLeast: bigint | undefined): void;
 export declare function validateBeginTransactionInput(input: BeginTransactionInput): void;
-export declare function validateLeaseExpiration(expiresAt: string): void;
 export declare function validateTempRunPage(page: TempRunPage): void;
 export declare function validateTempRunPageIdentity(ownerId: string, runId: string, pageIndex: number): void;
 export {};

package/dist/storage/toolkit/record-core.js

@@ -6382,13 +6382,6 @@ function validateTempOwnerRecord(record) {
         throw new RangeError("Temp owner record must be created at revision zero");
     }
 }
-export function validateLeaseExpiration(expiresAt) {
-    if (typeof expiresAt !== "string" ||
-        expiresAt.length === 0 ||
-        !Number.isFinite(Date.parse(expiresAt))) {
-        throw new TypeError("Lease expiration must be valid");
-    }
-}
 function isCanonicalTimestamp(value) {
     const timestamp = Date.parse(value);
     return Number.isFinite(timestamp) && dateIsoString(new Date(timestamp)) === value;

package/dist/testing/opfs-shim.d.ts

@@ -21,7 +21,7 @@
  * toolkit's `SyncFileHandle` surface, in plain vitest, with crashes and quota failures on tap.
  */
 export type WriteFault = (path: string, phase: "create" | "write" | "flush") => void;
-export type DeleteFault = (path: string) => void;
+type DeleteFault = (path: string) => void;
 export type TransferLimit = (path: string, operation: "read" | "write", requestedBytes: number, at: number) => number | undefined;
 export declare class MemoryOpfs {
     #private;
@@ -43,3 +43,4 @@ export declare class MemoryOpfs {
     /** Test-side in-place corruption: existing sync handles observe the changed byte. */
     corruptFileByte(path: string, offset: number): void;
 }
+export {};

package/dist/testing/simulator.js

@@ -572,6 +572,9 @@ function summarizeCollection(result) {
         retainedTransactions: result.retainedTransactionCount,
     };
 }
+// Stream-identical copy of `mulberry32` in ./seeds.ts. This module ships in the tarball and
+// seeds.ts does not (it reads MINNOW_SEED and the unpublished regression-seeds.json), so the
+// published simulator cannot import the canonical copy.
 function mulberry32(seed) {
     let state = seed >>> 0;
     return () => {

package/dist/worker-protocol/index.d.ts

@@ -1,7 +1,7 @@
 export declare const protocolVersion: 3;
 /** Outstanding request/response pairs retained by either side of one database RPC connection. */
 export declare const MAX_DATABASE_RPC_IN_FLIGHT = 256;
-export type WorkerOperation = "benchmark" | "cancelBenchmark" | "memorySample" | "datasetList" | "datasetCreate" | "datasetDelete" | "runQuery" | "suiteReference" | "suiteWrite" | "suiteFeatureMatrix" | "suiteLive";
+export type WorkerOperation = "benchmark" | "cancelBenchmark" | "datasetList" | "datasetCreate" | "datasetDelete" | "runQuery" | "suiteReference" | "suiteWrite" | "suiteFeatureMatrix" | "suiteLive";
 export interface WorkerRequest<T = unknown> {
     version: typeof protocolVersion;
     requestId: string;

package/dist/worker-protocol/index.js

@@ -105,7 +105,6 @@ function isOperation(value) {
     return [
         "benchmark",
         "cancelBenchmark",
-        "memorySample",
         "datasetList",
         "datasetCreate",
         "datasetDelete",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "description": "A columnar SQL database for the browser: PostgreSQL-style SQL over durable IndexedDB or OPFS data, with no server or WebAssembly module.",
   "license": "MIT",
   "author": "Eric Wilhite",
@@ -125,6 +125,7 @@
     "!dist/storage/fixture-shape.*",
     "!dist/engine/storage-test-helpers.*",
     "!dist/testing/seeds.*",
+    "!dist/testing/oracle.*",
     "!dist/*.tsbuildinfo",
     "sql-feature-matrix.json",
     "postgres-feature-profile.json"

package/postgres-feature-profile.json

@@ -111,7 +111,7 @@
     {
       "id": "function.string-extended",
       "classification": "different",
-      "reason": "The bundled form includes INSTR; PostgreSQL spells that function strpos with reversed arguments."
+      "reason": "The bundled form includes INSTR; PostgreSQL has no INSTR and spells the same (string, substring) lookup STRPOS, with the arguments in the same order."
     },
     {
       "id": "function.trim-multi-character",
@@ -134,10 +134,15 @@
       "classification": "different",
       "reason": "Both engines accept the correlated JSON aggregate and agree on its JSON value, but Minnow returns JSON text while PostgreSQL returns a native JSON value."
     },
+    {
+      "id": "literal.scientific",
+      "classification": "different",
+      "reason": "PostgreSQL types every scientific-notation constant NUMERIC and renders it as text. Minnow evaluates it exactly but returns a number whenever the value reads back identically from one, keeping ordinary constants number-typed at the JavaScript boundary; a constant that stays exact renders fully expanded, as PostgreSQL renders it."
+    },
     {
       "id": "type.exact-numeric",
       "classification": "different",
-      "reason": "Minnow preserves exact decimals at the JavaScript boundary as strings; PGlite's default decoder returns this NUMERIC value as a number. A declared scale renders at exactly that scale as PostgreSQL does; a bare NUMERIC column, a derived arithmetic result, and a value cast or concatenated to text render canonically, without the trailing fractional zeros PostgreSQL preserves. A non-terminating AVG quotient renders at Minnow's internal precision, which keeps more fractional digits than PostgreSQL's rounding; the value agrees to every digit PostgreSQL renders."
+      "reason": "Minnow preserves exact decimals at the JavaScript boundary as strings, as PGlite's default decoder also does. A declared scale renders at exactly that scale as PostgreSQL does; a bare NUMERIC column, a derived arithmetic result, and a value cast or concatenated to text render canonically, without the trailing fractional zeros PostgreSQL preserves. Division and AVG select their result scale the way PostgreSQL does, so quotient digits agree — including AVG over a column whose declared scale exceeds the selection. The canonical encoding does drop a stored value's display scale, so an explicit arithmetic quotient (such as SUM(v) / COUNT(v)) over a column declared with more than about twenty fractional digits can carry fewer digits than PostgreSQL, which floors the selection at the operand's display scale. An arithmetic or comparison expression mixing a float column with a constant Float64 cannot represent stays exact, where PostgreSQL casts the constant to float8 and rounds it before evaluating."
     },
     {
       "id": "type.json-jsonb",
@@ -182,7 +187,7 @@
     {
       "id": "json.array",
       "classification": "different",
-      "reason": "The JSON value agrees, but Minnow returns compact JSON text while PostgreSQL's text rendering includes spaces."
+      "reason": "Minnow defaults JSON_ARRAY to NULL ON NULL, so a NULL argument becomes a JSON null where PostgreSQL's ABSENT ON NULL default drops it; Minnow also returns compact JSON text while PostgreSQL's rendering includes spaces."
     },
     {
       "id": "trigger.create-after",