@minnowdb/core 0.6.4 → 0.6.6

package/dist/engine/artifact-cache.d.ts

@@ -1,5 +1,5 @@
 /** Snapshot of the byte-bounded artifact cache's lifetime counters. */
-export interface ArtifactCacheStats {
+interface ArtifactCacheStats {
     limitBytes: number;
     usedBytes: number;
     entries: number;
@@ -26,3 +26,4 @@ export declare class ArtifactCache {
     clear(): void;
     stats(): ArtifactCacheStats;
 }
+export {};

package/dist/engine/batch.d.ts

@@ -31,6 +31,5 @@ export interface ColumnarBatch {
 }
 /** What `insertBatch` and `upsertBatch` take: rows, or columns for a bulk load. */
 export type InsertBatchInput = readonly BatchRow[] | ColumnarBatch;
-export declare function isColumnarBatch(input: InsertBatchInput): input is ColumnarBatch;
 /** Pivots rows into the engine's columnar form; a columnar batch passes straight through. */
 export declare function toColumnarBatch(input: InsertBatchInput): ColumnarBatch;

package/dist/engine/batch.js

@@ -6,7 +6,7 @@
  * This module deliberately has no imports: the main-thread client normalizes here too, and must
  * not pull the engine in behind it.
  */
-export function isColumnarBatch(input) {
+function isColumnarBatch(input) {
     return !Array.isArray(input);
 }
 /** Pivots rows into the engine's columnar form; a columnar batch passes straight through. */

package/dist/engine/buffered-writer.js

@@ -1,4 +1,5 @@
 import { copyDate } from "../date-value.js";
+import { estimateRowBytes } from "./byte-estimates.js";
 /** Maximum accepted `add()` calls that have not completed. Callers must await for backpressure. */
 export const MAX_BUFFERED_WRITER_PENDING_ADDS = 64;
 /** Batches row-oriented writes by row count, estimated bytes, or age. */
@@ -169,15 +170,3 @@ function cloneRow(row) {
         value instanceof Date ? copyDate(value) : value,
     ]));
 }
-function estimateRowBytes(row) {
-    let bytes = 0;
-    for (const value of Object.values(row)) {
-        if (typeof value === "string")
-            bytes += 4 + value.length;
-        else if (typeof value === "number" || value instanceof Date)
-            bytes += 8;
-        else
-            bytes += 1;
-    }
-    return bytes;
-}

package/dist/engine/byte-estimates.d.ts

@@ -0,0 +1,11 @@
+import type { ColumnarBatch } from "./batch.js";
+/**
+ * The one modeled per-value size used for flush thresholds, cache accounting, and write
+ * metrics. One byte per UTF-16 code unit approximates the UTF-8 payload (exact for ASCII)
+ * without encoding the string just to measure it — this estimate feeds metrics and flush
+ * thresholds, not the physical format. Keeping a single implementation keeps those
+ * accountings from drifting apart.
+ */
+export declare function estimateValuesBytes(values: readonly unknown[]): number;
+export declare function estimateRowBytes(row: Readonly<Record<string, unknown>>): number;
+export declare function estimateBatchBytes(input: ColumnarBatch): number;

package/dist/engine/byte-estimates.js

@@ -0,0 +1,25 @@
+/**
+ * The one modeled per-value size used for flush thresholds, cache accounting, and write
+ * metrics. One byte per UTF-16 code unit approximates the UTF-8 payload (exact for ASCII)
+ * without encoding the string just to measure it — this estimate feeds metrics and flush
+ * thresholds, not the physical format. Keeping a single implementation keeps those
+ * accountings from drifting apart.
+ */
+export function estimateValuesBytes(values) {
+    let bytes = 0;
+    for (const value of values) {
+        if (typeof value === "string")
+            bytes += 4 + value.length;
+        else if (typeof value === "number" || value instanceof Date)
+            bytes += 8;
+        else
+            bytes += 1;
+    }
+    return bytes;
+}
+export function estimateRowBytes(row) {
+    return estimateValuesBytes(Object.values(row));
+}
+export function estimateBatchBytes(input) {
+    return Object.values(input.columns).reduce((total, values) => total + estimateValuesBytes(values), 0);
+}

package/dist/engine/database.js

@@ -1,5 +1,6 @@
 import { toColumnarBatch, } from "./batch.js";
 import { ArtifactCache } from "./artifact-cache.js";
+import { estimateBatchBytes, estimateRowBytes, estimateValuesBytes } from "./byte-estimates.js";
 import { throwIfAborted } from "./cancellation.js";
 import { BufferedTableWriter } from "./buffered-writer.js";
 export { attachLifecycleFlush, BufferedTableWriter, MAX_BUFFERED_WRITER_PENDING_ADDS, } from "./buffered-writer.js";
@@ -14,13 +15,13 @@ import { cachedQueryTerms, FTS_TOKENIZER_VERSION, renderDocumentValue, tokenize
 import { boundedMaintenanceBatchItems, simpleDataTypes, floorWholeNumberProduct, BlockReadBatchTooLargeError, validateColumnDefault, validateEnumValues, secondaryIndexColumnIds, secondaryIndexDirections, secondaryUniqueKeyNamespace, CompactionJobConflictError, CompactionBacklogError, GarbageCollectionJobConflictError, MAX_LEVEL_ZERO_SEGMENTS, MAX_FTS_CANDIDATE_ROW_IDS, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_FTS_POSTINGS_PER_CHUNK, MAX_FTS_POSTING_ROW_IDS_PER_CHUNK, MAX_INDEXED_STRING_CHARACTERS, MAX_CATALOG_NAME_CHARACTERS, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_MAINTENANCE_BATCH_ITEMS, MAX_STORAGE_BULK_READ_ITEMS, MAX_TRANSACTION_STAGE_BLOCKS, MAX_TRANSACTION_STAGE_BYTES, MAX_SNAPSHOT_SESSION_TTL_MS, MAX_POSTING_BUILD_TTL_MS, MAX_TEMP_OWNER_TTL_MS, MAX_SNAPSHOT_FRAME_BATCH_BYTES, MAX_SNAPSHOT_FRAME_BATCH_ITEMS, MAX_SNAPSHOT_METADATA_BATCH_BYTES, SNAPSHOT_FRAME_KINDS, validateStorageId, SnapshotManifestMissingError, SchemaConflictError, TableInUseError, TableRecordConflictError, TransactionRecordConflictError, UniqueKeyConflictError, UniqueIndexCoverageError, WriteConflictError, } from "../storage/types.js";
 import { decodeSnapshotFrameStream, encodeSnapshotFrameStreamFooter, encodeSnapshotFrameStreamHeader, extendSnapshotFrameStreamChecksum, snapshotFrameEnvelopeParts, snapshotFrameStreamHeaderIdentity, } from "../storage/snapshot.js";
 import { Snapshot, TransactionManager, } from "../transactions/index.js";
-import { applyWindowFunctions, bindPlanParameters, bindStatementParameters, DUAL_TABLE, dualTableRows, blockHasSubqueries, combineUnionResults, compileCheckExpression, compileQuery, hasAggregate, createRecursiveCteState, compileStatement, comparisonHolds, createPreparedColumnarQuery, evaluateJoinedRowExpression, evaluateRowExpression, externalizeQueryResult, expressionColumnNames, inferBlockSchema, inferResultColumnDomains, isDefaultInsertValue, referencedColumns, childExpressions, expandFtsColumns, expandNaturalJoins, expandSourceColumnAliases, expandViewSources, forEachBlockExpression, planContainsFts, planHasNaturalJoins, planHasSourceColumnAliases, planReadsTable, planReadsViews, planReadsBeyondSingleScan, projectResultColumns, queryResultNeedsExternalization, resolveStatementDatetimes, subqueryResolutionSteps, topLevelFtsMatchConjuncts, transparentProjectionSource, unknownColumnDomains, validateDefaultExpression, windowOutputDomain, windowOutputType, } from "./query.js";
+import { applyWindowFunctions, bindPlanParameters, bindStatementParameters, DUAL_TABLE, dualTableRows, blockHasSubqueries, combineUnionResults, compileCheckExpression, compileQuery, hasAggregate, createRecursiveCteState, annotateAvgArgumentScales, compileStatement, comparisonHolds, createPreparedColumnarQuery, evaluateJoinedRowExpression, evaluateRowExpression, externalizeQueryResult, expressionColumnNames, inferBlockSchema, inferResultColumnDomains, isDefaultInsertValue, referencedColumns, childExpressions, expandFtsColumns, expandNaturalJoins, expandSourceColumnAliases, expandViewSources, forEachBlockExpression, planContainsFts, planHasNaturalJoins, planHasSourceColumnAliases, planReadsTable, planReadsViews, planReadsBeyondSingleScan, projectResultColumns, queryResultNeedsExternalization, resolveStatementDatetimes, subqueryResolutionSteps, topLevelFtsMatchConjuncts, transparentProjectionSource, unknownColumnDomains, validateDefaultExpression, windowOutputDomain, windowOutputType, } from "./query.js";
 import { copyQueryResult, planMemoKey, queryResultMemoKey, queryResultRetainedBytes, RESULT_MEMO_MAX_BYTES, } from "./query-cache.js";
 import { QueryMemoryBudgetError, QueryMemoryContext, DEFAULT_QUERY_MEMORY_BUDGET_BYTES, } from "./memory.js";
 import { LiveQueryLimitError, LiveQuerySet, MAX_LIVE_QUERY_SETS_PER_DATABASE, } from "./live.js";
 import { chooseJoinOrder, optimizePlan, qualifyCorrelatedReferences, renderPlan, } from "./optimizer.js";
 import { encodeSqlEqualityValue } from "./sql-semantics.js";
-import { externalSqlDomainValue, externalSqlTextValue, isDateDomainValue, isSqlDomainValue, normalizeSqlDomainValue, protectedSqlTextValue, } from "./sql-domains.js";
+import { exactNumericAsNumber, externalSqlDomainValue, externalSqlTextValue, isDateDomainValue, isExactNumeric, isSqlDomainValue, normalizeSqlDomainValue, protectedSqlTextValue, } from "./sql-domains.js";
 import { toCatalog } from "./catalog.js";
 import { applyColumnSteps, assertColumnDroppable, compileGeneratedColumnExpression, declaredForeignKeys, isDestructiveStep, planMigration, } from "./schema.js";
 import { columnarTableFromRows, createColumnarTable, vectorValue, } from "./vector.js";
@@ -2666,6 +2667,9 @@ export class MinnowDatabase {
                 // columnar forms of derived and windowed sources too, not just the result memo.
                 options.memoize !== false, options.spillToStorage !== false, options.spillToStorage === true, options.spillPageRows, options.signal);
                 throwIfAborted(options.signal);
+                // After input preparation, because executing the nested blocks registered their
+                // synthetic source schemas in typedSchemas — same reasoning as the domain inference.
+                resolvedPlan = annotateAvgArgumentScales(resolvedPlan, typedSchemas);
                 outputNeedsExternalization = queryResultNeedsExternalization(resolvedPlan, typedSchemas);
                 outputColumnDomains = inferResultColumnDomains(resolvedPlan, typedSchemas);
             };
@@ -3602,12 +3606,15 @@ export class MinnowDatabase {
         if (!keyComponents.every((component) => equalityColumns.has(component.name))) {
             return undefined;
         }
+        // A logical-domain projection is served too: the stored scalar is the tagged internal
+        // value the ordinary executor's pipeline carries for a bare column reference, and both
+        // paths cross the result boundary through the same externalizeQueryResult call, so
+        // reporting the column's domain below makes the answers identical by construction.
         const projected = [];
         for (const item of shape.select) {
             const column = columnByName.get(item.column);
-            if (column === undefined || column.hidden === true || column.sqlDomain !== undefined) {
+            if (column === undefined || column.hidden === true)
                 return undefined;
-            }
             projected.push({ column, alias: item.alias });
         }
         const segments = await this.#visibleSegmentRecords(table, snapshot, visibility);
@@ -3749,11 +3756,16 @@ export class MinnowDatabase {
                         if (columnVector === undefined)
                             return undefined;
                         const value = vectorValue(columnVector, slot);
-                        // A stored plain-text value in the protected NUL namespace crosses the result
-                        // boundary through the ordinary executor's wrapping rules; reproducing them here
-                        // is not worth the risk, so the whole statement falls back.
-                        if (typeof value === "string" && value.charCodeAt(0) === 0)
-                            return undefined;
+                        if (typeof value === "string" && value.charCodeAt(0) === 0) {
+                            // A domain column's stored scalar is expected here: it carries the internal
+                            // tag and is stripped by the shared externalization boundary. Anything else in
+                            // the NUL namespace — plain text crossing through the ordinary executor's
+                            // wrapping rules, or an untagged value where a tag is required — is not
+                            // provably reproduced, so the whole statement falls back.
+                            if (item.column.sqlDomain === undefined || !isSqlDomainValue(value)) {
+                                return undefined;
+                            }
+                        }
                         row[item.alias] = value;
                     }
                     rows.push(row);
@@ -3762,7 +3774,7 @@ export class MinnowDatabase {
         }
         return {
             columns: shape.select.map((item) => item.alias),
-            columnDomains: shape.select.map(() => null),
+            columnDomains: projected.map((item) => item.column.sqlDomain ?? null),
             rows,
         };
     }
@@ -7791,6 +7803,8 @@ export class MinnowDatabase {
                 ...(sqlDomain === undefined ? {} : { sqlDomain }),
             })),
         ]));
+        // Streamed plans scan real tables only, so the catalog schemas resolve every AVG argument.
+        plan = annotateAvgArgumentScales(plan, typedSchemas);
         const columns = referencedColumns(plan, schemas);
         // Streaming must choose the scan/build orientation before creating its sliding base view.
         // Plain append histories have exact row counts in segment metadata; mutation histories keep
@@ -8846,29 +8860,48 @@ export class MinnowDatabase {
         throwIfAborted(signal);
         const inputs = await this.#prepareBlockInputs(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
         throwIfAborted(signal);
+        // After input preparation, because executing this block's nested sources registered their
+        // synthetic schemas in typedSchemas, which is what resolves a derived column's domain.
+        block = annotateAvgArgumentScales(block, typedSchemas);
         const prepared = createPreparedColumnarQuery(block, inputs, memory.createChild(), ftsStats === undefined ? {} : { ftsStats });
+        // The columnar preparation only knows vector kinds, so a plain domain column projects with a
+        // null domain. Catalog-backed inference fills those in — at miss time, because executing the
+        // block registered its nested synthetic sources in typedSchemas — so a substituted scalar or
+        // IN subquery literal carries its domain to the outer result (T694).
+        const withCatalogColumnDomains = (result) => {
+            if (!result.columnDomains.includes(null))
+                return result;
+            try {
+                const inferred = inferResultColumnDomains(block, typedSchemas);
+                result.columnDomains = result.columnDomains.map((domain, index) => domain ?? inferred[index] ?? null);
+            }
+            catch {
+                // A shape this schema registry cannot type keeps its expression-level domains.
+            }
+            return result;
+        };
         try {
             if (!allowSpill || memory.usage.budgetBytes === Number.MAX_SAFE_INTEGER) {
                 const result = prepared.execute();
                 throwIfAborted(signal);
-                return result;
+                return withCatalogColumnDomains(result);
             }
             if (!forceSpill) {
                 try {
                     const result = prepared.execute();
                     throwIfAborted(signal);
-                    return result;
+                    return withCatalogColumnDomains(result);
                 }
                 catch (error) {
                     if (!(error instanceof QueryMemoryBudgetError))
                         throw error;
                 }
             }
-            return await prepared.executeAsync({
+            return withCatalogColumnDomains(await prepared.executeAsync({
                 spillStore: this.#leasedSpillStore(),
                 ...(spillPageRows === undefined ? {} : { spillPageRows }),
                 ...(signal === undefined ? {} : { signal }),
-            });
+            }));
         }
         finally {
             prepared.close();
@@ -15875,7 +15908,12 @@ function normalizeDomainBatch(table, input) {
         const values = input.columns[column.name];
         if (values === undefined)
             continue;
-        if (column.sqlDomain !== undefined || column.type === "datetime") {
+        if (column.sqlDomain !== undefined ||
+            column.type === "datetime" ||
+            // A number column rewrites only when a tagged exact-NUMERIC constant actually reached it
+            // (a SQL literal like 0.1/3 evaluated exactly), so plain bulk loads never copy here.
+            (column.type === "number" &&
+                values.some((value) => typeof value === "string" && isExactNumeric(value)))) {
             input.columns[column.name] = values.map((value) => normalizeColumnLogicalValue(column, value));
         }
     }
@@ -15889,6 +15927,18 @@ function normalizeColumnLogicalValue(column, value) {
             throw new TypeError("Invalid DATE value");
         return new Date(`${external}T00:00:00.000Z`);
     }
+    if (column.type === "number" && typeof value === "string" && isExactNumeric(value)) {
+        // PostgreSQL's assignment cast: an exact-NUMERIC value reaching a float column rounds to
+        // the nearest Float64. An integer column keeps its exactness guarantee instead — a value
+        // Float64 cannot hold exactly is rejected rather than silently rounded.
+        const exact = exactNumericAsNumber(value);
+        if (exact !== undefined)
+            return exact;
+        if (column.integer === true) {
+            throw new TypeError(`${column.name} must be a safe integer`);
+        }
+        return Number(externalSqlDomainValue(value));
+    }
     return value;
 }
 function selectBatchRows(input, indexes) {
@@ -15923,14 +15973,25 @@ function normalizeUpsertConflictWhere(table, predicate) {
     return { column, operator: predicate.operator, value };
 }
 function normalizeDomainUpdate(table, input) {
-    if (!table.columns.some((column) => column.sqlDomain !== undefined || column.type === "datetime"))
+    const numberColumnNeedsCast = (column, values) => column.type === "number" &&
+        values.some((value) => typeof value === "string" && isExactNumeric(value));
+    if (!table.columns.some((column) => column.sqlDomain !== undefined || column.type === "datetime") &&
+        !Object.entries(input.changes).some(([name, values]) => {
+            const column = table.columns.find((candidate) => candidate.name === name);
+            return column !== undefined && numberColumnNeedsCast(column, values);
+        })) {
         return input;
+    }
     let changed = false;
     const changes = { ...input.changes };
     for (const [name, values] of Object.entries(input.changes)) {
         const column = table.columns.find((candidate) => candidate.name === name);
-        if (column === undefined || (column.sqlDomain === undefined && column.type !== "datetime"))
+        if (column === undefined ||
+            (column.sqlDomain === undefined &&
+                column.type !== "datetime" &&
+                !numberColumnNeedsCast(column, values))) {
             continue;
+        }
         changed = true;
         changes[name] = values.map((value) => normalizeColumnLogicalValue(column, value));
     }
@@ -18892,12 +18953,6 @@ function compactTableSkipped(tableName, skipReason, sourceSegments, sourceBlockI
         metrics: null,
     };
 }
-function estimateRowBytes(row) {
-    return estimateValuesBytes(Object.values(row));
-}
-function estimateBatchBytes(input) {
-    return Object.values(input.columns).reduce((total, values) => total + estimateValuesBytes(values), 0);
-}
 function writeColumnValues(type, values) {
     const cached = type === "string" ? validatedStringByteLengths.get(values) : undefined;
     return {
@@ -18925,21 +18980,6 @@ function maximumWriteBlockStoredBytes(column, start, end, compression) {
         : physicalBytes;
     return Math.min(MAX_STORED_BLOCK_BYTE_LENGTH, BLOCK_HEADER_LENGTH + MAX_BLOCK_METADATA_BYTE_LENGTH + storedPayloadBytes);
 }
-function estimateValuesBytes(values) {
-    let bytes = 0;
-    for (const value of values) {
-        // One byte per UTF-16 code unit approximates the UTF-8 payload (exact for ASCII) without
-        // encoding the string just to measure it — this estimate feeds metrics and flush
-        // thresholds, not the physical format.
-        if (typeof value === "string")
-            bytes += 4 + value.length;
-        else if (typeof value === "number" || value instanceof Date)
-            bytes += 8;
-        else
-            bytes += 1;
-    }
-    return bytes;
-}
 function cacheableQueryInput(sql, params) {
     let characters = sql.length;
     if (characters > MAX_CACHEABLE_TEXT_CHARACTERS)

package/dist/engine/fts.d.ts

@@ -27,7 +27,6 @@ export declare function tokenize(text: string): string[];
  * query matches nothing.
  */
 export declare function tokenizeQuery(query: string): FtsQueryTerm[];
-export declare function termMatches(token: string, term: FtsQueryTerm): boolean;
 /** Tokenized query terms with the same bounded caching scheme as the LIKE pattern cache. */
 export declare function cachedQueryTerms(query: string): FtsQueryTerm[];
 /** Compile-time validation shared by the SQL parser and the DSL expression builder. */

package/dist/engine/fts.js

@@ -110,7 +110,7 @@ export function tokenizeQuery(query) {
     }
     return terms;
 }
-export function termMatches(token, term) {
+function termMatches(token, term) {
     return term.prefix ? token.startsWith(term.term) : token === term.term;
 }
 /**

package/dist/engine/join-index.d.ts

@@ -1,5 +1,4 @@
 import { QueryMemoryContext } from "./memory.js";
-export type JoinIndexKey = boolean | number | string | Date;
 /** Collision-checked scalar-key hash index with typed duplicate row chains. */
 export declare class ByteJoinIndex {
     #private;

package/dist/engine/optimizer.js

@@ -1,6 +1,6 @@
 import { dateIsoString, dateMilliseconds } from "../date-value.js";
 import { blockHasSubqueries, childExpressions, DUAL_TABLE, expressionAliases, forEachBlockExpression, forEachNestedBlock, hasAggregate, isAggregateCall, isScalarFunctionName, mapBlockExpressions, mapChildExpressions, parseQuantified, scalarFunctionNames, scalarFunctionValue, splitCondition, volatileScalarFunctionNames, } from "./query.js";
-import { isSqlDomainValue } from "./sql-domains.js";
+import { concatenatedSqlValue, isSqlDomainValue } from "./sql-domains.js";
 /**
  * Deterministic plan-to-plan rewrites over the shared compiled representation. Every rule
  * preserves result semantics exactly; rules that cannot prove safety leave the plan unchanged.
@@ -2181,7 +2181,8 @@ function foldExpression(expression) {
                             ? { kind: targetWord }
                             : expression.name === "JSON_QUERY" ||
                                 expression.name === "JSON_OBJECT" ||
-                                expression.name === "JSON_ARRAY"
+                                expression.name === "JSON_ARRAY" ||
+                                expression.name === "MINNOW_JSON_GET"
                                 ? { kind: "json" }
                                 : undefined;
                     return {
@@ -2243,7 +2244,14 @@ function foldBinary(operator, leftValue, rightValue) {
         return null;
     if (operator === "||") {
         if (typeof leftValue === "string" && typeof rightValue === "string") {
-            return leftValue + rightValue;
+            // Same helper the executors use, so folding cannot concatenate internal domain
+            // encodings. A refused shape stays unfolded and raises the same error at execution.
+            try {
+                return concatenatedSqlValue(leftValue, rightValue);
+            }
+            catch {
+                return undefined;
+            }
         }
         return undefined;
     }

package/dist/engine/point-read.d.ts

@@ -1,5 +1,5 @@
 import type { CompiledQuery, QueryValue } from "../plan/model.js";
-export type PointReadValue = boolean | number | string | Date;
+type PointReadValue = boolean | number | string | Date;
 export interface PointReadEquality {
     column: string;
     value: PointReadValue;

package/dist/engine/point-read.js

@@ -1,7 +1,8 @@
 /**
  * Shape analysis for the keyed point-read fast path: a single-table conjunction of
- * column-equals-literal predicates that covers the table's unique key, projecting plain
- * columns. Such a statement addresses at most one row, so execution can skip parameter
+ * column-equals-literal predicates that covers the table's unique key, projecting bare
+ * columns — plain or logical-domain typed, since domain scalars externalize through the
+ * same result boundary. Such a statement addresses at most one row, so execution can skip parameter
  * binding, plan cloning, streamed-view construction, and the vector pipeline entirely and
  * answer from cached decoded blocks. Anything this module cannot prove eligible falls back to
  * the ordinary executor, which stays the authority on errors and semantics.

package/dist/engine/query-cache.js

@@ -1,4 +1,5 @@
 import { copyDate, dateMilliseconds } from "../date-value.js";
+import { estimateValuesBytes } from "./byte-estimates.js";
 import { copyQueryResultExternalization } from "./query.js";
 import { defineSqlResultProperty } from "./sql-semantics.js";
 /** Modest per-entry cap so one giant result cannot thrash the shared artifact cache. */
@@ -60,18 +61,6 @@ export function queryResultRetainedBytes(result) {
         bytes += estimateValuesBytes(Object.values(row));
     return bytes;
 }
-function estimateValuesBytes(values) {
-    let bytes = 0;
-    for (const value of values) {
-        if (typeof value === "string")
-            bytes += 4 + value.length;
-        else if (typeof value === "number" || value instanceof Date)
-            bytes += 8;
-        else
-            bytes += 1;
-    }
-    return bytes;
-}
 function encodeParameter(value) {
     if (value === null)
         return [0];

package/dist/engine/query.d.ts

@@ -31,12 +31,6 @@ export interface QueryExecutionOptions {
 export declare const scalarFunctionNames: ReadonlySet<string>;
 /** Functions whose answer can change without any catalog or input-row change. */
 export declare const volatileScalarFunctionNames: ReadonlySet<string>;
-/**
- * The niladic datetime functions (F051-06/07/08). Their value is the statement's own clock
- * reading, so they are resolved once per execution rather than evaluated per row: every row of
- * one statement sees one instant, both executors agree, and constant folding leaves them alone.
- */
-export declare const statementDatetimeNames: ReadonlySet<string>;
 export declare function isScalarFunctionName(name: AggregateName | ScalarFunctionName): name is ScalarFunctionName;
 /**
  * Evaluates one scalar function over already-evaluated argument values. Every executor calls
@@ -46,23 +40,6 @@ export declare function isScalarFunctionName(name: AggregateName | ScalarFunctio
  * SUBSTR count characters, not UTF-16 units, matching SQLite and PostgreSQL.
  */
 export declare function scalarFunctionValue(name: Exclude<ScalarFunctionName, "COALESCE">, values: readonly unknown[]): unknown;
-export declare const dateTruncUnits: ReadonlySet<string>;
-/**
- * `INTERVAL '1 month'`, `INTERVAL '2 years 3 days'`. Months are kept apart from milliseconds
- * rather than converted, because a month is not a fixed number of them: adding one to January 31
- * has to land on the end of February, which only calendar arithmetic can do.
- */
-export declare function intervalLiteral(text: string): {
-    months: number;
-    milliseconds: number;
-};
-/**
- * A datetime shifted by a calendar interval: whole months first, then milliseconds. A day that
- * does not exist in the target month clamps to that month's last day, which is what both SQLite
- * and PostgreSQL do with 31 January plus a month.
- */
-export declare function dateAddValue(value: unknown, months: unknown, milliseconds: unknown): Date | string | null;
-export declare function dateTruncValue(unit: unknown, value: unknown): Date | null;
 /** The output column type of one window: rankings and most aggregates count, MIN/MAX carry. */
 export declare function windowOutputType(window: WindowSpec, innerSchema: readonly SqlColumnSchema[]): SqlColumnType;
 /** Logical domain carried or produced by a window result, when its physical type is not enough. */
@@ -75,7 +52,7 @@ export declare function windowOutputDomain(window: WindowSpec, innerSchema: read
 export declare const DUAL_TABLE = "(dual)";
 /** The dual source's single row, shared by every resolution path. */
 export declare function dualTableRows(): DatabaseRow[];
-export interface CompileQueryOptions {
+interface CompileQueryOptions {
     /** Set false to skip deterministic plan rewrites, for example to snapshot the raw plan. */
     readonly optimize?: boolean;
 }
@@ -84,7 +61,7 @@ export declare function compileQuery(sql: string, options?: CompileQueryOptions)
  * One WHEN clause of a MERGE (F312). Branches are tried in order for each source row, and the
  * first whose match state and optional condition hold decides what happens to that row.
  */
-export type MergeBranch = {
+type MergeBranch = {
     when: "matched";
     condition?: Expression;
     action: {
@@ -125,7 +102,7 @@ export interface UniqueConstraintDefinition {
     columns: string[];
 }
 /** An INSERT value: a constant, SQL DEFAULT, or an unbound placeholder. */
-export interface DefaultInsertValue {
+interface DefaultInsertValue {
     readonly default: true;
 }
 export type InsertValue = QueryValue | DefaultInsertValue | {
@@ -344,7 +321,7 @@ export type CompiledStatement = {
  * row condition over this table's columns, with no aggregate, window, subquery, or parameter.
  */
 export declare function compileCheckExpression(sql: string, name: string): Expression;
-export interface DefaultExpressionTarget {
+interface DefaultExpressionTarget {
     readonly name: string;
     readonly type: SqlColumnType;
     readonly sqlDomain?: SqlDomain;
@@ -368,7 +345,7 @@ export declare function compileStatement(sql: string): CompiledStatement;
 export declare function evaluateJoinedRowExpression(expression: Expression, rows: Readonly<Record<string, DatabaseRow | undefined>>): QueryValue;
 /** Evaluates an expression against one row, for UPDATE SET assignment computation. */
 export declare function evaluateRowExpression(expression: Expression, alias: string, row: DatabaseRow): QueryValue;
-export interface SubqueryResolutionStep {
+interface SubqueryResolutionStep {
     /** The uncorrelated block to execute; earlier steps have already substituted inside it. */
     readonly block: CompiledQuery;
     /** Replaces the subquery node with the executed result as literals. */
@@ -386,9 +363,6 @@ export declare function subqueryResolutionSteps(plan: CompiledQuery): {
     steps: SubqueryResolutionStep[];
 };
 export declare function blockHasSubqueries(plan: CompiledQuery): boolean;
-/** True when any `?`/`$n` placeholder remains anywhere in the expression tree. */
-export declare function containsParameter(expression: Expression): boolean;
-export declare function blockHasParameters(block: CompiledQuery): boolean;
 /**
  * A deep copy of a compiled plan, statement, or expression tree. Plans are plain data — objects,
  * arrays, primitives, and Date literals — so a direct recursive copy does what structuredClone
@@ -486,7 +460,7 @@ export declare function mapBlockExpressions(block: CompiledQuery, map: (expressi
  */
 export declare function resolveStatementDatetimes(plan: CompiledQuery, now?: Date): CompiledQuery;
 /** One top-level full-text MATCH conjunct of a plan, with its resolved column expressions. */
-export interface FtsMatchConjunct {
+interface FtsMatchConjunct {
     columns: Expression[];
     query: string;
 }
@@ -520,6 +494,17 @@ export declare function planContainsFts(plan: CompiledQuery, op?: "match" | "bm2
  * later migrations.
  */
 export declare function expandFtsColumns(plan: CompiledQuery, searchableColumnsFor: (tableName: string) => readonly string[] | undefined): CompiledQuery;
+/**
+ * Annotates every `AVG(column)` in this block's expression positions with the argument column's
+ * declared NUMERIC scale, resolved against the given schemas. PostgreSQL floors an AVG's
+ * internal division scale at the summed values' display scale; the canonical NUMERIC encoding
+ * strips trailing fractional zeros, so without the annotation the divide cannot know the digits
+ * a declared scale above its own selection would render, and the display padding would fabricate
+ * zeros where PostgreSQL computes real digits. Runs where the catalog is known, per block —
+ * nested blocks execute through their own schema-aware entry. Copy-on-write: plans without an
+ * AVG pass through untouched, and the input is often the compile cache's own object.
+ */
+export declare function annotateAvgArgumentScales(plan: CompiledQuery, schemas: ReadonlyMap<string, readonly SqlColumnSchema[]>): CompiledQuery;
 /**
  * Appends window-function columns to an executed inner-block result. Rows sort stably by the
  * hidden partition and ordering aliases with the same comparison semantics as ORDER BY;
@@ -532,7 +517,7 @@ export declare function applyWindowFunctions(result: QueryResult, windows: reado
 /** Correctness reference retained while the vector executor matures. */
 export declare function executeRowQuery(plan: CompiledQuery, tables: ReadonlyMap<string, DatabaseRow[]>): QueryResult;
 /** One ORDER BY resolution source: an alias and the columns a wildcard select exposes from it. */
-export interface OrderSourceShape {
+interface OrderSourceShape {
     readonly alias: string;
     readonly columns: readonly string[];
 }
@@ -543,7 +528,7 @@ export interface OrderSourceShape {
  * repeated rows.
  */
 export declare function orderOutputName(expression: Expression, select: readonly SelectItem[], sources: readonly OrderSourceShape[]): string;
-export interface ListMembership {
+interface ListMembership {
     set: ReadonlySet<unknown>;
     hasNull: boolean;
 }
@@ -604,7 +589,7 @@ export declare function nullOrder(left: unknown, right: unknown, nulls: "first"
 export declare function copyQueryResultExternalization(source: QueryResult, copy: QueryResult): QueryResult;
 /** Removes internal domain tags only after every comparison, group, join, and sort is complete. */
 export declare function externalizeQueryResult(result: QueryResult): QueryResult;
-export interface SelectBlockParts {
+interface SelectBlockParts {
     sql: string;
     base: TableSource;
     joins: JoinPlan[];
@@ -624,13 +609,6 @@ export interface SelectBlockParts {
     groupingSets?: Expression[][];
 }
 export declare function assembleSelectBlock(parts: SelectBlockParts, nextSequence: () => number): CompiledQuery;
-/**
- * Expands a pending SELECT DISTINCT * against known input columns: the select list becomes
- * every wildcard output (alias-qualified when more than one source contributes), and GROUP BY
- * over those same columns provides the deduplication through the grouped executor. Runs
- * exactly once per execution entry, like MATCH(*) expansion.
- */
-export declare function expandDistinctWildcard(plan: CompiledQuery, columnsOf: (tableName: string) => readonly string[] | undefined): CompiledQuery;
 /**
  * Turns every source carrying a column alias list into a derived projection that renames the
  * table's columns positionally (E051-09). The table's own column order is only known here, so
@@ -648,15 +626,6 @@ export declare function planReadsViews(plan: CompiledQuery, isView: (name: strin
  */
 export declare function expandViewSources(plan: CompiledQuery, viewFor: (tableName: string) => CompiledQuery | undefined, maxDepth?: number): CompiledQuery;
 export declare function planHasSourceColumnAliases(plan: CompiledQuery): boolean;
-/**
- * FETCH FIRST n ROWS WITH TIES (F866). The plan runs without its limit — a limit pushed into a
- * scan cannot know whether the next row ties — and the ordered result is trimmed here: rows up
- * to the limit, plus every following row equal to the last one on all ORDER BY columns.
- */
-export declare function withTiesPlan(plan: CompiledQuery): {
-    plan: CompiledQuery;
-    trim: (result: QueryResult) => QueryResult;
-};
 /** Whether any block of the plan still carries an unresolved NATURAL join marker. */
 export declare function planHasNaturalJoins(plan: CompiledQuery): boolean;
 /**
@@ -666,13 +635,6 @@ export declare function planHasNaturalJoins(plan: CompiledQuery): boolean;
  */
 export declare function expandNaturalJoins(plan: CompiledQuery, columnsOf: (tableName: string) => readonly string[] | undefined): CompiledQuery;
 export declare function expandSourceColumnAliases(plan: CompiledQuery, columnsOf: (tableName: string) => readonly string[] | undefined): CompiledQuery;
-/**
- * Expands `alias.*` select items into that source's columns (E051-07), at every nesting depth.
- * Output names follow the same rule as a bare `*`: the column's own name when the block reads
- * one source, and `alias.column` when it reads several, so two sources cannot collide.
- * Runs once per execution entry, like MATCH(*) and DISTINCT * expansion.
- */
-export declare function expandQualifiedWildcards(plan: CompiledQuery, columnsOf: (tableName: string) => readonly string[] | undefined): CompiledQuery;
 /** Wraps compound members into the set-operation source the executor folds left to right. */
 export declare function compoundSelectBlock(sql: string, blocks: CompiledQuery[], ops: SetOperator[], tail: SelectTail, nextSequence: () => number): CompiledQuery;
 /**
@@ -693,7 +655,6 @@ export declare function projectResultColumns(result: QueryResult, aliases: reado
 export declare function derivedTableSource(derived: CompiledQuery, alias: string, nextSequence: () => number): TableSource;
 /** The parser's LIMIT range contract, shared with the typed builder. */
 export declare function validateLimit(limit: number): number;
-export declare function timestampLiteral(text: string): Date;
 /** The parser's OFFSET range contract, shared with the typed builder. */
 export declare function validateOffset(offset: number): number;
 /**