@minnowdb/core 0.7.10 → 0.9.0

package/dist/storage/opfs/store.js

@@ -1,4 +1,4 @@
-import { assertStorageBulkReadItems, assertTempRunPageBatchLimits, OpfsUncertainOutcomeError, StorageCorruptionError, StorageFormatVersionError, validateStorageDatabaseName } from "../types.js";
+import { assertStorageBulkReadItems, assertTempRunPageBatchLimits, OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError, StorageCorruptionError, StorageFormatVersionError, validateStorageDatabaseName } from "../types.js";
 import { validateTempRunPage, validateTempRunPageIdentity } from "../toolkit/record-core.js";
 import { OpfsTree, encodeSegment, isDomError } from "./files.js";
 import { LOG_FORMAT_VERSION } from "../toolkit/wire.js";
@@ -193,6 +193,7 @@ class OpfsBlockStore {
   #servedRequestLocks = /* @__PURE__ */ new Map();
   #inFlightMutationBytes = 0;
   #inFlightReadBytes = 0;
+  #readCapacityChanged;
   #settledMutationBytes = 0;
   #pendingRpcBytes = 0;
   #servedRequestCount = 0;
@@ -209,25 +210,41 @@ class OpfsBlockStore {
     this.#channelName = `minnowdb-store:${options.name}`;
     this.liveQueryChannelName = `minnowdb-live:opfs:${options.name}`;
   }
+  #releaseConnectionLock;
   static async open(options) {
-    const tree = new OpfsTree(await resolveDatabaseRoot(options));
-    const store = new OpfsBlockStore(tree, options);
-    await store.#ensureFormatMarker();
-    if (typeof BroadcastChannel === "function") {
-      const onMessage = (event) => {
-        const message = parseStoreRpcMessage(event.data, RPC_METHODS);
-        if (message !== void 0)
-          store.#onMessage(message);
-      };
-      const channel = new BroadcastChannel(store.#channelName);
-      channel.onmessage = onMessage;
-      const inbox = new BroadcastChannel(store.#inboxName(store.#instanceId));
-      inbox.onmessage = onMessage;
-      store.#channel = channel;
-      store.#inbox = inbox;
-    }
-    await store.#tryBecomeLeader();
-    return store;
+    const ownedOptions = { ...options };
+    validateStorageDatabaseName(ownedOptions.name);
+    const release = await holdConnectionLock(ownedOptions.name);
+    let store;
+    try {
+      const tree = new OpfsTree(await resolveDatabaseRoot(ownedOptions));
+      store = new OpfsBlockStore(tree, ownedOptions);
+    } catch (error) {
+      release?.();
+      throw error;
+    }
+    store.#releaseConnectionLock = release;
+    try {
+      await store.#ensureFormatMarker();
+      if (typeof BroadcastChannel === "function") {
+        const onMessage = (event) => {
+          const message = parseStoreRpcMessage(event.data, RPC_METHODS);
+          if (message !== void 0)
+            store.#onMessage(message);
+        };
+        const channel = new BroadcastChannel(store.#channelName);
+        channel.onmessage = onMessage;
+        store.#channel = channel;
+        const inbox = new BroadcastChannel(store.#inboxName(store.#instanceId));
+        inbox.onmessage = onMessage;
+        store.#inbox = inbox;
+      }
+      await store.#tryBecomeLeader();
+      return store;
+    } catch (error) {
+      store.close();
+      throw error;
+    }
   }
   async #tryBecomeLeader() {
     if (this.#closed)
@@ -305,11 +322,15 @@ class OpfsBlockStore {
     this.#leader = void 0;
     this.#knownLeader = void 0;
     this.#lastYieldAt = Date.now();
-    try {
-      await leader.shutdown();
-    } catch {
+    const shutdown = leader.shutdown().catch(() => {
       leader.crash();
-    }
+    });
+    this.#yielding = shutdown;
+    await shutdown;
+    if (this.#yielding === shutdown)
+      this.#yielding = void 0;
+    if (this.#closed)
+      return;
     this.#closeAnswerChannels();
     this.#post({ kind: "yield", to });
     if (this.#reacquireTimer !== void 0)
@@ -319,9 +340,12 @@ class OpfsBlockStore {
         void this.#tryBecomeLeader();
     }, 1500);
   }
+  #yielding;
   #onMessage(message) {
     if (this.#closed)
       return;
+    if (this.#coordinationPausedForTests)
+      return;
     switch (message.kind) {
       case "op": {
         if (this.#leader !== void 0) {
@@ -331,7 +355,7 @@ class OpfsBlockStore {
               kind: "result",
               requestId: message.requestId,
               ok: false,
-              error: { name: "Error", message: "The OPFS leader RPC queue is full" }
+              error: serializeStoreError(new OpfsCoordinationError("leader-queue-full", message.method))
             });
             return;
           }
@@ -481,26 +505,33 @@ class OpfsBlockStore {
           kind: "result",
           requestId: message.requestId,
           ok: false,
-          error: { name: "Error", message: "The OPFS leader mutation queue is full" }
+          error: serializeStoreError(new OpfsCoordinationError("mutation-queue-full", message.method))
         });
         return;
       }
       if (isRead) {
         const reservation = Math.max(fingerprint.retainedBytes, MAX_OPFS_RPC_MESSAGE_BYTES);
-        if (this.#inFlightReadBytes + reservation > RPC_IN_FLIGHT_READ_BYTES) {
-          this.#answer(message.from, {
-            kind: "result",
-            requestId: message.requestId,
-            ok: false,
-            error: { name: "Error", message: "The OPFS leader read queue is full" }
-          });
-          return;
+        while (this.#inFlightReadBytes + reservation > RPC_IN_FLIGHT_READ_BYTES) {
+          this.#answer(message.from, { kind: "busy", requestId: message.requestId });
+          if (this.#readCapacityChanged === void 0) {
+            let resolve;
+            const promise = new Promise((done) => {
+              resolve = done;
+            });
+            this.#readCapacityChanged = { promise, resolve };
+          }
+          await this.#readCapacityChanged.promise;
+          if (this.#closed || this.#leader !== leader)
+            return;
         }
+        if (this.#closed || this.#leader !== leader)
+          return;
         this.#inFlightReadBytes += reservation;
         try {
           settled = await this.#executeServedOpAfterGate(leader, message, true);
         } finally {
           this.#inFlightReadBytes = Math.max(0, this.#inFlightReadBytes - reservation);
+          this.#wakeReadWaiters();
         }
       } else {
         this.#inFlightMutationBytes += fingerprint.retainedBytes;
@@ -565,6 +596,11 @@ class OpfsBlockStore {
       }
     });
   }
+  #wakeReadWaiters() {
+    const waiting = this.#readCapacityChanged;
+    this.#readCapacityChanged = void 0;
+    waiting?.resolve();
+  }
   async #executeServedOpAfterGate(leader, message, isRead) {
     const gate = this.#servedMutationGateForTests;
     if (!isRead && gate !== void 0)
@@ -674,7 +710,7 @@ class OpfsBlockStore {
         throw error;
       }
     }
-    throw new Error("The OPFS store could not reach or become a leader");
+    throw new OpfsCoordinationError("leader-unavailable", method);
   }
   #leaderKnown() {
     return this.#knownLeader !== void 0;
@@ -687,7 +723,7 @@ class OpfsBlockStore {
       return Promise.reject(error instanceof Error ? error : new Error(String(error)));
     }
     if (this.#pending.size >= RPC_IN_FLIGHT_LIMIT || this.#pendingRpcBytes + retainedBytes > RPC_IN_FLIGHT_MUTATION_BYTES) {
-      return Promise.reject(new Error("The OPFS follower request queue is full"));
+      return Promise.reject(new OpfsCoordinationError("follower-queue-full", method));
     }
     return new Promise((resolve, reject) => {
       const message = { kind: "op", requestId, from: this.#instanceId, method, args };
@@ -754,6 +790,7 @@ class OpfsBlockStore {
     this.#pendingRpcBytes = 0;
     this.#inFlightMutationBytes = 0;
     this.#inFlightReadBytes = 0;
+    this.#wakeReadWaiters();
     this.#settledMutationBytes = 0;
     this.#servedRequestCount = 0;
     this.#servedRequestBytes = 0;
@@ -765,14 +802,31 @@ class OpfsBlockStore {
       }).then(() => {
         this.#post({ kind: "released", leaderId: this.#instanceId });
         this.#closeChannels();
+        this.#releaseWhenHandlesClose();
       });
       return;
     }
     this.#closeChannels();
+    this.#releaseWhenHandlesClose();
+  }
+  #releaseWhenHandlesClose() {
+    const release = this.#releaseConnectionLock;
+    this.#releaseConnectionLock = void 0;
+    if (this.#electing === void 0 && this.#yielding === void 0)
+      release?.();
+    else
+      void Promise.allSettled([this.#electing, this.#yielding]).then(() => release?.());
   }
   _isLeaderForTests() {
     return this.#leader !== void 0;
   }
+  #coordinationPausedForTests = false;
+  _pauseCoordinationForTests() {
+    this.#coordinationPausedForTests = true;
+    return () => {
+      this.#coordinationPausedForTests = false;
+    };
+  }
   _instanceIdForTests() {
     return this.#instanceId;
   }
@@ -820,12 +874,14 @@ class OpfsBlockStore {
     this.#pendingRpcBytes = 0;
     this.#inFlightMutationBytes = 0;
     this.#inFlightReadBytes = 0;
+    this.#wakeReadWaiters();
     this.#settledMutationBytes = 0;
     this.#servedRequestCount = 0;
     this.#servedRequestBytes = 0;
     this.#leader?.crash();
     this.#leader = void 0;
     this.#closeChannels();
+    this.#releaseWhenHandlesClose();
   }
   async #ensureFormatMarker() {
     const existing = await this.#tree.readFile(["format.json"], {
@@ -900,14 +956,34 @@ for (const method of RPC_METHODS) {
 }
 async function deleteOpfsDatabase(options) {
   const encodedName = encodeSegment(validateStorageDatabaseName(options.name));
-  const root = options.root ?? await navigator.storage.getDirectory();
-  try {
-    const namespace = await root.getDirectoryHandle("minnowdb");
-    await namespace.removeEntry(encodedName, { recursive: true });
-  } catch (error) {
-    if (!isDomError(error, "NotFoundError"))
-      throw error;
-  }
+  const locks = globalThis.navigator?.locks;
+  if (locks === void 0)
+    throw new Error("Deleting an OPFS database requires Web Locks");
+  await locks.request(connectionLockName(options.name), { mode: "exclusive", ifAvailable: true }, async (lock) => {
+    if (lock === null)
+      throw new OpfsDatabaseInUseError(options.name);
+    const root = options.root ?? await navigator.storage.getDirectory();
+    try {
+      const namespace = await root.getDirectoryHandle("minnowdb");
+      await namespace.removeEntry(encodedName, { recursive: true });
+    } catch (error) {
+      if (!isDomError(error, "NotFoundError"))
+        throw error;
+    }
+  });
+}
+function connectionLockName(name) {
+  return `minnowdb-opfs-connections:${name}`;
+}
+async function holdConnectionLock(name) {
+  const locks = globalThis.navigator?.locks;
+  if (locks === void 0)
+    return void 0;
+  return new Promise((resolve, reject) => {
+    void locks.request(connectionLockName(name), { mode: "shared" }, () => new Promise((release) => {
+      resolve(release);
+    })).catch(reject);
+  });
 }
 const RPC_TIMED_OUT = new Error("The leader did not answer in time");
 async function resolveDatabaseRoot(options) {

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

@@ -5711,6 +5711,7 @@ function collectIndexedPhysicalRoots(candidateSegmentIds, candidateBlockIds, man
   };
   const rootedBlockIds = /* @__PURE__ */ new Set();
   const rootedSegmentIds = /* @__PURE__ */ new Set();
+  const candidateSegments = new Set(candidateSegmentIds);
   for (const id of candidateSegmentIds) {
     const segment = segments.get(id);
     if (segment !== void 0 && isSegmentRoot(segment))
@@ -5723,7 +5724,7 @@ function collectIndexedPhysicalRoots(candidateSegmentIds, candidateBlockIds, man
     }
     for (const segmentId of segments.segmentIdsForBlock(id)) {
       const segment = segments.get(segmentId);
-      if (segment !== void 0 && isSegmentRoot(segment)) {
+      if (segment !== void 0 && (!candidateSegments.has(segmentId) || rootedSegmentIds.has(segmentId))) {
         rootedBlockIds.add(id);
         break;
       }

package/dist/storage/types.d.ts

@@ -1360,6 +1360,20 @@ export declare class OpfsUncertainOutcomeError extends Error {
     readonly name = "OpfsUncertainOutcomeError";
     constructor(method: string);
 }
+/** Temporary OPFS coordination failure. No operation was admitted, or a read exhausted retries. */
+export declare class OpfsCoordinationError extends Error {
+    readonly reason: "leader-unavailable" | "leader-queue-full" | "mutation-queue-full" | "follower-queue-full";
+    readonly method: string | null;
+    readonly name = "OpfsCoordinationError";
+    readonly backend = "opfs";
+    constructor(reason: "leader-unavailable" | "leader-queue-full" | "mutation-queue-full" | "follower-queue-full", method?: string | null);
+}
+/** Deletion was refused before removing files because another connection still owns the store. */
+export declare class OpfsDatabaseInUseError extends Error {
+    readonly databaseName: string;
+    readonly name = "OpfsDatabaseInUseError";
+    constructor(databaseName: string);
+}
 /**
  * The commit input carries only the change: added blocks are the transaction's journaled pending
  * blocks, removals are the superseded ids. The store derives the published manifest from its

package/dist/storage/types.js

@@ -1005,6 +1005,25 @@ class OpfsUncertainOutcomeError extends Error {
     this.method = method;
   }
 }
+class OpfsCoordinationError extends Error {
+  reason;
+  method;
+  name = "OpfsCoordinationError";
+  backend = "opfs";
+  constructor(reason, method = null) {
+    super(reason === "leader-queue-full" ? "The OPFS leader RPC queue is full" : reason === "mutation-queue-full" ? "The OPFS leader mutation queue is full" : reason === "follower-queue-full" ? "The OPFS follower request queue is full" : "The OPFS store could not reach or become a leader");
+    this.reason = reason;
+    this.method = method;
+  }
+}
+class OpfsDatabaseInUseError extends Error {
+  databaseName;
+  name = "OpfsDatabaseInUseError";
+  constructor(databaseName) {
+    super(`The OPFS database ${databaseName} is open; close all connections before deleting it`);
+    this.databaseName = databaseName;
+  }
+}
 const MAX_UNIQUE_KEY_BUILD_TOKENS_PER_CHUNK = 4096;
 const MAX_UNIQUE_KEY_BUILD_CHUNK_BYTES = 4 * 1024 * 1024;
 const MAX_UNIQUE_KEY_BUILD_TTL_MS = 60 * 60 * 1e3;
@@ -3025,6 +3044,8 @@ export {
   MAX_UNIQUE_KEY_BUILD_STAGED_BYTES_TOTAL,
   MAX_UNIQUE_KEY_BUILD_TOKENS_PER_CHUNK,
   MAX_UNIQUE_KEY_BUILD_TTL_MS,
+  OpfsCoordinationError,
+  OpfsDatabaseInUseError,
   OpfsUncertainOutcomeError,
   PostingBuildConflictError,
   SNAPSHOT_FRAME_KINDS,

package/dist/transactions/index.d.ts

@@ -32,6 +32,8 @@ export interface OpenLeasedSnapshotOptions {
     version?: number | null;
 }
 export interface BeginDeferredOptions {
+    /** Keep successive stages local while their combined artifacts fit one storage batch. */
+    coalesceArtifacts?: boolean;
     /**
      * Pins the captured snapshot with a renewable durable reader lease until this transaction
      * either persists its own durable owner or finishes. Enabled by default; tightly bounded
@@ -97,6 +99,7 @@ export declare class DatabaseTransaction {
         deref(): DatabaseTransaction | undefined;
     }, options?: {
         persisted?: boolean;
+        coalesceArtifacts?: boolean;
         initialCatalogProbe?: {
             catalogEpoch: number;
             manifestVersion: number | null;

package/dist/transactions/index.js

@@ -119,6 +119,7 @@ class DatabaseTransaction {
   #deferredSegments = [];
   #knownSegments = /* @__PURE__ */ new Map();
   #persisted;
+  #coalesceArtifacts;
   #snapshotLease;
   #snapshotLeaseOperation = Promise.resolve();
   #snapshotRenewal;
@@ -131,6 +132,7 @@ class DatabaseTransaction {
     this.ttlMs = ttlMs;
     this.#record = structuredClone(record);
     this.#persisted = options.persisted ?? true;
+    this.#coalesceArtifacts = options.coalesceArtifacts ?? false;
     this.#initialCatalogProbe = options.initialCatalogProbe;
     this.#snapshotLease = options.snapshotLease;
     const reference = createWeakRef(this);
@@ -384,7 +386,7 @@ class DatabaseTransaction {
     if (blocks.length === 0 && ordered.length === 0)
       return;
     const batches = transactionArtifactBatches(blocks, ordered);
-    if (!this.#persisted && this.#deferredBlocks.length === 0 && this.#deferredSegments.length === 0 && batches.length === 1) {
+    if (!this.#persisted && (this.#coalesceArtifacts || this.#deferredBlocks.length === 0 && this.#deferredSegments.length === 0) && this.#deferredBlocks.length + blocks.length <= MAX_TRANSACTION_STAGE_BLOCKS && this.#deferredSegments.length + ordered.length <= MAX_TRANSACTION_STAGE_SEGMENTS && [...this.#deferredBlocks, ...blocks].reduce((bytes, block) => bytes + block.bytes.byteLength, 0) <= MAX_TRANSACTION_STAGE_BYTES && batches.length === 1) {
       assertTransactionArtifactBatchLimits(blocks, ordered);
       this.#deferredBlocks.push(...blocks.map((block) => ({ id: block.id, bytes: new Uint8Array(block.bytes) })));
       this.#deferredSegments.push(...structuredClone(ordered));
@@ -1120,6 +1122,7 @@ class TransactionManager {
         committedVersion: null
       }, this.#now, this.#transactionTtlMs, this.#createWeakRef, {
         persisted: false,
+        coalesceArtifacts: options.coalesceArtifacts ?? false,
         initialCatalogProbe: probe,
         ...snapshotLease === void 0 ? {} : { snapshotLease }
       });

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

@@ -1,4 +1,4 @@
-export declare const protocolVersion: 6;
+export declare const protocolVersion: 7;
 /** Outstanding request/response pairs retained by either side of one database RPC connection. */
 export declare const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 export type RpcRequest = {

package/dist/worker-protocol/index.js

@@ -1,4 +1,4 @@
-const protocolVersion = 6;
+const protocolVersion = 7;
 const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 function serializeError(error) {
   if (!(error instanceof Error)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.7.10",
+  "version": "0.9.0",
   "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",
@@ -32,7 +32,7 @@
     "./dist/engine/worker-memory.js"
   ],
   "scripts": {
-    "prepack": "node ../../scripts/strip-dist-comments.mjs dist"
+    "prepack": "node ../../scripts/prepare-package.mjs --strip-comments"
   },
   "exports": {
     ".": {

package/postgres-feature-profile.json

@@ -142,7 +142,7 @@
     {
       "id": "type.exact-numeric",
       "classification": "different",
-      "reason": "Minnow preserves exact decimals at the JavaScript boundary as strings, as PGlite's default decoder also does. A declared scale renders at exactly that scale as PostgreSQL does; a bare NUMERIC column, a derived arithmetic result, and a value cast or concatenated to text render canonically, without the trailing fractional zeros PostgreSQL preserves. Division and AVG select their result scale the way PostgreSQL does, so quotient digits agree — including AVG over a column whose declared scale exceeds the selection. The canonical encoding does drop a stored value's display scale, so an explicit arithmetic quotient (such as SUM(v) / COUNT(v)) over a column declared with more than about twenty fractional digits can carry fewer digits than PostgreSQL, which floors the selection at the operand's display scale. An arithmetic or comparison expression mixing a float column with a constant Float64 cannot represent stays exact, where PostgreSQL casts the constant to float8 and rounds it before evaluating."
+      "reason": "Minnow preserves exact decimals at the JavaScript boundary as strings, as PGlite's default decoder also does. A declared scale renders at exactly that scale as PostgreSQL does; a bare NUMERIC column, a derived arithmetic result, and a value cast or concatenated to text render canonically, without the trailing fractional zeros PostgreSQL preserves. Division and AVG select their result scale the way PostgreSQL does, so quotient digits agree \u2014 including AVG over a column whose declared scale exceeds the selection. The canonical encoding does drop a stored value's display scale, so an explicit arithmetic quotient (such as SUM(v) / COUNT(v)) over a column declared with more than about twenty fractional digits can carry fewer digits than PostgreSQL, which floors the selection at the operand's display scale. An arithmetic or comparison expression mixing a float column with a constant Float64 cannot represent stays exact, where PostgreSQL casts the constant to float8 and rounds it before evaluating."
     },
     {
       "id": "type.json-jsonb",
@@ -258,6 +258,11 @@
       "id": "privileges.grant",
       "classification": "inapplicable",
       "reason": "An embedded database has no server roles, owners, or GRANT boundary."
+    },
+    {
+      "id": "aggregate.array-agg",
+      "classification": "different",
+      "reason": "Minnow returns arrays as canonical JSON text at the JavaScript boundary; PostgreSQL clients return native arrays. ARRAY_AGG supports DISTINCT and ordering, but not FILTER or window use."
     }
   ]
 }

package/sql-feature-matrix.json

@@ -653,14 +653,13 @@
       "id": "window.frame",
       "status": "supported",
       "example": "SELECT amount, SUM(amount) OVER (ORDER BY amount, joined ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS windowed FROM rows",
-      "notes": "ROWS frames take row-distance bounds; RANGE frames take UNBOUNDED and CURRENT ROW bounds, where CURRENT ROW spans the ordering peer group."
+      "notes": "ROWS frames use row distances; RANGE frames use peers or numeric ordering-value distances; GROUPS frames use peer-group distances. Exclusions are supported."
     },
     {
       "id": "window.frame-range-offset",
-      "status": "unsupported",
+      "status": "supported",
       "example": "SELECT amount, SUM(amount) OVER (ORDER BY amount RANGE BETWEEN 1 PRECEDING AND CURRENT ROW) AS windowed FROM rows",
-      "error": "RANGE frames take only UNBOUNDED and CURRENT ROW bounds; use ROWS",
-      "notes": "A numeric RANGE offset bounds the frame by ordering-value distance, which the engine does not implement. ROWS frames take numeric offsets; RANGE frames take UNBOUNDED and CURRENT ROW bounds only."
+      "notes": "Numeric RANGE offsets measure ordering-value distance and require one numeric ORDER BY expression. Temporal interval offsets are not supported."
     },
     {
       "id": "window.distinct-aggregate",
@@ -671,10 +670,9 @@
     },
     {
       "id": "window.outside-select",
-      "status": "unsupported",
+      "status": "supported",
       "example": "SELECT amount FROM rows ORDER BY ROW_NUMBER() OVER (ORDER BY amount)",
-      "error": "Window functions are only allowed in the select list",
-      "notes": "PostgreSQL also evaluates window functions in ORDER BY; Minnow evaluates them only as select items. Alias the window in the select list and order by the alias."
+      "notes": "Window functions work in SELECT and ORDER BY. WHERE, GROUP BY, and HAVING cannot contain windows."
     },
     {
       "id": "join.right",
@@ -843,7 +841,7 @@
       "id": "expression.cast",
       "status": "supported",
       "example": "SELECT CAST(amount AS INTEGER) AS whole, CAST(amount AS TEXT) AS label FROM rows",
-      "notes": "Common PostgreSQL type names map to the four stored value kinds; integer targets round to the nearest integer with ties to even, PostgreSQL's float8 cast (SQLite truncates), and non-numeric strings fail rather than becoming 0. The postfix spelling amount::INTEGER is the same cast."
+      "notes": "Integer casts round exact NUMERIC ties away from zero and floating-point ties to even. Integer text accepts signed decimal digits. Postfix :: and CAST use the same rules."
     },
     {
       "id": "identifier.quoted",
@@ -928,10 +926,9 @@
     },
     {
       "id": "join.full-grouped",
-      "status": "unsupported",
+      "status": "supported",
       "example": "SELECT r.region AS region, COUNT(*) AS matched FROM rows r FULL JOIN dims d ON d.region = r.region GROUP BY r.region",
-      "error": "FULL JOIN cannot be combined with grouping, DISTINCT, or window functions yet",
-      "notes": "FULL JOIN desugars into a union of two left joins, and grouping, DISTINCT, and window functions do not distribute over that union yet. Put the FULL JOIN in a derived table and group, deduplicate, or window in the outer block."
+      "notes": "The sole FULL JOIN composes with grouping, DISTINCT, wildcards, and window functions by applying these operations after both unmatched sides are included."
     },
     {
       "id": "order-by.ordinal",
@@ -1114,10 +1111,9 @@
     },
     {
       "id": "join.full-compound-on",
-      "status": "unsupported",
-      "example": "SELECT r.region FROM rows r FULL JOIN keyed k ON k.name = r.region AND k.score > 0",
-      "error": "FULL JOIN requires a single equality ON condition",
-      "notes": "FULL JOIN takes a single equality ON condition; move the extra condition into a derived source."
+      "status": "supported",
+      "example": "SELECT r.region FROM rows r FULL JOIN dims d ON d.region = r.region AND d.label <> ''",
+      "notes": "A sole FULL JOIN accepts compound ON predicates and preserves unmatched rows from both sides."
     },
     {
       "id": "datetime.current-date",
@@ -1552,10 +1548,9 @@
     },
     {
       "id": "aggregate.array-agg",
-      "status": "unsupported",
-      "example": "SELECT region, array_agg(amount) AS amounts FROM rows GROUP BY region",
-      "error": "Unsupported function: array_agg",
-      "notes": "array_agg is not supported because arrays are not; json_agg (JSON_ARRAYAGG) collects a group into a JSON array instead."
+      "status": "supported",
+      "example": "SELECT region, array_agg(amount ORDER BY amount) AS amounts FROM rows GROUP BY region ORDER BY region",
+      "notes": "ARRAY_AGG supports DISTINCT and aggregate-local ORDER BY, includes NULL elements, and returns NULL for empty input. Arrays cross the JavaScript boundary as canonical JSON text. FILTER and window use are not supported."
     },
     {
       "id": "aggregate.ordered-set",
@@ -1568,14 +1563,13 @@
       "id": "type.array",
       "status": "supported",
       "example": "SELECT ARRAY[1, 2] AS pair",
-      "notes": "Constructors and array columns use canonical JSON text at the JavaScript boundary. Subscripts and array operators are not supported (see type.array-subscript, type.array-any, and array.concat)."
+      "notes": "Constructors and array columns use canonical JSON text at the JavaScript boundary. One-based scalar subscripts and ARRAY_AGG are supported. Array operators such as concatenation and ANY/ALL remain unsupported."
     },
     {
       "id": "type.array-subscript",
-      "status": "unsupported",
+      "status": "supported",
       "example": "SELECT (ARRAY[1, 2, 3])[1] AS first_element",
-      "error": "Array subscripts are not supported",
-      "notes": "PostgreSQL reads array elements with one-based subscripts and slices. Minnow arrays are opaque JSON text values; element access is refused at parse time."
+      "notes": "One-based scalar subscripts return NULL for an out-of-range position. Slices and multidimensional access are not supported."
     },
     {
       "id": "type.array-any",
@@ -1748,7 +1742,7 @@
       "status": "unsupported",
       "example": "SELECT INTERVAL '1 day' + INTERVAL '2 hours' AS total FROM rows",
       "error": "Date arithmetic requires a date or datetime value",
-      "notes": "Interval-valued arithmetic — interval + interval, timestamp - timestamp, date - date, date + integer, EXTRACT(EPOCH FROM interval), justify_days — is not supported. A date or datetime plus or minus an INTERVAL is; subtract two EXTRACT(EPOCH …) readings for a duration in seconds."
+      "notes": "Interval-valued arithmetic — interval + interval, timestamp - timestamp, date - date, date + integer, justify_days — is not supported. A date or datetime plus or minus an INTERVAL is; subtract two EXTRACT(EPOCH …) readings for a duration in seconds."
     },
     {
       "id": "expression.date-minus-date",
@@ -1828,10 +1822,9 @@
     },
     {
       "id": "function.unnest",
-      "status": "unsupported",
+      "status": "supported",
       "example": "SELECT x FROM unnest(ARRAY[3, 1, 2]) AS x",
-      "error": "Expected )",
-      "notes": "Set-returning functions (unnest, generate_series, regexp_split_to_table, jsonb_array_elements) are not supported as FROM sources; use a VALUES source, a recursive CTE for a series, or JSON_TABLE for a JSON array."
+      "notes": "UNNEST over an ARRAY constructor produces typed rows and supports WITH ORDINALITY and output column aliases. Table-correlated array inputs and arbitrary array expressions are not supported."
     },
     {
       "id": "function.generate-series",

package/dist/date-value.d.ts

@@ -1,20 +0,0 @@
-/** Returns a Date's internal millisecond value without invoking an instance override. */
-export declare function dateMilliseconds(value: Date): number;
-/** Copies a Date by its internal value without invoking instance methods. */
-export declare function copyDate(value: Date): Date;
-/** Formats a Date's internal value without invoking an instance override. */
-export declare function dateIsoString(value: Date): string;
-export declare function dateUtcFullYear(value: Date): number;
-export declare function dateUtcMonth(value: Date): number;
-export declare function dateUtcDate(value: Date): number;
-export declare function dateUtcDay(value: Date): number;
-export declare function dateUtcHours(value: Date): number;
-export declare function dateUtcMinutes(value: Date): number;
-export declare function dateUtcSeconds(value: Date): number;
-export declare function setDateUtcDate(value: Date, day: number): number;
-export declare function setDateUtcMonth(value: Date, month: number): number;
-/** Whole days since 1970-01-01 for an epoch-millisecond value (floored, so negatives work). */
-export declare function epochDays(milliseconds: number): number;
-export declare function civilFromDays(days: number): readonly [number, number, number];
-/** Days since 1970-01-01 for a civil date; month is 0-11 as in Date.UTC. */
-export declare function daysFromCivil(year: number, month: number, day: number): number;

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

@@ -1,29 +0,0 @@
-/** Snapshot of the byte-bounded artifact cache's lifetime counters. */
-interface ArtifactCacheStats {
-    limitBytes: number;
-    usedBytes: number;
-    entries: number;
-    hits: number;
-    misses: number;
-    evictions: number;
-}
-/**
- * Byte-bounded LRU for decoded blocks, vectors, derived results, and memoized query results.
- * Payloads are immutable by convention; callers own the byte estimates for their artifact type.
- *
- * Recency lives on an intrusive doubly-linked list rather than Map insertion order: a hit
- * relinks four pointers instead of deleting and re-inserting the key, which re-hashed the
- * long block-identity keys twice per touch and was the single hottest frame of a cached point
- * lookup.
- */
-export declare class ArtifactCache {
-    #private;
-    constructor(limitBytes: number);
-    get enabled(): boolean;
-    get(key: string): unknown;
-    put(key: string, payload: unknown, bytes: number): void;
-    /** Releases every retained payload while preserving lifetime counters for final diagnostics. */
-    clear(): void;
-    stats(): ArtifactCacheStats;
-}
-export {};

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

@@ -1,11 +0,0 @@
-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;