@minnowdb/core 0.10.1 → 0.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "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",
@@ -149,6 +149,9 @@
     "!dist/engine/storage-test-helpers.*",
     "!dist/testing/seeds.*",
     "!dist/testing/oracle.*",
+    "!dist/engine/client-audit-harness.*",
+    "!dist/storage/indexeddb-audit-helpers.*",
+    "!dist/storage/opfs/power-loss-model.*",
     "!dist/*.tsbuildinfo",
     "sql-feature-matrix.json",
     "postgres-feature-profile.json"

package/dist/engine/client-audit-harness.js

@@ -1,123 +0,0 @@
-import { MemoryBlockStore } from "../storage/index.js";
-function createBoundary() {
-  const clientListeners = /* @__PURE__ */ new Map();
-  const workerListeners = /* @__PURE__ */ new Map();
-  let chain = Promise.resolve();
-  let severed = false;
-  const sentByClient = [];
-  const sentByWorker = [];
-  const deliver = (target, message, transfer) => {
-    const data = structuredClone(message, transfer === void 0 ? void 0 : { transfer });
-    if (severed)
-      return;
-    chain = chain.then(() => {
-      if (severed)
-        return;
-      for (const listener of target.get("message") ?? [])
-        listener({ data });
-    });
-  };
-  const add = (map, type, listener) => {
-    const list = map.get(type) ?? [];
-    list.push(listener);
-    map.set(type, list);
-  };
-  const remove = (map, type, listener) => {
-    const list = map.get(type) ?? [];
-    const index = list.indexOf(listener);
-    if (index >= 0)
-      list.splice(index, 1);
-  };
-  const clientSide = {
-    postMessage: (message, options) => {
-      sentByClient.push(structuredClone(message));
-      deliver(workerListeners, message, options?.transfer);
-    },
-    addEventListener: (type, listener) => {
-      add(clientListeners, type, listener);
-    },
-    removeEventListener: (type, listener) => {
-      remove(clientListeners, type, listener);
-    },
-    terminate: () => {
-      severed = true;
-    }
-  };
-  const workerSide = {
-    postMessage: (message, options) => {
-      sentByWorker.push(structuredClone(message));
-      deliver(clientListeners, message, options?.transfer);
-    },
-    addEventListener: (type, listener) => {
-      add(workerListeners, type, listener);
-    }
-  };
-  return {
-    sentByClient,
-    sentByWorker,
-    clientSide,
-    workerSide,
-    sever: () => {
-      severed = true;
-    },
-    injectToClient: (frame) => {
-      for (const listener of clientListeners.get("message") ?? []) {
-        listener({ data: frame });
-      }
-    },
-    injectToWorker: (frame) => {
-      for (const listener of workerListeners.get("message") ?? []) {
-        listener({ data: frame });
-      }
-    },
-    emitWorkerGlobal: (type, event) => {
-      for (const listener of workerListeners.get(type) ?? [])
-        listener(event);
-    },
-    emitTransport: (type, event) => {
-      for (const listener of clientListeners.get(type) ?? [])
-        listener(event);
-    },
-    flush: async () => {
-      await chain;
-      await new Promise((resolve) => setTimeout(resolve, 5));
-    }
-  };
-}
-function settled(ms = 20) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function faultyStore(fault, options = {}) {
-  const inner = new MemoryBlockStore();
-  const calls = [];
-  const hidden = new Set(options.hide ?? []);
-  const store = new Proxy(inner, {
-    get(target, property) {
-      if (typeof property === "string" && hidden.has(property))
-        return void 0;
-      const value = target[property];
-      if (typeof value !== "function" || typeof property !== "string")
-        return value;
-      const method = property;
-      return (...args) => {
-        const run = () => value.apply(inner, args);
-        const isAsync = value.constructor?.name === "AsyncFunction";
-        if (!isAsync)
-          return run();
-        calls.push({ method, args });
-        return fault(method, args, run);
-      };
-    },
-    has(target, property) {
-      if (typeof property === "string" && hidden.has(property))
-        return false;
-      return Reflect.has(target, property);
-    }
-  });
-  return { store, calls };
-}
-export {
-  createBoundary,
-  faultyStore,
-  settled
-};

package/dist/storage/indexeddb-audit-helpers.js

@@ -1,269 +0,0 @@
-import { IndexedDbBlockStore } from "./indexeddb.js";
-const NOW = "2026-09-12T12:00:00.000Z";
-async function openStore(indexedDB, name = crypto.randomUUID(), durability) {
-  return IndexedDbBlockStore.open({ name, indexedDB, ...durability ? { durability } : {} });
-}
-const EVENTS_TABLE = {
-  managed: false,
-  id: "events",
-  name: "events",
-  columns: [{ id: "value", name: "value", type: "number", nullable: false }],
-  revision: 0,
-  createdAt: NOW
-};
-function activeTransaction(id, snapshotVersion) {
-  return {
-    id,
-    ownerId: `owner-${id}`,
-    expiresAt: "2026-09-12T12:30:00.000Z",
-    snapshotVersion,
-    pendingBlockIds: [],
-    pendingSegmentIds: [],
-    status: "active",
-    revision: 0,
-    startedAt: NOW,
-    updatedAt: NOW,
-    committedVersion: null
-  };
-}
-function segment(id, transactionId, blockId, commitOrdinal = 0, rowIdStart = 1n) {
-  return {
-    id,
-    tableId: "events",
-    transactionId,
-    rowCount: 1,
-    rowIdStart,
-    rowIdEndExclusive: rowIdStart + 1n,
-    columnBlockIds: { value: [blockId] },
-    kind: "insert",
-    level: 0,
-    logicalOrder: 0,
-    commitOrdinal,
-    rowIdSpans: [],
-    createdAt: NOW
-  };
-}
-async function rawOpen(indexedDB, name) {
-  return new Promise((resolve, reject) => {
-    const request = indexedDB.open(name);
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error ?? new Error("raw IndexedDB open failed"));
-  });
-}
-async function readRawValue(indexedDB, name, storeName, key) {
-  const database = await rawOpen(indexedDB, name);
-  try {
-    const transaction = database.transaction(storeName, "readonly");
-    const value = await new Promise((resolve, reject) => {
-      const request = transaction.objectStore(storeName).get(key);
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(request.error ?? new Error("raw IndexedDB read failed"));
-    });
-    await new Promise((resolve, reject) => {
-      transaction.oncomplete = () => resolve();
-      transaction.onabort = () => reject(transaction.error ?? new Error("raw read aborted"));
-    });
-    return value;
-  } finally {
-    database.close();
-  }
-}
-async function readRawKeys(indexedDB, name, storeName) {
-  const database = await rawOpen(indexedDB, name);
-  try {
-    const transaction = database.transaction(storeName, "readonly");
-    const keys = await new Promise((resolve, reject) => {
-      const request = transaction.objectStore(storeName).getAllKeys();
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(request.error ?? new Error("raw IndexedDB read failed"));
-    });
-    await new Promise((resolve, reject) => {
-      transaction.oncomplete = () => resolve();
-      transaction.onabort = () => reject(transaction.error ?? new Error("raw read aborted"));
-    });
-    return keys;
-  } finally {
-    database.close();
-  }
-}
-function instrumentFactory(indexedDB) {
-  const state = {
-    factory: indexedDB,
-    transactions: [],
-    requestCounts: /* @__PURE__ */ new Map(),
-    setHook(hook) {
-      currentHook = hook;
-    },
-    reset() {
-      state.transactions.length = 0;
-      state.requestCounts.clear();
-    }
-  };
-  let currentHook;
-  const wrappedScanners = /* @__PURE__ */ new WeakSet();
-  const countScans = (target, label) => {
-    if (wrappedScanners.has(target))
-      return;
-    wrappedScanners.add(target);
-    for (const method of [
-      "openCursor",
-      "openKeyCursor",
-      "getAll",
-      "getAllKeys",
-      "count"
-    ]) {
-      const original = target[method].bind(target);
-      Object.defineProperty(target, method, {
-        configurable: true,
-        value: (...args) => {
-          const key = `${label}:${method}`;
-          state.requestCounts.set(key, (state.requestCounts.get(key) ?? 0) + 1);
-          const request = original(...args);
-          if (method === "openCursor" || method === "openKeyCursor") {
-            request.addEventListener("success", () => {
-              const stepKey = `${label}:cursor-steps`;
-              if (request.result !== null && request.result !== void 0) {
-                state.requestCounts.set(stepKey, (state.requestCounts.get(stepKey) ?? 0) + 1);
-              }
-            });
-          }
-          return request;
-        }
-      });
-    }
-  };
-  const wrappedStores = /* @__PURE__ */ new WeakSet();
-  const originalOpen = indexedDB.open.bind(indexedDB);
-  Object.defineProperty(indexedDB, "open", {
-    configurable: true,
-    value: (name, version) => {
-      const request = version === void 0 ? originalOpen(name) : originalOpen(name, version);
-      request.addEventListener("success", () => {
-        const database = request.result;
-        const originalTransaction = database.transaction.bind(database);
-        Object.defineProperty(database, "transaction", {
-          configurable: true,
-          value: (stores, mode, options) => {
-            const transaction = originalTransaction(stores, mode, options);
-            const entry = {
-              transaction,
-              stores: typeof stores === "string" ? [stores] : [...stores],
-              mode: mode ?? "readonly",
-              options,
-              completed: false,
-              aborted: false
-            };
-            transaction.addEventListener("complete", () => {
-              entry.completed = true;
-            });
-            transaction.addEventListener("abort", () => {
-              entry.aborted = true;
-            });
-            state.transactions.push(entry);
-            const originalObjectStore = transaction.objectStore.bind(transaction);
-            Object.defineProperty(transaction, "objectStore", {
-              configurable: true,
-              value: (storeName) => {
-                const store = originalObjectStore(storeName);
-                if (wrappedStores.has(store))
-                  return store;
-                wrappedStores.add(store);
-                countScans(store, storeName);
-                const originalIndex = store.index.bind(store);
-                Object.defineProperty(store, "index", {
-                  configurable: true,
-                  value: (indexName) => {
-                    const index = originalIndex(indexName);
-                    countScans(index, `${storeName}.${indexName}`);
-                    return index;
-                  }
-                });
-                for (const method of ["put", "add", "delete", "get", "getKey"]) {
-                  const original = store[method].bind(store);
-                  Object.defineProperty(store, method, {
-                    configurable: true,
-                    value: (...args) => {
-                      state.requestCounts.set(storeName, (state.requestCounts.get(storeName) ?? 0) + 1);
-                      const [first, second] = args;
-                      const isWrite = method === "put" || method === "add";
-                      const decision = currentHook?.({
-                        transaction,
-                        storeName,
-                        method,
-                        key: isWrite ? second : first,
-                        value: isWrite ? first : void 0
-                      });
-                      if (decision === "throw-quota") {
-                        const failing = original(...args);
-                        const queue = transaction._requests;
-                        const entry2 = queue.find((candidate) => candidate.request === failing);
-                        if (entry2 === void 0)
-                          throw new Error("request not queued");
-                        entry2.operation = () => {
-                          throw new DOMException("The quota has been exceeded.", "QuotaExceededError");
-                        };
-                        return failing;
-                      }
-                      const result = original(...args);
-                      if (decision === "abort") {
-                        try {
-                          transaction.abort();
-                        } catch {
-                        }
-                      }
-                      return result;
-                    }
-                  });
-                }
-                return store;
-              }
-            });
-            return transaction;
-          }
-        });
-      });
-      return request;
-    }
-  });
-  return state;
-}
-async function stageBlocks(store, record, ids) {
-  let current = record;
-  for (let start = 0; start < ids.length; start += 64) {
-    const slice = ids.slice(start, start + 64);
-    current = await store.stageTransactionArtifacts({
-      transactionId: record.id,
-      expectedRevision: current.revision,
-      blocks: slice.map((id) => ({ id, bytes: Uint8Array.of(1) })),
-      segments: [],
-      updatedAt: NOW
-    });
-  }
-  return current;
-}
-async function stageSegments(store, record, ids, blockId) {
-  let current = record;
-  for (let start = 0; start < ids.length; start += 64) {
-    const slice = ids.slice(start, start + 64);
-    current = await store.stageTransactionArtifacts({
-      transactionId: record.id,
-      expectedRevision: current.revision,
-      blocks: [],
-      segments: slice.map((id, offset) => segment(id, record.id, blockId, current.pendingSegmentIds.length + offset, BigInt(current.pendingSegmentIds.length + offset + 1))),
-      updatedAt: NOW
-    });
-  }
-  return current;
-}
-export {
-  EVENTS_TABLE,
-  NOW,
-  activeTransaction,
-  instrumentFactory,
-  openStore,
-  readRawKeys,
-  readRawValue,
-  segment,
-  stageBlocks,
-  stageSegments
-};

package/dist/storage/opfs/power-loss-model.js

@@ -1,62 +0,0 @@
-class PowerLossModel {
-  #durable = /* @__PURE__ */ new Map();
-  #touched = /* @__PURE__ */ new Set();
-  #shim;
-  constructor(shim) {
-    this.#shim = shim;
-    shim.setWriteFault((path, phase) => {
-      if (phase === "flush") {
-        this.#durable.set(path, shim.readFileBytes(path) ?? new Uint8Array());
-      } else {
-        this.#touched.add(path);
-      }
-    });
-  }
-  durableBytes(path) {
-    return this.#durable.get(path);
-  }
-  powerLoss(keepPrefix) {
-    const reverted = [];
-    for (const path of this.#touched) {
-      const current = this.#shim.readFileBytes(path);
-      if (current === void 0)
-        continue;
-      const durable = this.#durable.get(path) ?? new Uint8Array();
-      let kept = durable;
-      if (keepPrefix !== void 0 && current.byteLength > durable.byteLength && startsWith(current, durable)) {
-        const unflushed = current.byteLength - durable.byteLength;
-        const extra = keepPrefix(unflushed, path);
-        kept = current.slice(0, durable.byteLength + Math.max(0, Math.min(extra, unflushed)));
-      }
-      if (!bytesEqual(kept, current)) {
-        this.#shim.writeFileBytes(path, kept);
-        reverted.push(path);
-      }
-      this.#durable.set(path, kept.slice());
-    }
-    this.#touched.clear();
-    return reverted;
-  }
-}
-function startsWith(bytes, prefix) {
-  if (prefix.byteLength > bytes.byteLength)
-    return false;
-  for (let index = 0; index < prefix.byteLength; index += 1) {
-    if (bytes[index] !== prefix[index])
-      return false;
-  }
-  return true;
-}
-function bytesEqual(left, right) {
-  if (left.byteLength !== right.byteLength)
-    return false;
-  for (let index = 0; index < left.byteLength; index += 1) {
-    if (left[index] !== right[index])
-      return false;
-  }
-  return true;
-}
-export {
-  PowerLossModel,
-  bytesEqual
-};