hyperdb-wasm 0.0.26308-dev.wasm.gae25030d → 0.0.26312-dev.wasm.g57edd738

package/dist/browser.d.ts

@@ -1,5 +1,5 @@
 import { HyperDBEngineClient } from './client.js';
-import type { EngineRequest, WorkerTransport } from './protocol.js';
+import type { EngineRequest, InstantiationProgress, WorkerTransport } from './protocol.js';
 type BrowserListener = (event: unknown) => void;
 export interface BrowserWorkerLike {
     postMessage(message: unknown, transfer: ArrayBuffer[]): void;
@@ -10,6 +10,8 @@ export interface BrowserWorkerLike {
 export interface BrowserClientOptions {
     readonly workerUrl?: string | URL;
     readonly engineUrl?: string | URL;
+    readonly wasmUrl?: string | URL;
+    readonly onInitialisationProgress?: (progress: InstantiationProgress) => void;
 }
 export declare class BrowserWorker implements WorkerTransport {
     private readonly worker;
@@ -20,6 +22,6 @@ export declare class BrowserWorker implements WorkerTransport {
     onClose(): () => void;
     terminate(): void;
 }
-export declare function resolveBrowserWorkerUrl(workerUrl: string | URL, engineUrl: string | URL): URL;
+export declare function resolveBrowserWorkerUrl(workerUrl: string | URL, engineUrl: string | URL, wasmUrl?: string | URL): URL;
 export declare function createBrowserClient(options?: BrowserClientOptions): HyperDBEngineClient;
 export {};

package/dist/browser.js

@@ -43,6 +43,8 @@ function isWorkerEvent(message) {
   switch (message.type) {
     case "ready":
       return hasKeys(message, ["type"]);
+    case "progress":
+      return hasKeys(message, ["type", "bytesLoaded", "bytesTotal"]) && typeof message.bytesLoaded === "number" && Number.isSafeInteger(message.bytesLoaded) && message.bytesLoaded >= 0 && typeof message.bytesTotal === "number" && Number.isSafeInteger(message.bytesTotal) && message.bytesTotal >= 0;
     case "fatal":
       return hasKeys(message, ["type", "error"]) && typeof message.error === "string";
     case "log":
@@ -66,15 +68,8 @@ var init_client = __esm({
     "use strict";
     init_protocol();
     HyperDBEngineClient = class {
-      transport;
-      pending = /* @__PURE__ */ new Map();
-      readyPromise;
-      resolveReady;
-      rejectReady;
-      nextId = 1;
-      failed;
-      unsubscribe;
-      constructor(transport) {
+      constructor(transport, onInitialisationProgress) {
+        this.onInitialisationProgress = onInitialisationProgress;
         this.transport = transport;
         this.readyPromise = new Promise((resolve, reject) => {
           this.resolveReady = resolve;
@@ -86,6 +81,15 @@ var init_client = __esm({
           transport.onClose((error) => this.fail(error))
         ];
       }
+      onInitialisationProgress;
+      transport;
+      pending = /* @__PURE__ */ new Map();
+      readyPromise;
+      resolveReady;
+      rejectReady;
+      nextId = 1;
+      failed;
+      unsubscribe;
       ready() {
         return this.readyPromise;
       }
@@ -166,6 +170,10 @@ var init_client = __esm({
           this.resolveReady();
           return;
         }
+        if (message.type === "progress") {
+          this.onInitialisationProgress?.({ bytesLoaded: message.bytesLoaded, bytesTotal: message.bytesTotal });
+          return;
+        }
         if (message.type === "fatal") {
           this.fail(new Error(message.error || "engine aborted"));
           return;
@@ -195,15 +203,19 @@ __export(browser_exports, {
   createBrowserClient: () => createBrowserClient,
   resolveBrowserWorkerUrl: () => resolveBrowserWorkerUrl
 });
-function resolveBrowserWorkerUrl(workerUrl, engineUrl) {
+function resolveBrowserWorkerUrl(workerUrl, engineUrl, wasmUrl) {
   const resolved = new URL(workerUrl);
   resolved.searchParams.set("engineUrl", new URL(engineUrl).href);
+  if (wasmUrl != null) resolved.searchParams.set("wasmUrl", new URL(wasmUrl).href);
   return resolved;
 }
 function createBrowserClient(options = {}) {
   const workerUrl = options.workerUrl ?? new URL("./browser_worker.js", import.meta.url);
   const engineUrl = options.engineUrl ?? new URL("./hyperdb-wasm.js", import.meta.url);
-  return new HyperDBEngineClient(new BrowserWorker(new Worker(resolveBrowserWorkerUrl(workerUrl, engineUrl), { type: "classic" })));
+  return new HyperDBEngineClient(
+    new BrowserWorker(new Worker(resolveBrowserWorkerUrl(workerUrl, engineUrl, options.wasmUrl), { type: "classic" })),
+    options.onInitialisationProgress
+  );
 }
 var BrowserWorker;
 var init_browser = __esm({

package/dist/browser_worker.js

@@ -296,6 +296,8 @@
   var configuredEngineUrl = new URL(self.location.href).searchParams.get("engineUrl");
   var engineUrl = self.HYPERDB_WASM_ENGINE_URL ?? configuredEngineUrl ?? "hyperdb-wasm.js";
   var resolvedEngineUrl = new URL(engineUrl, self.location.href);
+  var configuredWasmUrl = new URL(self.location.href).searchParams.get("wasmUrl");
+  var resolvedWasmUrl = configuredWasmUrl == null ? new URL("hyperdb-wasm.wasm.br", resolvedEngineUrl) : new URL(configuredWasmUrl);
   function isPthreadWorker() {
     const location = self.location;
     return self.name === "em-pthread" || location.search?.includes("pthread") === true;
@@ -303,14 +305,38 @@
   if (isPthreadWorker()) {
     self.importScripts(resolvedEngineUrl.href);
   } else {
-    const module = {
-      locateFile: (path, prefix) => path === "hyperdb-wasm.wasm" ? new URL("hyperdb-wasm.wasm.br", resolvedEngineUrl).href : `${prefix}${path}`
-    };
-    self.Module = module;
     const transport = {
       postMessage: (message, transfer = []) => self.postMessage(message, [...transfer]),
       onMessage: (listener) => self.addEventListener("message", (event) => listener(event.data))
     };
+    const module = {
+      locateFile: (path, prefix) => path === "hyperdb-wasm.wasm" ? resolvedWasmUrl.href : `${prefix}${path}`,
+      instantiateWasm: (imports, receiveInstance) => {
+        void (async () => {
+          const response = await fetch(resolvedWasmUrl, { credentials: "same-origin" });
+          if (!response.ok) throw new Error(`failed to fetch HyperDB Wasm: ${response.status} ${response.statusText}`);
+          const bytesTotal = response.headers.has("content-encoding") ? 0 : Number(response.headers.get("content-length")) || 0;
+          let bytesLoaded = 0;
+          transport.postMessage({ type: "progress", bytesLoaded, bytesTotal });
+          const body = response.body?.pipeThrough(new TransformStream({
+            transform(chunk, controller) {
+              bytesLoaded += chunk.byteLength;
+              transport.postMessage({ type: "progress", bytesLoaded, bytesTotal });
+              controller.enqueue(chunk);
+            }
+          }));
+          const result = body == null ? await WebAssembly.instantiate(await response.arrayBuffer(), imports) : await WebAssembly.instantiateStreaming(new Response(body, response), imports);
+          receiveInstance(result.instance, result.module);
+        })().catch((error) => {
+          transport.postMessage({
+            type: "fatal",
+            error: `engine instantiation failed: ${error instanceof Error ? error.message : String(error)}`
+          });
+        });
+        return {};
+      }
+    };
+    self.Module = module;
     configureWorker(module, transport, (runtime) => {
       if (!runtime.OPFS) throw new Error("OPFS backend is unavailable");
       runtime.FS.mkdirTree("/opfs");
@@ -318,6 +344,7 @@
       runtime.FS.mkdirTree("/hyperdb-persistent");
       runtime.FS.mount(runtime.OPFS, {}, "/hyperdb-persistent");
       runtime.FS.mkdirTree("/hyperdb-persistent/hyperdb");
+      runtime.FS.mkdirTree("/hyperdb-persistent/logs");
       runtime.resolveHyperDBPath = (path) => {
         const parts = [];
         for (const part of path.replace(/^\/+/, "").split("/")) {

package/dist/client.d.ts

@@ -1,5 +1,6 @@
-import type { WasmResult, WorkerTransport } from './protocol.js';
+import type { InstantiationProgress, WasmResult, WorkerTransport } from './protocol.js';
 export declare class HyperDBEngineClient {
+    private readonly onInitialisationProgress?;
     private readonly transport;
     private readonly pending;
     private readonly readyPromise;
@@ -8,7 +9,7 @@ export declare class HyperDBEngineClient {
     private nextId;
     private failed;
     private readonly unsubscribe;
-    constructor(transport: WorkerTransport);
+    constructor(transport: WorkerTransport, onInitialisationProgress?: ((progress: InstantiationProgress) => void) | undefined);
     ready(): Promise<void>;
     initialize(settings: string): Promise<WasmResult>;
     connect(): Promise<WasmResult>;