@minnowdb/core 0.6.9 → 0.7.1

package/dist/engine/typed-live.js

@@ -1,311 +1,289 @@
 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.
-    return Object.freeze([...rows]);
+  return Object.freeze([...rows]);
 }
-/**
- * One typed live SELECT. It is also a framework-neutral external store: getSnapshot is stable
- * until state changes and subscribe returns synchronous cleanup. Slow consumers coalesce to the
- * newest invalidation; errors retain the last good rows.
- */
-export class LiveQuery {
-    #listeners = new Set();
-    #source;
-    #backend;
-    #onClose;
-    #snapshot = { status: "loading", rows: [] };
-    #subscription;
-    #observationGeneration = 0;
-    #queued;
-    #execution;
-    #executionAbort;
-    #invalidationSequence = 0;
-    #closed = false;
-    constructor(backend, source, onClose) {
-        this.#backend = backend;
-        this.#source = source;
-        this.#onClose = onClose;
-    }
-    getSnapshot = () => this.#snapshot;
-    subscribe = (listener) => {
-        if (this.#closed)
-            throw new Error("Live query is closed");
-        // A subscription is a lease, even when a framework reuses the same callback function.
-        const registered = () => listener();
-        this.#listeners.add(registered);
-        if (this.#listeners.size === 1)
-            this.#startObservation();
-        let subscribed = true;
-        return () => {
-            if (!subscribed)
-                return;
-            subscribed = false;
-            this.#listeners.delete(registered);
-            if (this.#listeners.size === 0)
-                this.#stopObservation();
-        };
+class LiveQuery {
+  #listeners = /* @__PURE__ */ new Set();
+  #source;
+  #backend;
+  #onClose;
+  #snapshot = { status: "loading", rows: [] };
+  #subscription;
+  #observationGeneration = 0;
+  #queued;
+  #execution;
+  #executionAbort;
+  #invalidationSequence = 0;
+  #closed = false;
+  constructor(backend, source, onClose) {
+    this.#backend = backend;
+    this.#source = source;
+    this.#onClose = onClose;
+  }
+  getSnapshot = () => this.#snapshot;
+  subscribe = (listener) => {
+    if (this.#closed)
+      throw new Error("Live query is closed");
+    const registered = () => listener();
+    this.#listeners.add(registered);
+    if (this.#listeners.size === 1)
+      this.#startObservation();
+    let subscribed = true;
+    return () => {
+      if (!subscribed)
+        return;
+      subscribed = false;
+      this.#listeners.delete(registered);
+      if (this.#listeners.size === 0)
+        this.#stopObservation();
     };
-    async refresh() {
-        if (this.#closed)
-            throw new Error("Live query is closed");
-        const sequence = this.#invalidationSequence;
-        if (this.#listeners.size > 0) {
-            // A transient dependency/observer setup failure must not strand existing subscribers.
-            // Re-open first so this refresh and future commits reach the query again.
-            if (this.#subscription === undefined)
-                this.#startObservation();
-            const opening = this.#subscription;
-            if (opening !== undefined)
-                await opening.catch(() => undefined);
-            await this.#backend.refresh();
-        }
-        // A backend refresh normally invalidates observers itself. Only synthesize an execution
-        // when it did not, which preserves manual retry without running every refreshed query twice.
-        if (this.#invalidationSequence === sequence) {
-            const version = this.#snapshot.status === "loading" ? null : this.#snapshot.version;
-            this.#schedule({ manifestVersion: version, catalogEpoch: 0, initial: false });
-        }
-        await this.#waitForIdle();
+  };
+  async refresh() {
+    if (this.#closed)
+      throw new Error("Live query is closed");
+    const sequence = this.#invalidationSequence;
+    if (this.#listeners.size > 0) {
+      if (this.#subscription === void 0)
+        this.#startObservation();
+      const opening = this.#subscription;
+      if (opening !== void 0)
+        await opening.catch(() => void 0);
+      await this.#backend.refresh();
     }
-    close() {
-        if (this.#closed)
-            return;
-        this.#closed = true;
-        this.#observationGeneration += 1;
-        this.#executionAbort?.abort(new Error("Live query is closed"));
-        const subscription = this.#subscription;
-        this.#subscription = undefined;
-        if (subscription !== undefined) {
-            void subscription.then((handle) => handle.close()).catch(() => undefined);
-        }
-        // Wake iterators before removing their listeners so a parked next() terminates.
-        this.#emit();
-        this.#listeners.clear();
-        this.#onClose?.();
+    if (this.#invalidationSequence === sequence) {
+      const version = this.#snapshot.status === "loading" ? null : this.#snapshot.version;
+      this.#schedule({ manifestVersion: version, catalogEpoch: 0, initial: false });
     }
-    #startObservation() {
-        if (this.#subscription !== undefined || this.#closed)
-            return;
-        const generation = (this.#observationGeneration += 1);
-        const subscription = this.#backend.observe(this.#source.query, {
-            onInvalidate: (invalidation) => {
-                if (generation !== this.#observationGeneration || this.#closed)
-                    return;
-                this.#schedule(invalidation);
-            },
-            onError: (error) => {
-                if (generation !== this.#observationGeneration || this.#closed)
-                    return;
-                this.#setError(error, this.#currentVersion());
-            },
-            onComplete: () => {
-                if (generation !== this.#observationGeneration)
-                    return;
-                this.#subscription = undefined;
-            },
-        });
-        this.#subscription = subscription;
-        subscription.catch((error) => {
-            if (generation !== this.#observationGeneration || this.#closed)
-                return;
-            this.#subscription = undefined;
-            this.#setError(error, this.#currentVersion());
-        });
+    await this.#waitForIdle();
+  }
+  close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    this.#observationGeneration += 1;
+    this.#executionAbort?.abort(new Error("Live query is closed"));
+    const subscription = this.#subscription;
+    this.#subscription = void 0;
+    if (subscription !== void 0) {
+      void subscription.then((handle) => handle.close()).catch(() => void 0);
     }
-    #stopObservation() {
-        this.#observationGeneration += 1;
-        this.#executionAbort?.abort(new Error("Live query has no subscribers"));
-        const subscription = this.#subscription;
-        this.#subscription = undefined;
-        if (subscription !== undefined) {
-            void subscription.then((handle) => handle.close()).catch(() => undefined);
-        }
-    }
-    #schedule(invalidation) {
-        this.#invalidationSequence += 1;
-        this.#queued = invalidation;
-        if (this.#execution !== undefined)
-            return;
-        const execution = this.#drain();
-        this.#execution = execution;
-        void execution.finally(() => {
-            if (this.#execution === execution)
-                this.#execution = undefined;
-            if (this.#queued !== undefined && !this.#closed)
-                this.#schedule(this.#queued);
-        });
+    this.#emit();
+    this.#listeners.clear();
+    this.#onClose?.();
+  }
+  #startObservation() {
+    if (this.#subscription !== void 0 || this.#closed)
+      return;
+    const generation = this.#observationGeneration += 1;
+    const subscription = this.#backend.observe(this.#source.query, {
+      onInvalidate: (invalidation) => {
+        if (generation !== this.#observationGeneration || this.#closed)
+          return;
+        this.#schedule(invalidation);
+      },
+      onError: (error) => {
+        if (generation !== this.#observationGeneration || this.#closed)
+          return;
+        this.#setError(error, this.#currentVersion());
+      },
+      onComplete: () => {
+        if (generation !== this.#observationGeneration)
+          return;
+        this.#subscription = void 0;
+      }
+    });
+    this.#subscription = subscription;
+    subscription.catch((error) => {
+      if (generation !== this.#observationGeneration || this.#closed)
+        return;
+      this.#subscription = void 0;
+      this.#setError(error, this.#currentVersion());
+    });
+  }
+  #stopObservation() {
+    this.#observationGeneration += 1;
+    this.#executionAbort?.abort(new Error("Live query has no subscribers"));
+    const subscription = this.#subscription;
+    this.#subscription = void 0;
+    if (subscription !== void 0) {
+      void subscription.then((handle) => handle.close()).catch(() => void 0);
     }
-    async #drain() {
-        while (this.#queued !== undefined && !this.#closed) {
-            const invalidation = this.#queued;
-            this.#queued = undefined;
-            const abort = new AbortController();
-            this.#executionAbort = abort;
-            try {
-                const rows = immutableRows(await this.#source.execute(abort.signal));
-                if (this.#executionWasCancelled(abort))
-                    continue;
-                // A newer invalidation arrived while this ran. Skip the intermediate snapshot and let
-                // the loop execute once more against the newest durable state.
-                if (this.#hasQueuedInvalidation())
-                    continue;
-                const previous = this.#snapshot.rows;
-                if (this.#snapshot.status === "ready" &&
-                    this.#snapshot.version === invalidation.manifestVersion &&
-                    sameLiveValue(previous, rows)) {
-                    continue;
-                }
-                if (sameLiveValue(previous, rows) && this.#snapshot.status !== "loading") {
-                    // Advance the version without replacing the immutable row array.
-                    this.#snapshot = {
-                        status: "ready",
-                        rows: previous,
-                        version: invalidation.manifestVersion,
-                    };
-                }
-                else {
-                    this.#snapshot = {
-                        status: "ready",
-                        rows,
-                        version: invalidation.manifestVersion,
-                    };
-                }
-                this.#emit();
-            }
-            catch (error) {
-                if (this.#executionWasCancelled(abort) || this.#hasQueuedInvalidation())
-                    continue;
-                this.#setError(error, invalidation.manifestVersion);
-            }
-            finally {
-                if (this.#executionAbort === abort)
-                    this.#executionAbort = undefined;
-            }
+  }
+  #schedule(invalidation) {
+    this.#invalidationSequence += 1;
+    this.#queued = invalidation;
+    if (this.#execution !== void 0)
+      return;
+    const execution = this.#drain();
+    this.#execution = execution;
+    void execution.finally(() => {
+      if (this.#execution === execution)
+        this.#execution = void 0;
+      if (this.#queued !== void 0 && !this.#closed)
+        this.#schedule(this.#queued);
+    });
+  }
+  async #drain() {
+    while (this.#queued !== void 0 && !this.#closed) {
+      const invalidation = this.#queued;
+      this.#queued = void 0;
+      const abort = new AbortController();
+      this.#executionAbort = abort;
+      try {
+        const rows = immutableRows(await this.#source.execute(abort.signal));
+        if (this.#executionWasCancelled(abort))
+          continue;
+        if (this.#hasQueuedInvalidation())
+          continue;
+        const previous = this.#snapshot.rows;
+        if (this.#snapshot.status === "ready" && this.#snapshot.version === invalidation.manifestVersion && sameLiveValue(previous, rows)) {
+          continue;
         }
-    }
-    #executionWasCancelled(abort) {
-        return abort.signal.aborted || this.#closed;
-    }
-    #hasQueuedInvalidation() {
-        return this.#queued !== undefined;
-    }
-    async #waitForIdle() {
-        for (;;) {
-            const execution = this.#execution;
-            if (execution === undefined)
-                return;
-            await execution;
-            if (this.#execution === undefined && this.#queued === undefined)
-                return;
+        if (sameLiveValue(previous, rows) && this.#snapshot.status !== "loading") {
+          this.#snapshot = {
+            status: "ready",
+            rows: previous,
+            version: invalidation.manifestVersion
+          };
+        } else {
+          this.#snapshot = {
+            status: "ready",
+            rows,
+            version: invalidation.manifestVersion
+          };
         }
+        this.#emit();
+      } catch (error) {
+        if (this.#executionWasCancelled(abort) || this.#hasQueuedInvalidation())
+          continue;
+        this.#setError(error, invalidation.manifestVersion);
+      } finally {
+        if (this.#executionAbort === abort)
+          this.#executionAbort = void 0;
+      }
     }
-    #currentVersion() {
-        return this.#snapshot.status === "loading" ? null : this.#snapshot.version;
+  }
+  #executionWasCancelled(abort) {
+    return abort.signal.aborted || this.#closed;
+  }
+  #hasQueuedInvalidation() {
+    return this.#queued !== void 0;
+  }
+  async #waitForIdle() {
+    for (; ; ) {
+      const execution = this.#execution;
+      if (execution === void 0)
+        return;
+      await execution;
+      if (this.#execution === void 0 && this.#queued === void 0)
+        return;
     }
-    #setError(error, version) {
-        this.#snapshot = { status: "error", rows: this.#snapshot.rows, error, version };
-        this.#emit();
+  }
+  #currentVersion() {
+    return this.#snapshot.status === "loading" ? null : this.#snapshot.version;
+  }
+  #setError(error, version) {
+    this.#snapshot = { status: "error", rows: this.#snapshot.rows, error, version };
+    this.#emit();
+  }
+  #emit() {
+    for (const listener of [...this.#listeners]) {
+      try {
+        listener();
+      } catch {
+      }
     }
-    #emit() {
-        for (const listener of [...this.#listeners]) {
-            try {
-                listener();
-            }
-            catch {
-                // One framework listener must not prevent the others from observing the same snapshot.
-            }
+  }
+  [Symbol.asyncIterator]() {
+    const inbox = {
+      latest: this.#snapshot,
+      hasLatest: true,
+      stopped: false,
+      notify: void 0
+    };
+    const wake = () => {
+      const notify = inbox.notify;
+      inbox.notify = void 0;
+      notify?.();
+    };
+    const unsubscribe = this.subscribe(() => {
+      inbox.latest = this.#snapshot;
+      inbox.hasLatest = true;
+      wake();
+    });
+    const done = { done: true, value: void 0 };
+    const read = async () => {
+      for (; ; ) {
+        if (inbox.stopped || this.#closed)
+          return done;
+        if (inbox.hasLatest) {
+          inbox.hasLatest = false;
+          return { done: false, value: inbox.latest };
         }
-    }
-    [Symbol.asyncIterator]() {
-        const inbox = {
-            latest: this.#snapshot,
-            hasLatest: true,
-            stopped: false,
-            notify: undefined,
-        };
-        const wake = () => {
-            const notify = inbox.notify;
-            inbox.notify = undefined;
-            notify?.();
-        };
-        const unsubscribe = this.subscribe(() => {
-            inbox.latest = this.#snapshot;
-            inbox.hasLatest = true;
-            wake();
+        await new Promise((resolve) => {
+          inbox.notify = resolve;
         });
-        const done = { done: true, value: undefined };
-        const read = async () => {
-            for (;;) {
-                if (inbox.stopped || this.#closed)
-                    return done;
-                if (inbox.hasLatest) {
-                    inbox.hasLatest = false;
-                    return { done: false, value: inbox.latest };
-                }
-                await new Promise((resolve) => {
-                    inbox.notify = resolve;
-                });
-            }
-        };
-        let queue = Promise.resolve();
-        return {
-            next: () => {
-                const result = queue.then(read, read);
-                queue = result.then(() => undefined, () => undefined);
-                return result;
-            },
-            return: async () => {
-                inbox.stopped = true;
-                wake();
-                unsubscribe();
-                return done;
-            },
-            throw: async (error) => {
-                inbox.stopped = true;
-                wake();
-                unsubscribe();
-                throw error;
-            },
-        };
-    }
+      }
+    };
+    let queue = Promise.resolve();
+    return {
+      next: () => {
+        const result = queue.then(read, read);
+        queue = result.then(() => void 0, () => void 0);
+        return result;
+      },
+      return: async () => {
+        inbox.stopped = true;
+        wake();
+        unsubscribe();
+        return done;
+      },
+      throw: async (error) => {
+        inbox.stopped = true;
+        wake();
+        unsubscribe();
+        throw error;
+      }
+    };
+  }
 }
-/** Owns one shared low-level set and every typed query created from it. */
-export class LiveQueryManager {
-    #backend;
-    #queries = new Set();
-    #closed = false;
-    constructor(driver, options = {}) {
-        this.#backend = driver.liveQueries(options);
-    }
-    watch(source) {
-        if (this.#closed)
-            throw new Error("Live query manager is closed");
-        const query = new LiveQuery(this.#backend, source, () => {
-            this.#queries.delete(query);
-        });
-        this.#queries.add(query);
-        return query;
-    }
-    async refresh() {
-        if (this.#closed)
-            throw new Error("Live query manager is closed");
-        // The shared backend sweep remains selective. Queries that were already in an adapter-level
-        // error also run their local retry path; concurrent backend refresh calls collapse into the
-        // same low-level sweep, so this does not multiply durable probes.
-        const failed = [...this.#queries].filter((query) => query.getSnapshot().status === "error");
-        await Promise.all([this.#backend.refresh(), ...failed.map((query) => query.refresh())]);
-    }
-    async close() {
-        if (this.#closed)
-            return;
-        this.#closed = true;
-        for (const query of [...this.#queries])
-            query.close();
-        this.#queries.clear();
-        await this.#backend.close();
-    }
+class LiveQueryManager {
+  #backend;
+  #queries = /* @__PURE__ */ new Set();
+  #closed = false;
+  constructor(driver, options = {}) {
+    this.#backend = driver.liveQueries(options);
+  }
+  watch(source) {
+    if (this.#closed)
+      throw new Error("Live query manager is closed");
+    const query = new LiveQuery(this.#backend, source, () => {
+      this.#queries.delete(query);
+    });
+    this.#queries.add(query);
+    return query;
+  }
+  async refresh() {
+    if (this.#closed)
+      throw new Error("Live query manager is closed");
+    const failed = [...this.#queries].filter((query) => query.getSnapshot().status === "error");
+    await Promise.all([this.#backend.refresh(), ...failed.map((query) => query.refresh())]);
+  }
+  async close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    for (const query of [...this.#queries])
+      query.close();
+    this.#queries.clear();
+    await this.#backend.close();
+  }
 }
-export function createLiveQueryManager(driver, options = {}) {
-    return new LiveQueryManager(driver, options);
+function createLiveQueryManager(driver, options = {}) {
+  return new LiveQueryManager(driver, options);
 }
+export {
+  LiveQuery,
+  LiveQueryManager,
+  createLiveQueryManager
+};

package/dist/engine/vector.d.ts

@@ -34,7 +34,7 @@ interface StringVector extends VectorBase {
     readonly dictionary: readonly string[];
 }
 export type ColumnVector = BooleanVector | NumberVector | DateTimeVector | StringVector;
-interface ColumnarColumnInput {
+export interface ColumnarColumnInput {
     readonly type: VectorType;
     readonly values: readonly QueryValue[];
 }
@@ -86,6 +86,12 @@ export interface AsyncQueryExecutionOptions {
      * reference instead of stitching copies.
      */
     readonly loadScanWindow?: (start: number, length: number) => number | Promise<number>;
+    /**
+     * Ascending scan row positions an index has already narrowed the plan to. The predicates
+     * still run on every visited row, so the selection is a pure skip list: rows outside it are
+     * never loaded or evaluated. Only the streamed scan honors it.
+     */
+    readonly scanRows?: readonly number[];
 }
 export interface QueryBatchExecutionOptions extends AsyncQueryExecutionOptions {
     /** Maximum result rows handed to the consumer at once. */