hyperdb-wasm 0.0.26311-dev.wasm.gbee0ee3d → 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");

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>;

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export { HyperDB, HyperDBConnection } from './api.js';
 export type { ArrowInsertOptions, BrowserCreateOptions, DatabaseCreateOptions, DatabaseMetadata, HyperDBSettingValue, HyperDBSettings } from './api.js';
+export type { InstantiationProgress } from './protocol.js';

package/dist/node.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/protocol.d.ts

@@ -101,9 +101,15 @@ export type WasmResponse = {
     type: 'response';
     result: WasmResult;
 };
+export interface InstantiationProgress {
+    readonly bytesLoaded: number;
+    readonly bytesTotal: number;
+}
 export type WorkerEvent = {
     type: 'ready';
-} | {
+} | ({
+    type: 'progress';
+} & InstantiationProgress) | {
     type: 'fatal';
     error: string;
 } | {

package/dist/raw.browser.d.ts

@@ -1,3 +1,3 @@
 export * from './raw.js';
 export { BrowserWorker, createBrowserClient } from './browser.js';
-export type { BrowserWorkerLike } from './browser.js';
+export type { BrowserClientOptions, BrowserWorkerLike } from './browser.js';

package/dist/raw.browser.js

@@ -28,6 +28,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":
@@ -41,15 +43,8 @@ function isWorkerEvent(message) {
 
 // src/client.ts
 var 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;
@@ -61,6 +56,15 @@ var HyperDBEngineClient = class {
       transport.onClose((error) => this.fail(error))
     ];
   }
+  onInitialisationProgress;
+  transport;
+  pending = /* @__PURE__ */ new Map();
+  readyPromise;
+  resolveReady;
+  rejectReady;
+  nextId = 1;
+  failed;
+  unsubscribe;
   ready() {
     return this.readyPromise;
   }
@@ -141,6 +145,10 @@ var HyperDBEngineClient = class {
       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;
@@ -336,15 +344,19 @@ var BrowserWorker = class {
     this.worker.terminate();
   }
 };
-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
+  );
 }
 export {
   BrowserWorker,

package/dist/raw.d.ts

@@ -1,3 +1,3 @@
 export { HyperDBEngineClient } from './client.js';
 export { HyperDBBindings } from './wasm_bindings.js';
-export type { EngineRequest, WasmResponse, WasmResult, WorkerEvent, WorkerTransport } from './protocol.js';
+export type { EngineRequest, InstantiationProgress, WasmResponse, WasmResult, WorkerEvent, WorkerTransport } from './protocol.js';

package/dist/raw.node.js

@@ -28,6 +28,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":
@@ -41,15 +43,8 @@ function isWorkerEvent(message) {
 
 // src/client.ts
 var 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;
@@ -61,6 +56,15 @@ var HyperDBEngineClient = class {
       transport.onClose((error) => this.fail(error))
     ];
   }
+  onInitialisationProgress;
+  transport;
+  pending = /* @__PURE__ */ new Map();
+  readyPromise;
+  resolveReady;
+  rejectReady;
+  nextId = 1;
+  failed;
+  unsubscribe;
   ready() {
     return this.readyPromise;
   }
@@ -141,6 +145,10 @@ var HyperDBEngineClient = class {
       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;

package/dist/worker_setup.d.ts

@@ -22,6 +22,7 @@ export interface HyperDBWasmRuntimeModule extends HyperDBWasmModule {
     onRuntimeInitialized?: () => void;
     onAbort?: (reason: unknown) => void;
     locateFile?: (path: string, prefix: string) => string;
+    instantiateWasm?: (imports: WebAssembly.Imports, receiveInstance: (instance: WebAssembly.Instance, module: WebAssembly.Module) => void) => Record<string, never>;
     hyperdbWasmFetchStart?: (id: number, url: string, offset: number, length: number) => void;
     hyperdbWasmHttpStart?: (id: number, method: string, url: string, headers: string, bodyPointer: number | bigint, bodyLength: number) => void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hyperdb-wasm",
-    "version": "0.0.26311-dev.wasm.gbee0ee3d",
+    "version": "0.0.26312-dev.wasm.g57edd738",
     "type": "module",
     "engines": {
         "node": ">=24"