@minnowdb/core 0.7.0 → 0.7.2

package/dist/engine/worker-indexeddb.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/engine/worker-indexeddb.js

@@ -0,0 +1,3 @@
+import { attachWorkerHost } from "./worker-server.js";
+import { indexedDbWorkerStore } from "./worker-store-indexeddb.js";
+attachWorkerHost(self, indexedDbWorkerStore);

package/dist/engine/worker-memory.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/engine/worker-memory.js

@@ -0,0 +1,3 @@
+import { attachWorkerHost } from "./worker-server.js";
+import { memoryWorkerStore } from "./worker-store-memory.js";
+attachWorkerHost(self, memoryWorkerStore);

package/dist/engine/worker-opfs.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/engine/worker-opfs.js

@@ -0,0 +1,3 @@
+import { attachWorkerHost } from "./worker-server.js";
+import { opfsWorkerStore } from "./worker-store-opfs.js";
+attachWorkerHost(self, opfsWorkerStore);

package/dist/engine/worker-server.d.ts

@@ -0,0 +1,93 @@
+import type { BlockStore } from "../storage/types.js";
+import { MinnowDatabase, type MinnowDatabaseOptions } from "./database.js";
+/**
+ * Worker-side host for the main-thread client. exposeDatabase() answers the client's RPC frames
+ * against a database you construct yourself; attachWorkerHost() additionally owns construction,
+ * building the store from the cloneable descriptor in the client's init frame through the store
+ * factory it is given. The per-store worker entries (`@minnowdb/core/worker/{indexeddb,opfs,
+ * memory}`) call it with a factory that imports one adapter statically. The public
+ * `@minnowdb/core/worker-host` facade adds attachDatabaseWorker(), whose default factory names
+ * every adapter — which is why it lives in that module and not here: an entry importing this
+ * module carries only the adapter it names itself.
+ *
+ * Dispatch is a whitelist per target: the root database and each issued handle accept only the
+ * methods listed here, so arbitrary property access never crosses the channel.
+ */
+export type StoreDescriptor = {
+    kind: "memory";
+} | {
+    kind: "indexeddb";
+    name: string;
+    durability?: IDBTransactionDurability;
+    uniqueKeyCacheBytes?: number;
+} | {
+    kind: "opfs";
+    name: string;
+    durability?: "relaxed" | "strict";
+};
+/** The cloneable subset of MinnowDatabaseOptions; function-valued seams stay worker-side. */
+export type WireDatabaseOptions = Pick<MinnowDatabaseOptions, "compression" | "targetBlockBytes" | "rowsPerBlock" | "maxCommitRetries" | "spillOwnerLeaseMs" | "transactionOwnerLeaseMs" | "transactionIdleTimeoutMs" | "bufferPoolBytes" | "executionMemoryBudgetBytes" | "autoCollectDebtLimitCommits" | "autoCollect" | "autoCompact">;
+export interface DatabaseInitPayload {
+    store: StoreDescriptor;
+    options?: WireDatabaseOptions;
+}
+/** The slice of DedicatedWorkerGlobalScope (or MessagePort) the host needs. */
+export interface RpcScope {
+    addEventListener(type: "message", listener: (event: MessageEvent<unknown>) => void): void;
+    /**
+     * Query results arrive with their typed-array buffers listed for transfer; a scope that
+     * ignores the second argument still works, it just clones them.
+     */
+    postMessage(message: unknown, options?: {
+        transfer: ArrayBuffer[];
+    }): void;
+}
+export interface ExposeDatabaseOptions {
+    /** Called when the client sends its dispose frame, after every handle has been closed. */
+    onDispose?: () => void | Promise<void>;
+    /**
+     * Rolls back a worker write handle after this long without a handle RPC. Match the constructed
+     * database's `transactionIdleTimeoutMs` when it is customized. Defaults to 30 seconds.
+     */
+    writeHandleIdleTimeoutMs?: number;
+    /**
+     * Called when the main thread reports its page visibility. The stock entry forwards this to
+     * the store's `setForeground` when it has one — the OPFS store uses it to keep leadership
+     * on the tab the user is looking at.
+     */
+    onVisibility?: (visible: boolean) => void;
+}
+/** What a worker store factory may need beyond the descriptor itself. */
+export interface WorkerStoreOptions {
+    /** Test seam for environments without a global IndexedDB (e.g. fake-indexeddb). */
+    indexedDB?: IDBFactory;
+}
+/**
+ * Builds the block store named by a client's init frame. The stock entry's factory loads the
+ * adapter for any of the three kinds on demand; a per-store entry supplies one that imports a
+ * single adapter statically and refuses the rest.
+ */
+export type WorkerStoreFactory = (descriptor: StoreDescriptor, options: WorkerStoreOptions) => BlockStore | Promise<BlockStore>;
+/** Hard per-connection ceiling for resident worker resources abandoned by a client. */
+export declare const MAX_WORKER_HANDLES_PER_CONNECTION = 256;
+/**
+ * Answers client RPC frames against a database you constructed yourself. Use this in a custom
+ * worker entry when you need non-cloneable construction options (a custom store, `now`,
+ * `createId`) — the client's init frame is acknowledged without reconstructing anything.
+ */
+export declare function exposeDatabase(database: MinnowDatabase, scope: RpcScope, options?: ExposeDatabaseOptions): void;
+/**
+ * Full worker-side wiring: waits for the client's init frame, builds the store it describes with
+ * `createStore`, constructs the database, and exposes it. The store is closed when the client
+ * disposes. A factory failure — including a refused store kind — fails the init call and leaves
+ * the worker ready for a retry.
+ */
+export declare function attachWorkerHost(scope: RpcScope, createStore: WorkerStoreFactory, options?: WorkerStoreOptions): void;
+/**
+ * A store factory that opens one kind of store and refuses every other init frame with an error
+ * naming the entry that does support it. The per-store worker entries are built from this; a
+ * custom entry may pass one to `attachDatabaseWorker()` when it must own the open call.
+ */
+export declare function singleStoreFactory<Kind extends StoreDescriptor["kind"]>(kind: Kind, open: (descriptor: Extract<StoreDescriptor, {
+    kind: Kind;
+}>, options: WorkerStoreOptions) => BlockStore | Promise<BlockStore>): WorkerStoreFactory;