hyperdb-wasm 0.0.26281-dev.wasm.g39d82636

package/dist/browser_worker.d.ts

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

package/dist/browser_worker.js

@@ -0,0 +1,226 @@
+"use strict";
+(() => {
+  // 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(module) {
+      this.module = module;
+      this.connect = module.cwrap("hyperdb_wasm_connect", "pointer", []);
+      this.disconnect = module.cwrap("hyperdb_wasm_disconnect", "pointer", ["number"]);
+      this.startQuery = module.cwrap("hyperdb_wasm_query_start", "pointer", ["number", "string"]);
+      this.pollQuery = module.cwrap("hyperdb_wasm_query_poll", "pointer", ["number"]);
+      this.cancelQuery = module.cwrap("hyperdb_wasm_query_cancel", "pointer", ["number"]);
+      this.releaseQuery = module.cwrap("hyperdb_wasm_query_release", "pointer", ["number"]);
+      this.resultState = module.cwrap("hyperdb_wasm_result_state", "number", ["number"]);
+      this.resultPayloadLength = module.cwrap("hyperdb_wasm_result_payload_len", "number", ["number"]);
+      this.free = module.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(module, bytes) {
+    const pointer = safePointer(module._malloc(bytes.byteLength || 1), "allocation pointer");
+    if (pointer === 0) throw new Error("wasm allocation failed");
+    if (pointer + bytes.byteLength > module.HEAPU8.byteLength) throw new Error("allocation exceeds the wasm heap");
+    module.HEAPU8.set(bytes, pointer);
+    return pointer;
+  }
+  function installHttpRuntime(module, transport) {
+    module.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) {
+          module._hyperdb_wasm_fetch_complete(id, 0, -1);
+          return;
+        }
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        module._hyperdb_wasm_fetch_complete(id, allocate(module, bytes), bytes.byteLength);
+      }).catch((error) => {
+        transport.postMessage({ type: "log", text: `fetch failed: ${errorText(error)}` });
+        module._hyperdb_wasm_fetch_complete(id, 0, -1);
+      });
+    };
+    module.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 > module.HEAPU8.byteLength) throw new Error("HTTP body exceeds the wasm heap");
+      const body = bodyLength > 0 ? module.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(module.stringToNewUTF8(responseHeaders), "headers pointer") : 0;
+        const responseBodyPointer = responseBody.byteLength ? allocate(module, responseBody) : 0;
+        module._hyperdb_wasm_http_complete(id, response.status, headersPointer, responseBodyPointer, responseBody.byteLength);
+      }).catch((error) => {
+        const errorBytes = new TextEncoder().encode(errorText(error));
+        module._hyperdb_wasm_http_complete(id, -1, 0, allocate(module, errorBytes), errorBytes.byteLength);
+      });
+    };
+  }
+  function configureWorker(module, transport) {
+    const queuedRequests = [];
+    let bindings;
+    const handle = (request) => {
+      if (!bindings) {
+        queuedRequests.push(request);
+        return;
+      }
+      try {
+        const result = bindings.handle(request);
+        transport.postMessage(result.response, result.transfer);
+      } catch (error) {
+        transport.postMessage({ id: request.id, type: "response", result: { state: "error", error: errorText(error) } });
+      }
+    };
+    transport.onMessage((message) => {
+      if (isEngineRequest(message)) handle(message);
+    });
+    module.arguments = ["--no-demo"];
+    module.print = (text) => transport.postMessage({ type: "log", text });
+    module.printErr = (text) => transport.postMessage({ type: "log", text });
+    module.onRuntimeInitialized = () => {
+      installHttpRuntime(module, transport);
+      bindings = new HyperDBBindings(module);
+      transport.postMessage({ type: "ready" });
+      for (const request of queuedRequests.splice(0)) handle(request);
+    };
+    module.onAbort = (reason) => transport.postMessage({ type: "fatal", error: `engine aborted: ${String(reason)}` });
+  }
+
+  // browser_worker.ts
+  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);
+  function isPthreadWorker() {
+    const location = self.location;
+    return self.name === "em-pthread" || location.search?.includes("pthread") === true;
+  }
+  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))
+    };
+    configureWorker(module, transport);
+    self.importScripts(resolvedEngineUrl.href);
+  }
+})();

package/dist/client.d.ts

@@ -0,0 +1,23 @@
+import type { WasmResult, WorkerTransport } from './protocol.js';
+export declare class HyperDBEngineClient {
+    private readonly transport;
+    private readonly pending;
+    private readonly readyPromise;
+    private resolveReady;
+    private rejectReady;
+    private nextId;
+    private failed;
+    private readonly unsubscribe;
+    constructor(transport: WorkerTransport);
+    ready(): Promise<void>;
+    connect(): Promise<WasmResult>;
+    disconnect(connection: number): Promise<WasmResult>;
+    startQuery(connection: number, sql: string): Promise<WasmResult>;
+    pollQuery(query: number): Promise<WasmResult>;
+    cancelQuery(query: number): Promise<WasmResult>;
+    releaseQuery(query: number): Promise<WasmResult>;
+    terminate(): Promise<void>;
+    private request;
+    private onMessage;
+    private fail;
+}