@minnowdb/core 0.6.5 → 0.6.7

package/dist/block-format/codecs.d.ts

@@ -16,14 +16,6 @@ export interface CompressionMemoryBound {
     /** Additional JavaScript-owned byte storage retained while producing the result. */
     readonly scratchBytes: number;
 }
-/**
- * The raw codec returns its input view unchanged in both directions: callers treat compressed
- * and decompressed payloads as read-only (encode copies the payload into the block envelope,
- * decode consumers only read or copy out), so a full-payload defensive copy per block would be
- * pure overhead on the default compression path. The returned view may share the caller's
- * buffer at a non-zero byte offset.
- */
-export declare const rawCodec: CompressionCodec;
 export declare function getCompressionMemoryBound(compression: Compression, inputLength: number): CompressionMemoryBound;
 export declare const gzipCodec: CompressionCodec;
 export declare function getCodec(id: Compression): CompressionCodec;

package/dist/block-format/codecs.js

@@ -16,7 +16,7 @@ export class CompressionOutputLimitError extends RangeError {
  * pure overhead on the default compression path. The returned view may share the caller's
  * buffer at a non-zero byte offset.
  */
-export const rawCodec = {
+const rawCodec = {
     id: "raw",
     async compress(bytes, maximumOutputLength) {
         if (maximumOutputLength !== undefined) {

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,6 +8860,9 @@ 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
@@ -15891,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));
         }
     }
@@ -15905,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) {
@@ -15939,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));
     }
@@ -18908,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 {
@@ -18941,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/group-index.d.ts

@@ -29,3 +29,5 @@ export declare function hashScratch(length: number): number;
 export declare function equalsScratch(arena: Uint8Array, offset: number, length: number): boolean;
 /** Copies the scratch arena's first `length` bytes into owned storage. Exported for the join index. */
 export declare function copyScratchKey(length: number): Uint8Array;
+export declare function safeDouble(value: number, label: string): number;
+export declare function safeProduct(left: number, right: number, label: string): number;

package/dist/engine/group-index.js

@@ -49,7 +49,7 @@ export class ByteGroupIndex {
         return this.get([]);
     }
     getOne(key) {
-        const length = encodeSingleGroupKey(key);
+        const length = encodeSingleScalarKey(key);
         const index = this.#find(length, hashScratch(length));
         return index < 0 ? undefined : this.#values[index];
     }
@@ -68,7 +68,7 @@ export class ByteGroupIndex {
         return this.#getOrInsertScratch(length, create);
     }
     getOrInsertOne(key, create) {
-        const length = encodeSingleGroupKey(key);
+        const length = encodeSingleScalarKey(key);
         return this.#getOrInsertScratch(length, create);
     }
     /**
@@ -231,10 +231,6 @@ export function encodeSingleScalarKey(key) {
     reclaimScratch();
     return writeGroupKey(key, 0);
 }
-function encodeSingleGroupKey(key) {
-    reclaimScratch();
-    return writeGroupKey(key, 0);
-}
 function writeGroupKey(key, offset) {
     if (key === null) {
         ensureScratchCapacity(offset + 1);
@@ -341,13 +337,13 @@ export function equalsScratch(arena, offset, length) {
 export function copyScratchKey(length) {
     return scratch.slice(0, length);
 }
-function safeDouble(value, label) {
+export function safeDouble(value, label) {
     const doubled = value * 2;
     if (!Number.isSafeInteger(doubled))
         throw new RangeError(`${label} exceeds the safe integer range`);
     return doubled;
 }
-function safeProduct(left, right, label) {
+export function safeProduct(left, right, label) {
     const product = left * right;
     if (!Number.isSafeInteger(product))
         throw new RangeError(`${label} exceeds the safe integer range`);

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/join-index.js

@@ -1,5 +1,5 @@
 import { dateMilliseconds } from "../date-value.js";
-import { copyScratchKey, encodeSingleScalarKey, equalsScratch, hashScratch, } from "./group-index.js";
+import { copyScratchKey, encodeSingleScalarKey, equalsScratch, hashScratch, safeDouble, safeProduct, } from "./group-index.js";
 const INITIAL_ENTRY_CAPACITY = 4;
 const INITIAL_BUCKET_CAPACITY = 8;
 const INITIAL_KEY_CAPACITY = 32;
@@ -201,17 +201,3 @@ function encodeJoinKey(value) {
     }
     throw new TypeError("Join keys must be SQL scalar values");
 }
-function safeDouble(value, label) {
-    const doubled = value * 2;
-    if (!Number.isSafeInteger(doubled)) {
-        throw new RangeError(`${label} exceeds the safe integer range`);
-    }
-    return doubled;
-}
-function safeProduct(left, right, label) {
-    const product = left * right;
-    if (!Number.isSafeInteger(product)) {
-        throw new RangeError(`${label} exceeds the safe integer range`);
-    }
-    return product;
-}

package/dist/engine/keyed-live.js

@@ -1,39 +1,5 @@
 import { dateMilliseconds } from "../date-value.js";
-function sameValue(left, right) {
-    if (Object.is(left, right))
-        return true;
-    if (left instanceof Date || right instanceof Date) {
-        return (left instanceof Date &&
-            right instanceof Date &&
-            Object.is(dateMilliseconds(left), dateMilliseconds(right)));
-    }
-    if (Array.isArray(left) || Array.isArray(right)) {
-        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
-            return false;
-        for (let index = 0; index < left.length; index += 1) {
-            if (!sameValue(left[index], right[index]))
-                return false;
-        }
-        return true;
-    }
-    if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) {
-        return false;
-    }
-    const leftRecord = left;
-    const rightRecord = right;
-    const leftKeys = Object.keys(leftRecord);
-    const rightKeys = Object.keys(rightRecord);
-    if (leftKeys.length !== rightKeys.length)
-        return false;
-    for (let index = 0; index < leftKeys.length; index += 1) {
-        const key = leftKeys[index];
-        if (key === undefined || key !== rightKeys[index])
-            return false;
-        if (!sameValue(leftRecord[key], rightRecord[key]))
-            return false;
-    }
-    return true;
-}
+import { sameLiveValue } from "./live-equal.js";
 function keyToken(value, name) {
     if (typeof value === "string")
         return `s:${String(value.length)}:${value}`;
@@ -84,7 +50,7 @@ function diffRows(previousRows, rows, key) {
             changes.push({ type: "insert", row: next.row, index: next.index });
             continue;
         }
-        if (!sameValue(old.row, next.row)) {
+        if (!sameLiveValue(old.row, next.row)) {
             changes.push({ type: "update", row: next.row, previous: old.row, index: next.index });
         }
         if (old.index !== next.index) {

package/dist/engine/live-equal.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Structural equality over live result values: dates by instant, arrays by element, objects by
+ * own keys in insertion order. Shared by the typed live store's exact suppression and the keyed
+ * live window's diffing; internal on purpose — live-api re-exports its modules wholesale, and
+ * this helper is not part of the live API.
+ */
+export declare function sameLiveValue(left: unknown, right: unknown): boolean;

package/dist/engine/live-equal.js

@@ -0,0 +1,42 @@
+import { dateMilliseconds } from "../date-value.js";
+/**
+ * Structural equality over live result values: dates by instant, arrays by element, objects by
+ * own keys in insertion order. Shared by the typed live store's exact suppression and the keyed
+ * live window's diffing; internal on purpose — live-api re-exports its modules wholesale, and
+ * this helper is not part of the live API.
+ */
+export function sameLiveValue(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (left instanceof Date || right instanceof Date) {
+        return (left instanceof Date &&
+            right instanceof Date &&
+            Object.is(dateMilliseconds(left), dateMilliseconds(right)));
+    }
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
+            return false;
+        for (let index = 0; index < left.length; index += 1) {
+            if (!sameLiveValue(left[index], right[index]))
+                return false;
+        }
+        return true;
+    }
+    if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) {
+        return false;
+    }
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord);
+    const rightKeys = Object.keys(rightRecord);
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    for (let index = 0; index < leftKeys.length; index += 1) {
+        const key = leftKeys[index];
+        if (key === undefined || key !== rightKeys[index])
+            return false;
+        if (!sameLiveValue(leftRecord[key], rightRecord[key]))
+            return false;
+    }
+    return true;
+}

package/dist/engine/optimizer.js

@@ -1,6 +1,7 @@
 import { dateIsoString, dateMilliseconds } from "../date-value.js";
+import { crossJoinPlan } from "../plan/model.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.
@@ -1776,20 +1777,7 @@ function decorrelateExistsWithProbes(block, exists, scope, nextAlias) {
         reference: `${probesAlias}.${correlationProbeAlias(index)}`,
     }));
     replacePlanReferences(inner, new Map(references.map((reference, index) => [reference, probeReferences[index] ?? null])));
-    inner.joins.push({
-        table: probesAlias,
-        alias: probesAlias,
-        derived: probes,
-        kind: "inner",
-        left: { kind: "literal", value: null },
-        right: { kind: "literal", value: null },
-        on: {
-            kind: "condition",
-            operator: "=",
-            left: { kind: "literal", value: 1 },
-            right: { kind: "literal", value: 1 },
-        },
-    });
+    inner.joins.push(crossJoinPlan({ table: probesAlias, alias: probesAlias, derived: probes }));
     const flagsAlias = nextAlias();
     const flags = {
         sql: "(probe-lifted correlated exists flags)",
@@ -2244,7 +2232,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];