hyperdb-wasm 0.0.26281-dev.wasm.g39d82636

package/dist/node.js

@@ -0,0 +1,456 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// protocol.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasKeys(value, keys) {
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function isWasmResult(value) {
+  if (!isRecord(value) || typeof value.state !== "string") return false;
+  switch (value.state) {
+    case "ok":
+    case "chunk":
+      return hasKeys(value, ["state", "payload"]) && value.payload instanceof Uint8Array;
+    case "pending":
+    case "done":
+      return hasKeys(value, ["state"]);
+    case "error":
+    case "busy":
+      return hasKeys(value, ["state", "error"]) && typeof value.error === "string";
+    default:
+      return false;
+  }
+}
+function isWorkerEvent(message) {
+  if (!isRecord(message) || typeof message.type !== "string") return false;
+  switch (message.type) {
+    case "ready":
+      return hasKeys(message, ["type"]);
+    case "fatal":
+      return hasKeys(message, ["type", "error"]) && typeof message.error === "string";
+    case "log":
+      return hasKeys(message, ["type", "text"]) && typeof message.text === "string";
+    case "response":
+      return hasKeys(message, ["id", "type", "result"]) && Number.isSafeInteger(message.id) && isWasmResult(message.result);
+    default:
+      return false;
+  }
+}
+var init_protocol = __esm({
+  "protocol.ts"() {
+    "use strict";
+  }
+});
+
+// client.ts
+var HyperDBEngineClient;
+var init_client = __esm({
+  "client.ts"() {
+    "use strict";
+    init_protocol();
+    HyperDBEngineClient = class {
+      transport;
+      pending = /* @__PURE__ */ new Map();
+      readyPromise;
+      resolveReady;
+      rejectReady;
+      nextId = 1;
+      failed;
+      unsubscribe;
+      constructor(transport) {
+        this.transport = transport;
+        this.readyPromise = new Promise((resolve, reject) => {
+          this.resolveReady = resolve;
+          this.rejectReady = reject;
+        });
+        this.unsubscribe = [
+          transport.onMessage((message) => this.onMessage(message)),
+          transport.onError((error) => this.fail(error)),
+          transport.onClose((error) => this.fail(error))
+        ];
+      }
+      ready() {
+        return this.readyPromise;
+      }
+      connect() {
+        return this.request({ id: this.nextId++, type: "connect" });
+      }
+      disconnect(connection) {
+        return this.request({ id: this.nextId++, type: "disconnect", connection });
+      }
+      startQuery(connection, sql) {
+        return this.request({ id: this.nextId++, type: "startQuery", connection, sql });
+      }
+      pollQuery(query) {
+        return this.request({ id: this.nextId++, type: "pollQuery", query });
+      }
+      cancelQuery(query) {
+        return this.request({ id: this.nextId++, type: "cancelQuery", query });
+      }
+      releaseQuery(query) {
+        return this.request({ id: this.nextId++, type: "releaseQuery", query });
+      }
+      async terminate() {
+        this.fail(new Error("engine worker terminated"));
+        await this.transport.terminate();
+      }
+      request(request) {
+        if (this.failed) return Promise.reject(this.failed);
+        return new Promise((resolve, reject) => {
+          this.pending.set(request.id, { resolve, reject });
+          try {
+            this.transport.postMessage(request);
+          } catch (error) {
+            this.pending.delete(request.id);
+            reject(error instanceof Error ? error : new Error(String(error)));
+          }
+        });
+      }
+      onMessage(message) {
+        if (!isWorkerEvent(message)) return;
+        if (message.type === "ready") {
+          this.resolveReady();
+          return;
+        }
+        if (message.type === "fatal") {
+          this.fail(new Error(message.error || "engine aborted"));
+          return;
+        }
+        if (message.type !== "response") return;
+        const pending = this.pending.get(message.id);
+        if (!pending) return;
+        this.pending.delete(message.id);
+        pending.resolve(message.result);
+      }
+      fail(error) {
+        if (this.failed) return;
+        this.failed = error;
+        for (const unsubscribe of this.unsubscribe.splice(0)) unsubscribe();
+        this.rejectReady(error);
+        for (const pending of this.pending.values()) pending.reject(error);
+        this.pending.clear();
+      }
+    };
+  }
+});
+
+// browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  BrowserWorker: () => BrowserWorker,
+  createBrowserClient: () => createBrowserClient,
+  resolveBrowserWorkerUrl: () => resolveBrowserWorkerUrl
+});
+function resolveBrowserWorkerUrl(workerUrl, engineUrl) {
+  const resolved = new URL(workerUrl);
+  resolved.searchParams.set("engineUrl", new URL(engineUrl).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" })));
+}
+var BrowserWorker;
+var init_browser = __esm({
+  "browser.ts"() {
+    "use strict";
+    init_client();
+    BrowserWorker = class {
+      constructor(worker) {
+        this.worker = worker;
+      }
+      worker;
+      postMessage(message, transfer = []) {
+        this.worker.postMessage(message, [...transfer]);
+      }
+      onMessage(listener) {
+        const wrapped = (event) => listener(event.data);
+        this.worker.addEventListener("message", wrapped);
+        return () => this.worker.removeEventListener("message", wrapped);
+      }
+      onError(listener) {
+        const wrapped = (event) => listener(new Error(event.message || "engine worker error"));
+        this.worker.addEventListener("error", wrapped);
+        return () => this.worker.removeEventListener("error", wrapped);
+      }
+      onClose() {
+        return () => void 0;
+      }
+      terminate() {
+        this.worker.terminate();
+      }
+    };
+  }
+});
+
+// api.ts
+import { RecordBatchReader, Table } from "apache-arrow";
+function readHandleFromResult(result, operation) {
+  if (result.state !== "ok") throw readErrorFromResult(result, operation);
+  if (result.payload.byteLength !== 4) throw new Error(`${operation} returned an invalid handle`);
+  return new DataView(result.payload.buffer, result.payload.byteOffset, result.payload.byteLength).getUint32(0, true);
+}
+function readErrorFromResult(result, operation) {
+  if (result.state === "error" || result.state === "busy") return new Error(result.error);
+  return new Error(`${operation} returned unexpected state ${result.state}`);
+}
+function expectOk(result, operation) {
+  if (result.state !== "ok") throw readErrorFromResult(result, operation);
+}
+function yieldToEventLoop() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+var HyperDB = class _HyperDB {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  terminated = false;
+  termination;
+  connections = /* @__PURE__ */ new Set();
+  static async create(options = {}) {
+    const { createBrowserClient: createBrowserClient2 } = await Promise.resolve().then(() => (init_browser(), browser_exports));
+    const database = new _HyperDB(createBrowserClient2(options));
+    await database.ready();
+    return database;
+  }
+  ready() {
+    this.ensureRunning();
+    return this.client.ready();
+  }
+  async connect() {
+    this.ensureRunning();
+    const connection = readHandleFromResult(await this.client.connect(), "connect");
+    const result = new HyperDBConnection(this.client, connection, () => this.connections.delete(result));
+    this.connections.add(result);
+    return result;
+  }
+  async terminate() {
+    if (this.terminated) return;
+    if (!this.termination) {
+      this.termination = (async () => {
+        try {
+          await Promise.all([...this.connections].map(async (connection) => connection.closeForTermination()));
+        } catch (error) {
+          this.termination = void 0;
+          throw error;
+        }
+        this.terminated = true;
+        await this.client.terminate();
+      })();
+    }
+    await this.termination;
+  }
+  ensureRunning() {
+    if (this.terminated) throw new Error("database is terminated");
+  }
+};
+var HyperDBConnection = class {
+  constructor(client, connection, onClose = () => void 0) {
+    this.client = client;
+    this.connection = connection;
+    this.onClose = onClose;
+  }
+  client;
+  connection;
+  onClose;
+  closed = false;
+  active = false;
+  closing;
+  async close() {
+    if (this.closed) return;
+    if (this.active) throw new Error("connection has an active query");
+    if (!this.closing) {
+      this.closing = (async () => {
+        try {
+          expectOk(await this.client.disconnect(this.connection), "disconnect");
+        } catch (error) {
+          this.closing = void 0;
+          throw error;
+        }
+        this.closed = true;
+        this.onClose();
+      })();
+    }
+    await this.closing;
+  }
+  sendIPC(sql) {
+    const connection = this;
+    return {
+      async *[Symbol.asyncIterator]() {
+        connection.ensureAvailable();
+        let query;
+        let terminal = false;
+        let prefetched;
+        try {
+          query = readHandleFromResult(await connection.client.startQuery(connection.connection, sql), "start query");
+          for (; ; ) {
+            let result = prefetched ? await prefetched : await connection.client.pollQuery(query);
+            prefetched = void 0;
+            while (result.state === "pending") {
+              await yieldToEventLoop();
+              result = await connection.client.pollQuery(query);
+            }
+            if (result.state === "chunk") {
+              prefetched = connection.client.pollQuery(query);
+              void prefetched.catch(() => void 0);
+              yield result.payload;
+              continue;
+            }
+            terminal = true;
+            if (result.state === "done") return;
+            throw readErrorFromResult(result, "poll query");
+          }
+        } finally {
+          try {
+            if (query !== void 0) {
+              let cleanupError;
+              if (prefetched) {
+                try {
+                  await prefetched;
+                } catch (error) {
+                  cleanupError = error;
+                }
+                prefetched = void 0;
+              }
+              if (!terminal) {
+                try {
+                  expectOk(await connection.client.cancelQuery(query), "cancel query");
+                } catch (error) {
+                  cleanupError ??= error;
+                }
+              }
+              try {
+                await connection.release(query);
+              } catch (error) {
+                cleanupError ??= error;
+              }
+              if (cleanupError) throw cleanupError;
+            }
+          } finally {
+            connection.active = false;
+          }
+        }
+      }
+    };
+  }
+  async queryIPC(sql) {
+    const chunks = [];
+    let length = 0;
+    for await (const chunk of this.sendIPC(sql)) {
+      chunks.push(chunk);
+      length += chunk.byteLength;
+    }
+    const result = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return result;
+  }
+  async send(sql) {
+    const reader = await RecordBatchReader.from(this.sendIPC(sql));
+    if (!reader.isAsync() || !reader.isStream()) throw new Error("query did not produce an Arrow async stream");
+    return reader;
+  }
+  async query(sql) {
+    const reader = await this.send(sql);
+    const batches = [];
+    for await (const batch of reader) batches.push(batch);
+    return new Table(reader.schema, batches);
+  }
+  ensureAvailable() {
+    if (this.closed) throw new Error("connection is closed");
+    if (this.closing) throw new Error("connection is closing");
+    if (this.active) {
+      throw new Error("connection has an active query");
+    }
+    this.active = true;
+  }
+  async release(query) {
+    let delay = 1;
+    for (; ; ) {
+      const result = await this.client.releaseQuery(query);
+      if (result.state === "ok") return;
+      if (result.state !== "pending") throw readErrorFromResult(result, "release query");
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      delay = Math.min(delay * 2, 32);
+    }
+  }
+  async closeForTermination() {
+    if (this.active) throw new Error("cannot terminate while a connection has an active query");
+    await this.close();
+  }
+};
+
+// node.ts
+init_client();
+import { Worker as NativeWorker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+var NodeWorker = class {
+  constructor(worker) {
+    this.worker = worker;
+  }
+  worker;
+  postMessage(message, transfer = []) {
+    this.worker.postMessage(message, transfer);
+  }
+  onMessage(listener) {
+    const wrapped = (message) => listener(message);
+    this.worker.on("message", wrapped);
+    return () => this.worker.off("message", wrapped);
+  }
+  onError(listener) {
+    const wrapped = (error) => listener(error instanceof Error ? error : new Error(String(error)));
+    this.worker.on("error", wrapped);
+    return () => this.worker.off("error", wrapped);
+  }
+  onClose(listener) {
+    const wrapped = (code) => listener(new Error(`engine worker exited with code ${String(code)}`));
+    this.worker.on("exit", wrapped);
+    return () => this.worker.off("exit", wrapped);
+  }
+  terminate() {
+    return this.worker.terminate();
+  }
+};
+function resolveNodeEnginePath(engineUrl) {
+  return fileURLToPath(engineUrl);
+}
+function createNodeClient(options = {}) {
+  const workerUrl = options.workerUrl ?? new URL("./node_worker.js", import.meta.url);
+  const engineUrl = options.engineUrl ?? resolveNodeEnginePath(new URL("./hyperdb-wasm.cjs", import.meta.url));
+  return new HyperDBEngineClient(new NodeWorker(new NativeWorker(workerUrl, { workerData: { engineUrl } })));
+}
+
+// index.node.ts
+var HyperDB2 = class _HyperDB extends HyperDB {
+  static async create(options = {}) {
+    const database = new _HyperDB(createNodeClient(options));
+    await database.ready();
+    return database;
+  }
+};
+export {
+  HyperDB2 as HyperDB,
+  HyperDBConnection
+};

package/dist/node_worker.d.ts

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

package/dist/node_worker.js

@@ -0,0 +1,236 @@
+// node_worker.ts
+import { createReadStream } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { Readable } from "node:stream";
+import { parentPort, workerData } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+import { createBrotliDecompress } from "node:zlib";
+
+// wasm_bindings.ts
+var resultStates = ["ok", "pending", "chunk", "done", "error", "busy"];
+function safeInteger(value, name) {
+  const number = typeof value === "bigint" && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : value;
+  if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 0) throw new Error(`${name} must be a nonnegative safe integer`);
+  return number;
+}
+var HyperDBBindings = class {
+  module;
+  connect;
+  disconnect;
+  startQuery;
+  pollQuery;
+  cancelQuery;
+  releaseQuery;
+  resultState;
+  resultPayloadLength;
+  free;
+  constructor(module2) {
+    this.module = module2;
+    this.connect = module2.cwrap("hyperdb_wasm_connect", "pointer", []);
+    this.disconnect = module2.cwrap("hyperdb_wasm_disconnect", "pointer", ["number"]);
+    this.startQuery = module2.cwrap("hyperdb_wasm_query_start", "pointer", ["number", "string"]);
+    this.pollQuery = module2.cwrap("hyperdb_wasm_query_poll", "pointer", ["number"]);
+    this.cancelQuery = module2.cwrap("hyperdb_wasm_query_cancel", "pointer", ["number"]);
+    this.releaseQuery = module2.cwrap("hyperdb_wasm_query_release", "pointer", ["number"]);
+    this.resultState = module2.cwrap("hyperdb_wasm_result_state", "number", ["number"]);
+    this.resultPayloadLength = module2.cwrap("hyperdb_wasm_result_payload_len", "number", ["number"]);
+    this.free = module2.cwrap("hyperdb_wasm_free", null, ["pointer"]);
+  }
+  handle(request) {
+    const pointer = safeInteger(this.invoke(request), "result pointer");
+    const result = this.decodeResult(pointer);
+    const response = { id: request.id, type: "response", result };
+    return { response, transfer: result.state === "chunk" ? [result.payload.buffer] : [] };
+  }
+  invoke(request) {
+    switch (request.type) {
+      case "connect":
+        return this.connect();
+      case "disconnect":
+        return this.disconnect(request.connection);
+      case "startQuery":
+        return this.startQuery(request.connection, request.sql);
+      case "pollQuery":
+        return this.pollQuery(request.query);
+      case "cancelQuery":
+        return this.cancelQuery(request.query);
+      case "releaseQuery":
+        return this.releaseQuery(request.query);
+    }
+  }
+  decodeResult(pointer) {
+    if (pointer === 0) return { state: "error", error: "out of memory" };
+    try {
+      const rawState = safeInteger(this.resultState(pointer), "result state");
+      const state = resultStates[rawState];
+      if (!state) return { state: "error", error: `invalid result state ${rawState}` };
+      const payloadLength = safeInteger(this.resultPayloadLength(pointer), "result payload length");
+      const payloadStart = safeInteger(pointer + 8, "result payload start");
+      const payloadEnd = safeInteger(payloadStart + payloadLength, "result payload end");
+      if (payloadEnd > this.module.HEAPU8.byteLength) throw new Error("result payload exceeds the wasm heap");
+      const payload = new Uint8Array(payloadLength);
+      payload.set(this.module.HEAPU8.subarray(payloadStart, payloadEnd));
+      switch (state) {
+        case "ok":
+          return { state, payload };
+        case "pending":
+          return { state };
+        case "chunk":
+          return { state, payload };
+        case "done":
+          return { state };
+        case "error":
+          return { state, error: new TextDecoder().decode(payload) };
+        case "busy":
+          return { state, error: new TextDecoder().decode(payload) };
+      }
+    } finally {
+      this.free(pointer);
+    }
+  }
+};
+
+// protocol.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasKeys(value, keys) {
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function isEngineRequest(value) {
+  if (!isRecord(value) || !Number.isSafeInteger(value.id) || typeof value.type !== "string") return false;
+  switch (value.type) {
+    case "connect":
+      return hasKeys(value, ["id", "type"]);
+    case "disconnect":
+      return hasKeys(value, ["id", "type", "connection"]) && Number.isSafeInteger(value.connection);
+    case "startQuery":
+      return hasKeys(value, ["id", "type", "connection", "sql"]) && Number.isSafeInteger(value.connection) && typeof value.sql === "string";
+    case "pollQuery":
+    case "cancelQuery":
+    case "releaseQuery":
+      return hasKeys(value, ["id", "type", "query"]) && Number.isSafeInteger(value.query);
+    default:
+      return false;
+  }
+}
+
+// worker_setup.ts
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function safePointer(value, name) {
+  const pointer = typeof value === "bigint" && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : value;
+  if (typeof pointer !== "number" || !Number.isSafeInteger(pointer) || pointer < 0) throw new Error(`${name} must be a nonnegative safe integer`);
+  return pointer;
+}
+function allocate(module2, bytes) {
+  const pointer = safePointer(module2._malloc(bytes.byteLength || 1), "allocation pointer");
+  if (pointer === 0) throw new Error("wasm allocation failed");
+  if (pointer + bytes.byteLength > module2.HEAPU8.byteLength) throw new Error("allocation exceeds the wasm heap");
+  module2.HEAPU8.set(bytes, pointer);
+  return pointer;
+}
+function installHttpRuntime(module2, transport2) {
+  module2.hyperdbWasmFetchStart = (id, url, offset, length) => {
+    const headers = new Headers();
+    if (length > 0) headers.set("Range", `bytes=${offset}-${offset + length - 1}`);
+    void fetch(url, { headers }).then(async (response) => {
+      if (!response.ok && response.status !== 206) {
+        module2._hyperdb_wasm_fetch_complete(id, 0, -1);
+        return;
+      }
+      const bytes = new Uint8Array(await response.arrayBuffer());
+      module2._hyperdb_wasm_fetch_complete(id, allocate(module2, bytes), bytes.byteLength);
+    }).catch((error) => {
+      transport2.postMessage({ type: "log", text: `fetch failed: ${errorText(error)}` });
+      module2._hyperdb_wasm_fetch_complete(id, 0, -1);
+    });
+  };
+  module2.hyperdbWasmHttpStart = (id, method, url, headerLines, bodyPointer, bodyLength) => {
+    const headers = new Headers();
+    for (const line of headerLines.split("\n")) {
+      const separator = line.indexOf(":");
+      if (separator > 0) headers.set(line.slice(0, separator), line.slice(separator + 1));
+    }
+    const pointer = safePointer(bodyPointer, "HTTP body pointer");
+    const bodyEnd = safePointer(pointer + bodyLength, "HTTP body end");
+    if (bodyEnd > module2.HEAPU8.byteLength) throw new Error("HTTP body exceeds the wasm heap");
+    const body = bodyLength > 0 ? module2.HEAPU8.slice(pointer, bodyEnd) : void 0;
+    const init = { method, headers };
+    if (body) init.body = body;
+    void fetch(url, init).then(async (response) => {
+      const responseBody = new Uint8Array(await response.arrayBuffer());
+      let responseHeaders = "";
+      response.headers.forEach((value, name) => {
+        responseHeaders += `${name.toLowerCase()}:${value}
+`;
+      });
+      const headersPointer = responseHeaders ? safePointer(module2.stringToNewUTF8(responseHeaders), "headers pointer") : 0;
+      const responseBodyPointer = responseBody.byteLength ? allocate(module2, responseBody) : 0;
+      module2._hyperdb_wasm_http_complete(id, response.status, headersPointer, responseBodyPointer, responseBody.byteLength);
+    }).catch((error) => {
+      const errorBytes = new TextEncoder().encode(errorText(error));
+      module2._hyperdb_wasm_http_complete(id, -1, 0, allocate(module2, errorBytes), errorBytes.byteLength);
+    });
+  };
+}
+function configureWorker(module2, transport2) {
+  const queuedRequests = [];
+  let bindings;
+  const handle = (request) => {
+    if (!bindings) {
+      queuedRequests.push(request);
+      return;
+    }
+    try {
+      const result = bindings.handle(request);
+      transport2.postMessage(result.response, result.transfer);
+    } catch (error) {
+      transport2.postMessage({ id: request.id, type: "response", result: { state: "error", error: errorText(error) } });
+    }
+  };
+  transport2.onMessage((message) => {
+    if (isEngineRequest(message)) handle(message);
+  });
+  module2.arguments = ["--no-demo"];
+  module2.print = (text) => transport2.postMessage({ type: "log", text });
+  module2.printErr = (text) => transport2.postMessage({ type: "log", text });
+  module2.onRuntimeInitialized = () => {
+    installHttpRuntime(module2, transport2);
+    bindings = new HyperDBBindings(module2);
+    transport2.postMessage({ type: "ready" });
+    for (const request of queuedRequests.splice(0)) handle(request);
+  };
+  module2.onAbort = (reason) => transport2.postMessage({ type: "fatal", error: `engine aborted: ${String(reason)}` });
+}
+
+// node_worker.ts
+if (!parentPort) throw new Error("Node engine worker requires a parent port");
+var enginePort = parentPort;
+var options = workerData;
+var engineUrl = options?.engineUrl ?? fileURLToPath(new URL("./hyperdb-wasm.cjs", import.meta.url));
+var transport = {
+  postMessage: (message, transfer = []) => enginePort.postMessage(message, [...transfer]),
+  onMessage: (listener) => enginePort.on("message", listener)
+};
+process.argv.push("--no-demo");
+var compressedWasm = join(dirname(engineUrl), "hyperdb-wasm.wasm.br");
+var decompressedWasm = Readable.toWeb(createReadStream(compressedWasm).pipe(createBrotliDecompress()));
+var compiledWasm = await WebAssembly.compileStreaming(new Response(decompressedWasm, {
+  headers: { "Content-Type": "application/wasm" }
+}));
+var moduleConfiguration = {
+  instantiateWasm: (imports, receiveInstance) => {
+    void WebAssembly.instantiate(compiledWasm, imports).then((instance) => receiveInstance(instance, compiledWasm));
+    return {};
+  }
+};
+var configuredGlobal = globalThis;
+configuredGlobal.HYPERDB_WASM_MODULE = moduleConfiguration;
+var module = createRequire(import.meta.url)(engineUrl);
+delete configuredGlobal.HYPERDB_WASM_MODULE;
+configureWorker(module, transport);