@minnowdb/core 0.6.9 → 0.7.1

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

@@ -1,69 +1,14 @@
-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; attachDatabaseWorker() additionally owns
- * construction, building the store from the cloneable descriptor in the client's init frame. The
- * ready-made worker entry (`@minnowdb/core/worker`) is one line over the latter.
- *
- * 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;
+import { type RpcScope, type WorkerStoreFactory, type WorkerStoreOptions } from "./worker-server.js";
+export { exposeDatabase, singleStoreFactory, MAX_WORKER_HANDLES_PER_CONNECTION, type DatabaseInitPayload, type ExposeDatabaseOptions, type RpcScope, type StoreDescriptor, type WireDatabaseOptions, type WorkerStoreFactory, type WorkerStoreOptions, } from "./worker-server.js";
+export interface AttachDatabaseWorkerOptions extends WorkerStoreOptions {
     /**
-     * Query results arrive with their typed-array buffers listed for transfer; a scope that
-     * ignores the second argument still works, it just clones them.
+     * Replaces the stock store factory. `singleStoreFactory()` builds one that opens a single
+     * kind and refuses the rest, the way the `@minnowdb/core/worker/{indexeddb,opfs,memory}`
+     * entries do — though a custom entry importing this module still carries every adapter the
+     * stock factory names unless its bundler splits worker code.
      */
-    postMessage(message: unknown, options?: {
-        transfer: ArrayBuffer[];
-    }): void;
+    createStore?: WorkerStoreFactory;
 }
-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;
-}
-export interface AttachDatabaseWorkerOptions {
-    /** Test seam for environments without a global IndexedDB (e.g. fake-indexeddb). */
-    indexedDB?: IDBFactory;
-}
-/** 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,
  * constructs the database, and exposes it. The store is closed when the client disposes.