@minnowdb/core 0.6.6 → 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/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.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,4 +1,5 @@
 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 { concatenatedSqlValue, isSqlDomainValue } from "./sql-domains.js";
 /**
@@ -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)",

package/dist/engine/query.js

@@ -1,4 +1,5 @@
 import { copyDate, dateIsoString, dateMilliseconds, dateUtcDate, dateUtcDay, dateUtcFullYear, dateUtcHours, dateUtcMinutes, dateUtcMonth, dateUtcSeconds, setDateUtcDate, setDateUtcMonth, } from "../date-value.js";
+import { crossJoinPlan } from "../plan/model.js";
 import { assertWellFormedString, wellFormedUtf8ByteLength } from "../block-format/unicode.js";
 import { MAX_SQL_NESTING_DEPTH, MAX_SQL_PARAMETERS, MAX_SQL_SCALAR_RESULT_CHARACTERS, MAX_SQL_TEXT_CHARACTERS, MAX_SQL_TOKENS, } from "./cache-limits.js";
 import { SqlCompileError } from "./errors.js";
@@ -2549,6 +2550,9 @@ function createPreparedRowQuery(plan, tables, memory) {
         },
     };
 }
+// protectText defaults OFF here — the row engine's own tables are already inside the SQL
+// boundary — but ON in vector.ts's columnarTableFromRows, which ingests caller-owned rows.
+// A new call site must pick deliberately, not inherit whichever default is nearest.
 function cloneRowTables(tables, protectText = false) {
     return new Map([...tables].map(([name, rows]) => [
         name,
@@ -6163,19 +6167,6 @@ class Parser {
         }
         const joins = [];
         let rightJoins = 0;
-        /** A cross join: the nested-loop path with a condition every row pair satisfies. */
-        const crossJoin = (source) => ({
-            ...source,
-            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 },
-            },
-        });
         while (this.#peek().text === "," ||
             this.#isKeyword("NATURAL") ||
             this.#isKeyword("JOIN") ||
@@ -6186,13 +6177,13 @@ class Parser {
             this.#isKeyword("CROSS")) {
             if (this.#punctuation(",")) {
                 // F041-07: a comma between table references is a cross join.
-                joins.push(crossJoin(this.#source()));
+                joins.push(crossJoinPlan(this.#source()));
                 continue;
             }
             if (this.#isKeyword("CROSS")) {
                 this.#keyword("CROSS");
                 this.#keyword("JOIN");
-                joins.push(crossJoin(this.#source()));
+                joins.push(crossJoinPlan(this.#source()));
                 continue;
             }
             let kind = "inner";

package/dist/engine/schema.d.ts

@@ -48,13 +48,6 @@ export interface TableForeignKey<TColumnName extends string = string> {
  * derives for an unnamed inline REFERENCES, so a table built either way has the same catalog.
  */
 export declare function foreignKeyName(tableName: string, columnName: string): string;
-/**
- * A flavored value: a column whose slot the engine can fill, so inserts may omit it. The brand
- * is an optional phantom property — plain values stay assignable in both directions.
- */
-export type HasDefault<TValue> = TValue & {
-    readonly __minnowHasDefault?: true;
-};
 /**
  * A JSON column's select value carrying a declared document shape. The value is still JSON
  * text — the brand is an optional phantom property, so plain strings stay assignable in both
@@ -171,11 +164,6 @@ interface AnyColumn {
     readonly renamedFromName?: string;
     readonly reference?: ColumnReferenceSpec;
 }
-/**
- * Rebuilds a column carrying an exact default spec — the wire layer's escape hatch, since the
- * public `.default()` accepts literals and cannot express auto-increment catalog metadata.
- */
-export declare function columnWithDefaultSpec(base: Pick<AnyColumn, "type" | "isNullable" | "isUnique" | "renamedFromName" | "reference" | "enumValues"> & Partial<Pick<AnyColumn, "integer" | "sqlDomain">>, spec: ColumnDefault): AnyColumn;
 /** Rebuilds a fluent column from structured-clone-safe metadata. */
 export declare function columnFromState(state: Pick<AnyColumn, "type" | "isNullable" | "isUnique"> & Partial<Pick<AnyColumn, "integer" | "sqlDomain" | "renamedFromName" | "reference" | "defaultSpec" | "generatedSpec" | "enumValues" | "backfillValue">>): AnyColumn;
 export declare const column: {

package/dist/engine/schema.js

@@ -184,23 +184,6 @@ function validateSchemaName(name, kind) {
         throw new TypeError(`${kind} name cannot start or end with whitespace: ${JSON.stringify(name)}`);
     }
 }
-/**
- * Rebuilds a column carrying an exact default spec — the wire layer's escape hatch, since the
- * public `.default()` accepts literals and cannot express auto-increment catalog metadata.
- */
-export function columnWithDefaultSpec(base, spec) {
-    return columnFromState({
-        type: base.type,
-        isNullable: base.isNullable,
-        isUnique: base.isUnique,
-        integer: base.integer ?? false,
-        ...(base.sqlDomain === undefined ? {} : { sqlDomain: base.sqlDomain }),
-        ...(base.renamedFromName === undefined ? {} : { renamedFromName: base.renamedFromName }),
-        ...(base.reference === undefined ? {} : { reference: base.reference }),
-        ...(base.enumValues === undefined ? {} : { enumValues: base.enumValues }),
-        defaultSpec: spec,
-    });
-}
 /** Rebuilds a fluent column from structured-clone-safe metadata. */
 export function columnFromState(state) {
     return createColumn(state.type, {

package/dist/engine/typed-live.js

@@ -1,42 +1,4 @@
-import { dateMilliseconds } from "../date-value.js";
-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;
-}
-function sameRows(left, right) {
-    return sameLiveValue(left, right);
-}
+import { sameLiveValue } from "./live-equal.js";
 function immutableRows(rows) {
     // Adapters own their values. Copy the array so mutating the returned builder result cannot
     // change the snapshot identity retained for exact suppression.
@@ -191,10 +153,10 @@ export class LiveQuery {
                 const previous = this.#snapshot.rows;
                 if (this.#snapshot.status === "ready" &&
                     this.#snapshot.version === invalidation.manifestVersion &&
-                    sameRows(previous, rows)) {
+                    sameLiveValue(previous, rows)) {
                     continue;
                 }
-                if (sameRows(previous, rows) && this.#snapshot.status !== "loading") {
+                if (sameLiveValue(previous, rows) && this.#snapshot.status !== "loading") {
                     // Advance the version without replacing the immutable row array.
                     this.#snapshot = {
                         status: "ready",

package/dist/engine/vector.js

@@ -1,4 +1,5 @@
 import { dateMilliseconds } from "../date-value.js";
+import { crossJoinPlan, isCrossJoinPlan } from "../plan/model.js";
 import { MAX_TEMP_RUN_BATCH_BYTES, MAX_TEMP_RUN_PAGE_BYTES, MAX_TEMP_RUN_PAGES_PER_BATCH, } from "../storage/types.js";
 import { throwIfAborted } from "./cancellation.js";
 import { cachedListMembership, childExpressions, distinctFromComparison, nullOrder, isScalarFunctionName, likeMatches, orderOutputName, parseQuantified, quantifiedComparison, scalarFunctionValue, unknownColumnDomains, } from "./query.js";
@@ -409,7 +410,7 @@ function disjunctiveNormalForm(predicate) {
 function orderCartesianJoins(plan, tables) {
     if (plan.joins.length < 2 ||
         plan.select.some((item) => item.expression.kind === "wildcard") ||
-        plan.joins.some((join) => !isCartesianJoin(join))) {
+        plan.joins.some((join) => !isCrossJoinPlan(join))) {
         return plan;
     }
     const entries = [
@@ -454,21 +455,11 @@ function orderCartesianJoins(plan, tables) {
             return plan;
         const keyIndex = predicates.findIndex((predicate) => predicateJoinsSource(predicate, sourceIndex, available, entries, sourceTables));
         const key = keyIndex < 0 ? undefined : predicates.splice(keyIndex, 1)[0];
-        joins.push(key === undefined ? cartesianJoin(source) : keyedInnerJoin(source, key));
+        joins.push(key === undefined ? crossJoinPlan(source) : keyedInnerJoin(source, key));
         available.add(sourceIndex);
     }
     return { ...plan, base: plan.base, joins, predicates };
 }
-function isCartesianJoin(join) {
-    const condition = join.on;
-    return (join.kind === "inner" &&
-        condition?.kind === "condition" &&
-        condition.operator === "=" &&
-        condition.left.kind === "literal" &&
-        condition.left.value === 1 &&
-        condition.right.kind === "literal" &&
-        condition.right.value === 1);
-}
 function tableSourceOf(join) {
     const { kind, left, right, on, full, natural, ...source } = join;
     void kind;
@@ -479,20 +470,6 @@ function tableSourceOf(join) {
     void natural;
     return source;
 }
-function cartesianJoin(source) {
-    return {
-        ...source,
-        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 },
-        },
-    };
-}
 function keyedInnerJoin(source, predicate) {
     return {
         ...source,

package/dist/plan/model.d.ts

@@ -190,6 +190,13 @@ export interface JoinPlan extends TableSource {
     full?: boolean;
     natural?: boolean;
 }
+/**
+ * A cross join rides the nested-loop inner-join path with a condition every row pair satisfies:
+ * 1 = 1 over null literal key expressions. Producers build the shape with crossJoinPlan and
+ * consumers recognize it with isCrossJoinPlan, so the encoding lives in exactly one place.
+ */
+export declare function crossJoinPlan(source: TableSource): JoinPlan;
+export declare function isCrossJoinPlan(join: JoinPlan): boolean;
 export type SetOperator = "union" | "union all" | "intersect" | "intersect all" | "except" | "except all";
 export interface RecursiveCte {
     reference: string;

package/dist/plan/model.js

@@ -1 +1,29 @@
-export {};
+/**
+ * A cross join rides the nested-loop inner-join path with a condition every row pair satisfies:
+ * 1 = 1 over null literal key expressions. Producers build the shape with crossJoinPlan and
+ * consumers recognize it with isCrossJoinPlan, so the encoding lives in exactly one place.
+ */
+export function crossJoinPlan(source) {
+    return {
+        ...source,
+        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 },
+        },
+    };
+}
+export function isCrossJoinPlan(join) {
+    const condition = join.on;
+    return (join.kind === "inner" &&
+        condition?.kind === "condition" &&
+        condition.operator === "=" &&
+        condition.left.kind === "literal" &&
+        condition.left.value === 1 &&
+        condition.right.kind === "literal" &&
+        condition.right.value === 1);
+}

package/dist/storage/indexeddb.js

@@ -1,4 +1,4 @@
-import { CompactionJobConflictError, assertCompactionOutputProvenance, compactionOutputSegmentIds, CompactionBacklogError, createManifest, createGarbageCollectionJobRecord, storeNames, advanceGarbageCollectionJobRecord as advanceGarbageCollectionJobRecordUnchecked, BlockReadBatchTooLargeError, activePostingStorageColumnIds, assertTempRunPageBatchLimits, assertStorageBulkReadItems, assertTransactionArtifactBatchLimits, assertTransactionArtifactJournalLimits, boundedMaintenanceBatchItems, canonicalManifestChangedTableIds, catalogRecordRetainedBytes, manifestRecordRetainedReservationBytes, segmentRecordRetainedBytes, collectFtsPostings, ftsPostingQueryMatches, invalidateUncoveredFtsColumns, invalidateUncoveredSecondaryIndexes, GarbageCollectionJobConflictError, LeaseConflictError, LeaseExpiredError, LeaseOwnerConflictError, MAX_FTS_CANDIDATE_ROW_IDS, MAX_ACTIVE_UNIQUE_KEY_BUILDS, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES_TOTAL, MAX_UNIQUE_KEY_BUILD_CHUNK_BYTES, MAX_UNIQUE_KEY_BUILD_TOKENS_PER_CHUNK, MAX_UNIQUE_KEY_BUILD_TTL_MS, MAX_FTS_BASE_CHUNKS, MAX_FTS_DELTA_CHUNKS, MAX_FTS_POSTINGS_PER_CHUNK, MAX_FTS_POSTING_ROW_IDS_PER_CHUNK, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_FTS_TOKENS_PER_DOCUMENT, MAX_FTS_ORDERED_READ_BYTES, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_MANIFEST_RECORDS, MAX_MANIFEST_RETAINED_BYTES, MAX_BLOCK_READ_BATCH_BYTES, MAX_STORAGE_ID_CHARACTERS, MAX_LEASE_TTL_MS, MAX_ACTIVE_LEASES, MAX_ACTIVE_TRANSACTIONS, MAX_GLOBAL_STAGED_ARTIFACT_BYTES, MAX_GLOBAL_STAGED_BLOCKS, MAX_GLOBAL_STAGED_SEGMENTS, MAX_RETIRED_HISTORY_BYTES, MAX_PINNED_MANIFEST_VERSION_LAG, MAX_PINNED_RETIRED_BLOCKS, MAX_PINNED_RETIRED_BYTES, MAX_TERMINAL_TRANSACTION_RECORDS, MAX_ACTIVE_COMPACTION_JOBS, MAX_ACTIVE_GARBAGE_COLLECTION_JOBS, MAX_TERMINAL_COMPACTION_JOB_RECORDS, MAX_COMPLETED_GARBAGE_COLLECTION_JOB_RECORDS, MAX_CATALOG_RECORDS, MAX_CATALOG_RETAINED_BYTES, MAX_SEGMENT_RECORDS, MAX_SEGMENT_RETAINED_BYTES, MAX_ACTIVE_FTS_BASE_BUILDS, MAX_ACTIVE_SECONDARY_INDEX_BUILDS, MAX_ACCELERATOR_BUILD_STAGED_BYTES_TOTAL, MAX_ACCELERATOR_BUILD_STAGED_ENTRIES_TOTAL, MAX_POSTING_BUILD_TTL_MS, MAX_SNAPSHOT_SESSION_TTL_MS, MAX_SNAPSHOT_FRAME_BATCH_BYTES, MAX_SNAPSHOT_FRAME_BATCH_ITEMS, MAX_SNAPSHOT_METADATA_BATCH_BYTES, MAX_SNAPSHOT_METADATA_FRAME_BYTES, SNAPSHOT_FRAME_KINDS, MAX_LEVEL_ZERO_SEGMENTS, MAX_AUTO_INCREMENT_EXCLUSIVE_END, MAX_ROW_ID, MAX_ROW_ID_EXCLUSIVE_END, StorageCorruptionError, StorageFormatVersionError, IndexedDbSchemaUpgradeBlockedError, StorageResourceLimitError, SnapshotManifestMissingError, SnapshotImportConflictError, PostingBuildConflictError, validateTableForeignKey, TableInUseError, TableRecordConflictError, TempOwnerConflictError, MAX_TEMP_OWNER_TTL_MS, MAX_ACTIVE_TEMP_OWNERS, MAX_TEMP_RUNS_PER_OWNER, MAX_TEMP_PAGES_PER_OWNER, MAX_TEMP_RUNS_TOTAL, MAX_TEMP_PAGES_TOTAL, MAX_TEMP_BYTES_PER_OWNER, MAX_TEMP_BYTES_TOTAL, TransactionRecordConflictError, UniqueKeyConflictError, UniqueKeyBuildConflictError, UniqueIndexCoverageError, SchemaConflictError, normalizeCompactionJobRecord, normalizeGarbageCollectionJobRecord, normalizeSegmentRecord, updateCompactionJobRecord as updateCompactionJobRecordUnchecked, updateGarbageCollectionPlanningRecord, updateTransactionRecord as updateTransactionRecordUnchecked, validateColumnDefault, validateCatalogName, validateCanonicalManifestChangedTableIds, validateEnumValues, validateFtsOrderedReadLimits, validateFtsPostingQueries, validateStorageId, validateStorageDatabaseName, validateTableColumns, validateSecondaryIndexes, validateTableRecordBounds, secondaryIndexColumnIds, secondaryIndexWriteContractChanged, secondaryUniqueKeyNamespace, transactionCommitDeltaRetainedBytes, uniqueKeyBuildChunkRetainedBytes, WriteConflictError, } from "./types.js";
+import { CompactionJobConflictError, assertCompactionOutputProvenance, compactionOutputSegmentIds, CompactionBacklogError, createManifest, createGarbageCollectionJobRecord, storeNames, advanceGarbageCollectionJobRecord as advanceGarbageCollectionJobRecordUnchecked, BlockReadBatchTooLargeError, activePostingStorageColumnIds, assertTempRunPageBatchLimits, assertStorageBulkReadItems, assertTransactionArtifactBatchLimits, assertTransactionArtifactJournalLimits, boundedMaintenanceBatchItems, canonicalManifestChangedTableIds, catalogRecordRetainedBytes, manifestRecordRetainedReservationBytes, segmentRecordRetainedBytes, collectFtsPostings, ftsPostingQueryMatches, invalidateUncoveredFtsColumns, invalidateUncoveredSecondaryIndexes, GarbageCollectionJobConflictError, LeaseConflictError, LeaseExpiredError, LeaseOwnerConflictError, MAX_FTS_CANDIDATE_ROW_IDS, MAX_ACTIVE_UNIQUE_KEY_BUILDS, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES_TOTAL, MAX_UNIQUE_KEY_BUILD_CHUNK_BYTES, MAX_UNIQUE_KEY_BUILD_TOKENS_PER_CHUNK, MAX_UNIQUE_KEY_BUILD_TTL_MS, MAX_FTS_BASE_CHUNKS, MAX_FTS_DELTA_CHUNKS, MAX_FTS_POSTINGS_PER_CHUNK, MAX_FTS_POSTING_ROW_IDS_PER_CHUNK, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_FTS_TOKENS_PER_DOCUMENT, MAX_FTS_ORDERED_READ_BYTES, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_MANIFEST_RECORDS, MAX_MANIFEST_RETAINED_BYTES, MAX_BLOCK_READ_BATCH_BYTES, MAX_STORAGE_ID_CHARACTERS, MAX_LEASE_TTL_MS, MAX_ACTIVE_LEASES, MAX_ACTIVE_TRANSACTIONS, MAX_GLOBAL_STAGED_ARTIFACT_BYTES, MAX_GLOBAL_STAGED_BLOCKS, MAX_GLOBAL_STAGED_SEGMENTS, MAX_RETIRED_HISTORY_BYTES, MAX_PINNED_MANIFEST_VERSION_LAG, MAX_PINNED_RETIRED_BLOCKS, MAX_PINNED_RETIRED_BYTES, MAX_TERMINAL_TRANSACTION_RECORDS, MAX_ACTIVE_COMPACTION_JOBS, MAX_ACTIVE_GARBAGE_COLLECTION_JOBS, MAX_TERMINAL_COMPACTION_JOB_RECORDS, MAX_COMPLETED_GARBAGE_COLLECTION_JOB_RECORDS, MAX_CATALOG_RECORDS, MAX_CATALOG_RETAINED_BYTES, MAX_SEGMENT_RECORDS, MAX_SEGMENT_RETAINED_BYTES, MAX_ACTIVE_FTS_BASE_BUILDS, MAX_ACTIVE_SECONDARY_INDEX_BUILDS, MAX_ACCELERATOR_BUILD_STAGED_BYTES_TOTAL, MAX_ACCELERATOR_BUILD_STAGED_ENTRIES_TOTAL, MAX_POSTING_BUILD_TTL_MS, MAX_SNAPSHOT_SESSION_TTL_MS, MAX_SNAPSHOT_FRAME_BATCH_BYTES, MAX_SNAPSHOT_FRAME_BATCH_ITEMS, MAX_SNAPSHOT_METADATA_BATCH_BYTES, MAX_SNAPSHOT_METADATA_FRAME_BYTES, SNAPSHOT_FRAME_KINDS, MAX_LEVEL_ZERO_SEGMENTS, MAX_AUTO_INCREMENT_EXCLUSIVE_END, MAX_ROW_ID, MAX_ROW_ID_EXCLUSIVE_END, StorageCorruptionError, StorageFormatVersionError, IndexedDbSchemaUpgradeBlockedError, StorageResourceLimitError, SnapshotManifestMissingError, SnapshotImportConflictError, PostingBuildConflictError, validateTableForeignKey, TableInUseError, TableRecordConflictError, TempOwnerConflictError, MAX_TEMP_OWNER_TTL_MS, MAX_ACTIVE_TEMP_OWNERS, MAX_TEMP_RUNS_PER_OWNER, MAX_TEMP_PAGES_PER_OWNER, MAX_TEMP_RUNS_TOTAL, MAX_TEMP_PAGES_TOTAL, MAX_TEMP_BYTES_PER_OWNER, MAX_TEMP_BYTES_TOTAL, TransactionRecordConflictError, UniqueKeyConflictError, UniqueKeyBuildConflictError, UniqueIndexCoverageError, SchemaConflictError, normalizeCompactionJobRecord, normalizeGarbageCollectionJobRecord, normalizeSegmentRecord, updateCompactionJobRecord as updateCompactionJobRecordUnchecked, updateGarbageCollectionPlanningRecord, updateTransactionRecord as updateTransactionRecordUnchecked, validateColumnDefault, validateCatalogName, validateCanonicalManifestChangedTableIds, validateEnumValues, validateFtsCandidateLimit, validateFtsOrderedReadLimits, validateFtsReadVersion, validateFtsPostingQueries, validateStorageId, validateStorageDatabaseName, validateTableColumns, validateSecondaryIndexes, validateTableRecordBounds, secondaryIndexColumnIds, secondaryIndexWriteContractChanged, secondaryUniqueKeyNamespace, transactionCommitDeltaRetainedBytes, uniqueKeyBuildChunkRetainedBytes, WriteConflictError, } from "./types.js";
 import { crc32, verifyStoredBlock } from "../block-format/index.js";
 import { dateIsoString } from "../date-value.js";
 import { decodeSnapshotMetadataItems, encodeSnapshotMetadataPage, extendSnapshotFrameStreamChecksum, prepareSnapshotFrameStreamHeader, snapshotFrameEnvelopeParts, snapshotFrameStreamHeaderIdentity, } from "./snapshot-stream.js";
@@ -1769,11 +1769,8 @@ export class IndexedDbBlockStore {
         validateId(tableId, "Table ID");
         validateId(columnId, "Column ID");
         validateFtsPostingQueries(terms);
-        if (!Number.isSafeInteger(maxRowIds) ||
-            maxRowIds < 1 ||
-            maxRowIds > MAX_FTS_CANDIDATE_ROW_IDS) {
-            throw new RangeError(`Full-text candidate limit must be between 1 and ${String(MAX_FTS_CANDIDATE_ROW_IDS)}`);
-        }
+        validateFtsReadVersion(upToVersion);
+        validateFtsCandidateLimit(maxRowIds);
         const transaction = this.#transaction("catalog", "readonly");
         const store = transaction.objectStore("catalog");
         const [rawToc, rawDeltaIndex] = await Promise.all([
@@ -1870,9 +1867,7 @@ export class IndexedDbBlockStore {
     async readFtsPostings(tableId, columnId, upToVersion, maxRowIds = MAX_FTS_CANDIDATE_ROW_IDS, maxRetainedBytes = MAX_FTS_ORDERED_READ_BYTES) {
         validateId(tableId, "Table ID");
         validateId(columnId, "Column ID");
-        if (!Number.isSafeInteger(upToVersion) || upToVersion < 0) {
-            throw new RangeError("Full-text snapshot version must be a non-negative safe integer");
-        }
+        validateFtsReadVersion(upToVersion);
         validateFtsOrderedReadLimits(maxRowIds, maxRetainedBytes);
         const transaction = this.#transaction("catalog", "readonly");
         const store = transaction.objectStore("catalog");
@@ -6983,20 +6978,15 @@ function createCurrentIndexedDbSchema(database, upgrade) {
     for (const storeName of storeNames)
         database.createObjectStore(storeName);
     database.createObjectStore(SNAPSHOT_HEADER_STORE);
-    upgrade.objectStore("segments").createIndex(SEGMENT_TABLE_INDEX, "tableId");
-    upgrade.objectStore("leases").createIndex(LEASE_EXPIRY_INDEX, ["expiresAt", "id"]);
-    upgrade.objectStore("transactions").createIndex(TRANSACTION_STATUS_INDEX, "status");
-    upgrade.objectStore("temp").createIndex(TEMP_OWNER_EXPIRY_INDEX, ["expiresAt", "ownerId"]);
-    upgrade.objectStore("catalog").createIndex(CATALOG_FTS_BUILD_UPDATED_INDEX, "updatedAt");
-    upgrade.objectStore("catalog").createIndex(CATALOG_FTS_BUILD_EXPIRY_INDEX, "ftsBuildExpiry");
-    upgrade
-        .objectStore("catalog")
-        .createIndex(CATALOG_FTS_RETIREMENT_UPDATED_INDEX, "retirementUpdatedAt");
-    upgrade.objectStore("catalog").createIndex(UNIQUE_KEY_BUILD_ACTIVE_INDEX, "activeBuildState");
-    upgrade.objectStore("catalog").createIndex(UNIQUE_KEY_BUILD_EXPIRY_INDEX, "activeExpiry");
-    upgrade.objectStore("catalog").createIndex(MANIFEST_BLOCK_ID_INDEX, "blockId", {
-        unique: true,
-    });
+    // Creation is driven by the same declaration validateCurrentIndexedDbSchema verifies
+    // against, so the two can never disagree about what the current schema is.
+    for (const [storeName, indexes] of Object.entries(indexedDbIndexSchema)) {
+        const store = upgrade.objectStore(storeName);
+        for (const index of indexes) {
+            const keyPath = typeof index.keyPath === "string" ? index.keyPath : [...index.keyPath];
+            store.createIndex(index.name, keyPath, { unique: index.unique ?? false });
+        }
+    }
     upgrade.objectStore("gc").add(emptyMaintenanceQuota(), MAINTENANCE_QUOTA_KEY);
     upgrade.objectStore("statistics").add(emptyResourceLedger(), RESOURCE_LEDGER_KEY);
     upgrade.objectStore("statistics").add(emptyCatalogResourceLedger(), CATALOG_RESOURCE_LEDGER_KEY);

package/dist/storage/opfs/leader.js

@@ -1,4 +1,4 @@
-import { activePostingStorageColumnIds, assertStorageBulkReadItems, assertTempRunPageBatchLimits, BlockReadBatchTooLargeError, collectFtsPostingsBounded, ftsPostingQueryMatches, MAX_BLOCK_READ_BATCH_BYTES, MAX_FTS_BASE_CHUNKS, MAX_POSTING_BUILD_TTL_MS, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_STORAGE_ID_CHARACTERS, MAX_TEMP_RUN_PAGE_BYTES, MAX_TEMP_RUN_PAGES_PER_BATCH, MAX_TEMP_RUN_BATCH_BYTES, MAX_TEMP_RUNS_PER_OWNER, MAX_TEMP_PAGES_PER_OWNER, MAX_TEMP_RUNS_TOTAL, MAX_TEMP_PAGES_TOTAL, MAX_TEMP_BYTES_PER_OWNER, MAX_TEMP_BYTES_TOTAL, MAX_ACTIVE_FTS_BASE_BUILDS, MAX_ACTIVE_SECONDARY_INDEX_BUILDS, MAX_ACCELERATOR_BUILD_STAGED_BYTES_TOTAL, MAX_ACCELERATOR_BUILD_STAGED_ENTRIES_TOTAL, MAX_FTS_CANDIDATE_ROW_IDS, MAX_FTS_ORDERED_READ_BYTES, MAX_SNAPSHOT_SESSION_TTL_MS, MAX_SNAPSHOT_FRAME_BATCH_BYTES, MAX_SNAPSHOT_FRAME_BATCH_ITEMS, MAX_SNAPSHOT_METADATA_BATCH_BYTES, SNAPSHOT_FRAME_KINDS, MAX_TRANSACTION_STAGE_BLOCKS, MAX_TRANSACTION_STAGE_SEGMENTS, SnapshotImportConflictError, PostingBuildConflictError, StorageResourceLimitError, StorageCorruptionError, StorageFormatVersionError, validateFtsPostingQueries, validateFtsOrderedReadLimits, uniqueKeyBuildChunkRetainedBytes, } from "../types.js";
+import { activePostingStorageColumnIds, assertStorageBulkReadItems, assertTempRunPageBatchLimits, BlockReadBatchTooLargeError, collectFtsPostingsBounded, ftsPostingQueryMatches, MAX_BLOCK_READ_BATCH_BYTES, MAX_FTS_BASE_CHUNKS, MAX_POSTING_BUILD_TTL_MS, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_STORAGE_ID_CHARACTERS, MAX_TEMP_RUN_PAGE_BYTES, MAX_TEMP_RUN_PAGES_PER_BATCH, MAX_TEMP_RUN_BATCH_BYTES, MAX_TEMP_RUNS_PER_OWNER, MAX_TEMP_PAGES_PER_OWNER, MAX_TEMP_RUNS_TOTAL, MAX_TEMP_PAGES_TOTAL, MAX_TEMP_BYTES_PER_OWNER, MAX_TEMP_BYTES_TOTAL, MAX_ACTIVE_FTS_BASE_BUILDS, MAX_ACTIVE_SECONDARY_INDEX_BUILDS, MAX_ACCELERATOR_BUILD_STAGED_BYTES_TOTAL, MAX_ACCELERATOR_BUILD_STAGED_ENTRIES_TOTAL, MAX_FTS_CANDIDATE_ROW_IDS, MAX_FTS_ORDERED_READ_BYTES, MAX_SNAPSHOT_SESSION_TTL_MS, MAX_SNAPSHOT_FRAME_BATCH_BYTES, MAX_SNAPSHOT_FRAME_BATCH_ITEMS, MAX_SNAPSHOT_METADATA_BATCH_BYTES, SNAPSHOT_FRAME_KINDS, MAX_TRANSACTION_STAGE_BLOCKS, MAX_TRANSACTION_STAGE_SEGMENTS, SnapshotImportConflictError, PostingBuildConflictError, StorageResourceLimitError, StorageCorruptionError, StorageFormatVersionError, validateFtsPostingQueries, validateFtsCandidateLimit, validateFtsOrderedReadLimits, validateFtsReadVersion, uniqueKeyBuildChunkRetainedBytes, } from "../types.js";
 import { dateIsoString } from "../../date-value.js";
 import { decodeSnapshotMetadataItems, encodeSnapshotMetadataPage, extendSnapshotFrameStreamChecksum, prepareSnapshotFrameStreamHeader, snapshotFrameEnvelopeParts, snapshotFrameStreamHeaderIdentity, } from "../snapshot-stream.js";
 import { RecordCore, validateBeginTransactionInput, validateBlockWriteBytes, validateFtsBaseInput, validateFtsPostingChunks, validateId, validateTempRunPage, validateTempRunPageIdentity, } from "../toolkit/record-core.js";
@@ -2485,9 +2485,7 @@ export class OpfsLeader {
         validateId(tableId);
         validateId(columnId);
         validateFtsPostingQueries(terms);
-        if (!Number.isSafeInteger(upToVersion) || upToVersion < -1) {
-            throw new RangeError("Full-text query version must be a safe integer at least -1");
-        }
+        validateFtsReadVersion(upToVersion);
         validateFtsCandidateLimit(maxRowIds);
         return this.#run(async () => {
             // Unlike immutable table blocks, derived-index extents are not protected by reader leases:
@@ -2553,9 +2551,7 @@ export class OpfsLeader {
     async readFtsPostings(tableId, columnId, upToVersion, maxRowIds = MAX_FTS_CANDIDATE_ROW_IDS, maxRetainedBytes = MAX_FTS_ORDERED_READ_BYTES) {
         validateId(tableId);
         validateId(columnId);
-        if (!Number.isSafeInteger(upToVersion) || upToVersion < -1) {
-            throw new RangeError("Full-text query version must be a safe integer at least -1");
-        }
+        validateFtsReadVersion(upToVersion);
         validateFtsOrderedReadLimits(maxRowIds, maxRetainedBytes);
         return this.#run(async () => {
             const key = postingStorageKey(tableId, columnId);
@@ -4041,11 +4037,6 @@ function requireCoverageVersion(value, label) {
     if (!Number.isSafeInteger(value) || value < -1)
         throw new Error(`Invalid ${label}`);
 }
-function validateFtsCandidateLimit(value) {
-    if (!Number.isSafeInteger(value) || value < 1 || value > MAX_FTS_CANDIDATE_ROW_IDS) {
-        throw new RangeError(`Full-text candidate limit must be between 1 and ${String(MAX_FTS_CANDIDATE_ROW_IDS)}`);
-    }
-}
 function requirePositiveInteger(value, label) {
     if (!Number.isSafeInteger(value) || value < 1)
         throw new Error(`Invalid ${label}`);

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

@@ -1,4 +1,4 @@
-import { CompactionBacklogError, CompactionJobConflictError, assertCompactionOutputProvenance, compactionOutputSegmentIds, createManifest, createGarbageCollectionJobRecord, advanceGarbageCollectionJobRecord, collectFtsCandidates, collectFtsPostingsBounded, activePostingStorageColumnIds, invalidateUncoveredFtsColumns, invalidateUncoveredSecondaryIndexes, GarbageCollectionJobConflictError, LeaseConflictError, LeaseExpiredError, LeaseOwnerConflictError, MAX_LEASE_TTL_MS, MAX_ACTIVE_LEASES, MAX_ACTIVE_TEMP_OWNERS, MAX_ACTIVE_COMPACTION_JOBS, MAX_ACTIVE_UNIQUE_KEY_BUILDS, MAX_ACTIVE_TRANSACTIONS, MAX_TERMINAL_TRANSACTION_RECORDS, MAX_TERMINAL_COMPACTION_JOB_RECORDS, MAX_COMPLETED_GARBAGE_COLLECTION_JOB_RECORDS, MAX_PINNED_MANIFEST_VERSION_LAG, MAX_PINNED_RETIRED_BLOCKS, MAX_PINNED_RETIRED_BYTES, MAX_RETIRED_HISTORY_BYTES, MAX_GLOBAL_STAGED_ARTIFACT_BYTES, MAX_GLOBAL_STAGED_BLOCKS, MAX_GLOBAL_STAGED_SEGMENTS, MAX_TEMP_OWNER_TTL_MS, MAX_ROW_ID, MAX_ROW_ID_EXCLUSIVE_END, MAX_AUTO_INCREMENT_EXCLUSIVE_END, MAX_LEVEL_ZERO_SEGMENTS, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_STORAGE_ID_CHARACTERS, MAX_CATALOG_RECORDS, MAX_CATALOG_RETAINED_BYTES, MAX_MANIFEST_RECORDS, MAX_MANIFEST_RETAINED_BYTES, MAX_SEGMENT_RECORDS, MAX_SEGMENT_RETAINED_BYTES, MAX_FTS_CANDIDATE_ROW_IDS, MAX_FTS_POSTINGS_PER_CHUNK, MAX_FTS_POSTING_ROW_IDS_PER_CHUNK, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_FTS_TOKENS_PER_DOCUMENT, MAX_FTS_BASE_CHUNKS, MAX_FTS_DELTA_CHUNKS, SnapshotManifestMissingError, StorageResourceLimitError, TableInUseError, TableRecordConflictError, TempOwnerConflictError, TransactionRecordConflictError, UniqueKeyConflictError, UniqueKeyBuildConflictError, UniqueIndexCoverageError, assertTransactionArtifactBatchLimits, assertTransactionArtifactJournalLimits, assertTempRunPageBatchLimits, assertStorageBulkReadItems, boundedMaintenanceBatchItems, normalizeCompactionJobRecord, normalizeGarbageCollectionJobRecord, normalizeSegmentRecord, updateCompactionJobRecord, updateTransactionRecord, updateGarbageCollectionPlanningRecord, validateTableColumns, validateTableForeignKey, validateSecondaryIndexes, secondaryIndexColumnIds, secondaryIndexWriteContractChanged, secondaryUniqueKeyNamespace, transactionCommitDeltaRetainedBytes, uniqueKeyBuildChunkRetainedBytes, MAX_UNIQUE_KEY_BUILD_TTL_MS, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES_TOTAL, MAX_UNIQUE_KEY_BUILD_TOKENS_PER_CHUNK, validateFtsPostingQueries, validateCanonicalManifestChangedTableIds, catalogRecordRetainedBytes, manifestRecordRetainedReservationBytes, segmentRecordRetainedBytes, snapshotAcceleratorItemRetainedUsage, assertSnapshotImportAcceleratorUsage, SchemaConflictError, WriteConflictError, } from "../types.js";
+import { CompactionBacklogError, CompactionJobConflictError, assertCompactionOutputProvenance, compactionOutputSegmentIds, createManifest, createGarbageCollectionJobRecord, advanceGarbageCollectionJobRecord, collectFtsCandidates, collectFtsPostingsBounded, validateFtsCandidateLimit, validateFtsReadVersion, activePostingStorageColumnIds, invalidateUncoveredFtsColumns, invalidateUncoveredSecondaryIndexes, GarbageCollectionJobConflictError, LeaseConflictError, LeaseExpiredError, LeaseOwnerConflictError, MAX_LEASE_TTL_MS, MAX_ACTIVE_LEASES, MAX_ACTIVE_TEMP_OWNERS, MAX_ACTIVE_COMPACTION_JOBS, MAX_ACTIVE_UNIQUE_KEY_BUILDS, MAX_ACTIVE_TRANSACTIONS, MAX_TERMINAL_TRANSACTION_RECORDS, MAX_TERMINAL_COMPACTION_JOB_RECORDS, MAX_COMPLETED_GARBAGE_COLLECTION_JOB_RECORDS, MAX_PINNED_MANIFEST_VERSION_LAG, MAX_PINNED_RETIRED_BLOCKS, MAX_PINNED_RETIRED_BYTES, MAX_RETIRED_HISTORY_BYTES, MAX_GLOBAL_STAGED_ARTIFACT_BYTES, MAX_GLOBAL_STAGED_BLOCKS, MAX_GLOBAL_STAGED_SEGMENTS, MAX_TEMP_OWNER_TTL_MS, MAX_ROW_ID, MAX_ROW_ID_EXCLUSIVE_END, MAX_AUTO_INCREMENT_EXCLUSIVE_END, MAX_LEVEL_ZERO_SEGMENTS, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_STORAGE_ID_CHARACTERS, MAX_CATALOG_RECORDS, MAX_CATALOG_RETAINED_BYTES, MAX_MANIFEST_RECORDS, MAX_MANIFEST_RETAINED_BYTES, MAX_SEGMENT_RECORDS, MAX_SEGMENT_RETAINED_BYTES, MAX_FTS_CANDIDATE_ROW_IDS, MAX_FTS_POSTINGS_PER_CHUNK, MAX_FTS_POSTING_ROW_IDS_PER_CHUNK, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_FTS_TOKENS_PER_DOCUMENT, MAX_FTS_BASE_CHUNKS, MAX_FTS_DELTA_CHUNKS, SnapshotManifestMissingError, StorageResourceLimitError, TableInUseError, TableRecordConflictError, TempOwnerConflictError, TransactionRecordConflictError, UniqueKeyConflictError, UniqueKeyBuildConflictError, UniqueIndexCoverageError, assertTransactionArtifactBatchLimits, assertTransactionArtifactJournalLimits, assertTempRunPageBatchLimits, assertStorageBulkReadItems, boundedMaintenanceBatchItems, normalizeCompactionJobRecord, normalizeGarbageCollectionJobRecord, normalizeSegmentRecord, updateCompactionJobRecord, updateTransactionRecord, updateGarbageCollectionPlanningRecord, validateTableColumns, validateTableForeignKey, validateSecondaryIndexes, secondaryIndexColumnIds, secondaryIndexWriteContractChanged, secondaryUniqueKeyNamespace, transactionCommitDeltaRetainedBytes, uniqueKeyBuildChunkRetainedBytes, MAX_UNIQUE_KEY_BUILD_TTL_MS, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES_TOTAL, MAX_UNIQUE_KEY_BUILD_TOKENS_PER_CHUNK, validateFtsPostingQueries, validateCanonicalManifestChangedTableIds, catalogRecordRetainedBytes, manifestRecordRetainedReservationBytes, segmentRecordRetainedBytes, snapshotAcceleratorItemRetainedUsage, assertSnapshotImportAcceleratorUsage, SchemaConflictError, WriteConflictError, } from "../types.js";
 import { dateIsoString } from "../../date-value.js";
 import { assertWellFormedString, crc32, MAX_STORED_BLOCK_BYTE_LENGTH, } from "../../block-format/index.js";
 /**
@@ -1729,9 +1729,7 @@ export class RecordCore {
         validateId(tableId);
         validateId(columnId);
         validateFtsPostingQueries(terms);
-        if (!Number.isSafeInteger(upToVersion) || upToVersion < -1) {
-            throw new RangeError("Full-text query version must be a safe integer at least -1");
-        }
+        validateFtsReadVersion(upToVersion);
         validateFtsCandidateLimit(maxRowIds);
         const key = `${tableId}/${columnId}`;
         const base = this.#ftsBases.get(key);
@@ -1834,9 +1832,7 @@ export class RecordCore {
     readFtsPostings(tableId, columnId, upToVersion, maxRowIds = MAX_FTS_CANDIDATE_ROW_IDS, maxRetainedBytes) {
         validateId(tableId);
         validateId(columnId);
-        if (!Number.isSafeInteger(upToVersion) || upToVersion < -1) {
-            throw new RangeError("Full-text query version must be a safe integer at least -1");
-        }
+        validateFtsReadVersion(upToVersion);
         const base = this.#ftsBases.get(`${tableId}/${columnId}`);
         const coversVersion = base?.coversVersion ?? -1;
         const delta = this.readFtsDeltas(tableId, columnId, coversVersion, upToVersion);
@@ -6489,11 +6485,6 @@ function sortedVersionInInterval(versions, addedVersion, removedVersion) {
     const version = versions[low];
     return version !== undefined && (removedVersion === null || version < removedVersion);
 }
-function validateFtsCandidateLimit(value) {
-    if (!Number.isSafeInteger(value) || value < 1 || value > MAX_FTS_CANDIDATE_ROW_IDS) {
-        throw new RangeError(`Full-text candidate limit must be between 1 and ${String(MAX_FTS_CANDIDATE_ROW_IDS)}`);
-    }
-}
 function varuintByteLength(value) {
     let length = 1;
     while (value >= 0x80n) {

package/dist/storage/types.d.ts

@@ -534,8 +534,6 @@ export interface CompactionJobCursor {
     sourceSegmentIndex: number;
     sourceBlockIndex: number;
 }
-export declare const compactionRewritePlanKinds: readonly ["copy-v1", "rechunk-v1", "merge-v1"];
-export type CompactionRewritePlanKind = (typeof compactionRewritePlanKinds)[number];
 export interface CopyCompactionRewritePlan {
     readonly kind: "copy-v1";
 }
@@ -1669,6 +1667,10 @@ export declare function ftsPostingQueryMatches(term: string, query: FtsPostingQu
  * never drift between backends — pruning would silently differ per store.
  */
 export declare function collectFtsCandidates(chunkLists: Iterable<readonly FtsPosting[]>, terms: readonly FtsPostingQuery[], maxRowIds?: number): FtsCandidates;
+/** Validates the snapshot bound of one full-text read; -1 selects the base view alone. */
+export declare function validateFtsReadVersion(upToVersion: number): void;
+/** Validates the candidate row-ID ceiling accepted by one full-text candidate read. */
+export declare function validateFtsCandidateLimit(maxRowIds: number): void;
 /** Validates the fixed memory ceilings accepted by one ordered postings read. */
 export declare function validateFtsOrderedReadLimits(maxRowIds?: number, maxRetainedBytes?: number): void;
 /**
@@ -2422,7 +2424,6 @@ export declare function createManifest(input: CreateManifestInput): Manifest;
 export declare function normalizeSegmentRecord(record: SegmentRecord): SegmentRecord;
 export declare function updateTransactionRecord(record: TransactionRecord, update: TransactionRecordUpdate): TransactionRecord;
 export declare function createGarbageCollectionJobRecord(input: CreateGarbageCollectionJobInput): GarbageCollectionJobRecord;
-export declare function normalizeGarbageCollectionDiscovery(discovery: GarbageCollectionDiscovery): GarbageCollectionDiscovery;
 export declare function updateGarbageCollectionPlanningRecord(record: GarbageCollectionJobRecord, input: UpdateGarbageCollectionPlanningInput): GarbageCollectionJobRecord;
 export declare function normalizeGarbageCollectionJobRecord(record: GarbageCollectionJobRecord): GarbageCollectionJobRecord;
 export declare function advanceGarbageCollectionJobRecord(record: GarbageCollectionJobRecord, accounting: GarbageCollectionStepAccounting): GarbageCollectionJobRecord;

package/dist/storage/types.js

@@ -726,7 +726,6 @@ export const compactionJobStates = [
     "cancelled",
     "aborted",
 ];
-export const compactionRewritePlanKinds = ["copy-v1", "rechunk-v1", "merge-v1"];
 export const compactionOutputCompressions = ["raw", "gzip"];
 /** Every segment ID owned by a compaction job, including merge partition outputs. */
 export function compactionOutputSegmentIds(job) {
@@ -1427,6 +1426,18 @@ export function collectFtsCandidates(chunkLists, terms, maxRowIds = MAX_FTS_CAND
         overflow: false,
     };
 }
+/** Validates the snapshot bound of one full-text read; -1 selects the base view alone. */
+export function validateFtsReadVersion(upToVersion) {
+    if (!Number.isSafeInteger(upToVersion) || upToVersion < -1) {
+        throw new RangeError("Full-text query version must be a safe integer at least -1");
+    }
+}
+/** Validates the candidate row-ID ceiling accepted by one full-text candidate read. */
+export function validateFtsCandidateLimit(maxRowIds) {
+    if (!Number.isSafeInteger(maxRowIds) || maxRowIds < 1 || maxRowIds > MAX_FTS_CANDIDATE_ROW_IDS) {
+        throw new RangeError(`Full-text candidate limit must be between 1 and ${String(MAX_FTS_CANDIDATE_ROW_IDS)}`);
+    }
+}
 /** Validates the fixed memory ceilings accepted by one ordered postings read. */
 export function validateFtsOrderedReadLimits(maxRowIds = MAX_FTS_CANDIDATE_ROW_IDS, maxRetainedBytes = MAX_FTS_ORDERED_READ_BYTES) {
     if (!Number.isSafeInteger(maxRowIds) || maxRowIds < 1 || maxRowIds > MAX_FTS_CANDIDATE_ROW_IDS) {
@@ -1940,7 +1951,7 @@ export function createGarbageCollectionJobRecord(input) {
         ...(discovery === undefined ? {} : { discovery }),
     };
 }
-export function normalizeGarbageCollectionDiscovery(discovery) {
+function normalizeGarbageCollectionDiscovery(discovery) {
     const runtime = discovery;
     if (typeof runtime !== "object" || runtime === null) {
         throw new TypeError("Garbage collection discovery must be an object");

package/dist/testing/block-store-conformance.js

@@ -1008,6 +1008,34 @@ export function blockStoreConformanceCases() {
                     { term: "minnows", rowIds: [2n], tf: [1] },
                     { term: "shark", rowIds: [4n], tf: [1] },
                 ], "ordered postings must merge into canonical term and row-ID order");
+                // The read-argument contract is uniform across adapters: -1 selects the base view
+                // alone, anything below it (or non-integral) is refused, and the candidate limit is
+                // validated on every read path.
+                const baseOnly = await store.readFtsPostings("table-t", "col-v", -1);
+                check(baseOnly.hasBase && baseOnly.postings.length === 3, "an upToVersion of -1 must serve the base view alone");
+                for (const version of [-2, Number.NaN, 1.5]) {
+                    try {
+                        await store.readFtsCandidates("table-t", "col-v", [{ term: "minnow", prefix: false }], version);
+                        throw new Error(`candidate read accepted invalid version ${String(version)}`);
+                    }
+                    catch (error) {
+                        check(error instanceof RangeError, "invalid candidate versions must throw RangeError");
+                    }
+                    try {
+                        await store.readFtsPostings("table-t", "col-v", version);
+                        throw new Error(`postings read accepted invalid version ${String(version)}`);
+                    }
+                    catch (error) {
+                        check(error instanceof RangeError, "invalid postings versions must throw RangeError");
+                    }
+                }
+                try {
+                    await store.readFtsCandidates("table-t", "col-v", [{ term: "minnow", prefix: false }], 10, 0);
+                    throw new Error("candidate read accepted a zero row-ID limit");
+                }
+                catch (error) {
+                    check(error instanceof RangeError, "invalid candidate limits must throw RangeError");
+                }
                 store.close();
             },
         },

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

@@ -1,38 +1,6 @@
 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" | "datasetList" | "datasetCreate" | "datasetDelete" | "runQuery" | "suiteReference" | "suiteWrite" | "suiteFeatureMatrix" | "suiteLive";
-export interface WorkerRequest<T = unknown> {
-    version: typeof protocolVersion;
-    requestId: string;
-    operation: WorkerOperation;
-    payload: T;
-}
-export interface SuccessResponse<T = unknown> {
-    version: typeof protocolVersion;
-    requestId: string;
-    kind: "success";
-    result: T;
-}
-export interface FailureResponse {
-    version: typeof protocolVersion;
-    requestId: string;
-    kind: "failure";
-    error: {
-        name: string;
-        message: string;
-    };
-}
-export interface ProgressResponse<T = unknown> {
-    version: typeof protocolVersion;
-    requestId: string;
-    kind: "progress";
-    progress: T;
-}
-export type WorkerResponse<T = unknown> = SuccessResponse<T> | FailureResponse | ProgressResponse;
-export declare function parseRequest(value: unknown): WorkerRequest;
-export declare function success<T>(requestId: string, result: T): SuccessResponse<T>;
-export declare function failure(requestId: string, error: unknown): FailureResponse;
 export type RpcRequest = {
     version: typeof protocolVersion;
     requestId: string;

package/dist/worker-protocol/index.js

@@ -1,31 +1,6 @@
 export const protocolVersion = 3;
 /** Outstanding request/response pairs retained by either side of one database RPC connection. */
 export const MAX_DATABASE_RPC_IN_FLIGHT = 256;
-export function parseRequest(value) {
-    if (typeof value !== "object" || value === null)
-        throw new TypeError("Request must be an object");
-    const candidate = value;
-    if (candidate.version !== protocolVersion)
-        throw new Error("Unsupported protocol version");
-    if (typeof candidate.requestId !== "string" || candidate.requestId.length === 0) {
-        throw new TypeError("Request ID must be a non-empty string");
-    }
-    if (!isOperation(candidate.operation))
-        throw new Error("Unsupported worker operation");
-    return candidate;
-}
-export function success(requestId, result) {
-    return { version: protocolVersion, requestId, kind: "success", result };
-}
-export function failure(requestId, error) {
-    const normalized = error instanceof Error ? error : new Error(String(error));
-    return {
-        version: protocolVersion,
-        requestId,
-        kind: "failure",
-        error: { name: normalized.name, message: normalized.message },
-    };
-}
 export function serializeError(error) {
     if (!(error instanceof Error)) {
         return { name: "Error", message: String(error) };
@@ -101,17 +76,3 @@ export function parseRpcResponse(value) {
         throw new Error("Unsupported protocol version");
     return candidate;
 }
-function isOperation(value) {
-    return [
-        "benchmark",
-        "cancelBenchmark",
-        "datasetList",
-        "datasetCreate",
-        "datasetDelete",
-        "runQuery",
-        "suiteReference",
-        "suiteWrite",
-        "suiteFeatureMatrix",
-        "suiteLive",
-    ].includes(String(value));
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.6.6",
+  "version": "0.6.7",
   "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",