hyperdb-wasm 0.0.26268-dev.remotes-origin-wasm.gcf8d815a

package/dist/node_worker.js

@@ -0,0 +1,277 @@
+// node_worker.ts
+import { createReadStream } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, posix, relative, resolve, sep } 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;
+  insertArrowIPCFromPath;
+  pollQuery;
+  cancelQuery;
+  releaseQuery;
+  resultState;
+  resultPayloadLength;
+  free;
+  nextTemporaryFile = 1;
+  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.insertArrowIPCFromPath = module2.cwrap("hyperdb_wasm_arrow_insert_from_path", "pointer", ["number", "string", "string", "string", "number"]);
+    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) {
+    if (request.type === "createTemporaryFile") {
+      const path = `/tmp/hyperdb/arrow-${this.nextTemporaryFile++}.arrows`;
+      this.module.FS.mkdirTree("/tmp/hyperdb");
+      this.module.FS.writeFile(path, request.bytes);
+      return { response: { id: request.id, type: "response", result: { state: "ok", payload: new TextEncoder().encode(path) } }, transfer: [] };
+    }
+    if (request.type === "removeFile") {
+      this.module.FS.unlink(request.path);
+      return { response: { id: request.id, type: "response", result: { state: "ok", payload: new Uint8Array() } }, transfer: [] };
+    }
+    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 "insertArrowIPCFromPath": {
+        const path = request.internal ? request.path : this.module.resolveHyperDBPath?.(request.path) ?? request.path;
+        return this.insertArrowIPCFromPath(request.connection, path, request.name, request.schema ?? "", Number(request.create));
+      }
+      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 "insertArrowIPCFromPath":
+      return hasKeys(value, ["id", "type", "connection", "path", "name", "schema", "create", "internal"]) && Number.isSafeInteger(value.connection) && typeof value.path === "string" && typeof value.name === "string" && (typeof value.schema === "string" || value.schema === null) && typeof value.create === "boolean" && typeof value.internal === "boolean";
+    case "createTemporaryFile":
+      return hasKeys(value, ["id", "type", "bytes"]) && value.bytes instanceof Uint8Array;
+    case "removeFile":
+      return hasKeys(value, ["id", "type", "path"]) && typeof value.path === "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, configureFilesystem = () => void 0) {
+  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 = () => {
+    try {
+      configureFilesystem(module2);
+      installHttpRuntime(module2, transport2);
+      bindings = new HyperDBBindings(module2);
+      transport2.postMessage({ type: "ready" });
+      for (const request of queuedRequests.splice(0)) handle(request);
+    } catch (error) {
+      transport2.postMessage({ type: "fatal", error: `engine initialization failed: ${errorText(error)}` });
+    }
+  };
+  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 hostPath = resolve(options?.hostPath ?? process.cwd());
+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, (runtime) => {
+  if (!runtime.NODEFS) throw new Error("Node filesystem backend is unavailable");
+  runtime.FS.mkdirTree("/host");
+  runtime.FS.mount(runtime.NODEFS, { root: hostPath }, "/host");
+  runtime.resolveHyperDBPath = (path) => {
+    const absolute = resolve(isAbsolute(path) ? path : join(hostPath, path));
+    const suffix = relative(hostPath, absolute);
+    if (suffix === ".." || suffix.startsWith(`..${sep}`) || isAbsolute(suffix)) {
+      throw new Error(`Arrow IPC path is outside the mounted host directory: ${path}`);
+    }
+    return posix.join("/host", ...suffix.split(sep));
+  };
+});

package/dist/protocol.d.ts

@@ -0,0 +1,84 @@
+export type RequestId = number;
+export type EngineRequest = {
+    id: RequestId;
+    type: 'connect';
+} | {
+    id: RequestId;
+    type: 'disconnect';
+    connection: number;
+} | {
+    id: RequestId;
+    type: 'startQuery';
+    connection: number;
+    sql: string;
+} | {
+    id: RequestId;
+    type: 'insertArrowIPCFromPath';
+    connection: number;
+    path: string;
+    name: string;
+    schema: string | null;
+    create: boolean;
+    internal: boolean;
+} | {
+    id: RequestId;
+    type: 'createTemporaryFile';
+    bytes: Uint8Array;
+} | {
+    id: RequestId;
+    type: 'removeFile';
+    path: string;
+} | {
+    id: RequestId;
+    type: 'pollQuery';
+    query: number;
+} | {
+    id: RequestId;
+    type: 'cancelQuery';
+    query: number;
+} | {
+    id: RequestId;
+    type: 'releaseQuery';
+    query: number;
+};
+export type WasmResult = {
+    state: 'ok';
+    payload: Uint8Array;
+} | {
+    state: 'pending';
+} | {
+    state: 'chunk';
+    payload: Uint8Array;
+} | {
+    state: 'done';
+} | {
+    state: 'error';
+    error: string;
+} | {
+    state: 'busy';
+    error: string;
+};
+export type WasmResponse = {
+    id: RequestId;
+    type: 'response';
+    result: WasmResult;
+};
+export type WorkerEvent = {
+    type: 'ready';
+} | {
+    type: 'fatal';
+    error: string;
+} | {
+    type: 'log';
+    text: string;
+} | WasmResponse;
+export interface WorkerTransport {
+    postMessage(message: EngineRequest, transfer?: readonly ArrayBuffer[]): void;
+    onMessage(listener: (message: unknown) => void): () => void;
+    onError(listener: (error: Error) => void): () => void;
+    onClose(listener: (error: Error) => void): () => void;
+    terminate(): void | Promise<unknown>;
+}
+export declare function isWasmResult(value: unknown): value is WasmResult;
+export declare function isEngineRequest(value: unknown): value is EngineRequest;
+export declare function isWorkerEvent(message: unknown): message is WorkerEvent;

package/dist/raw.browser.d.ts

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

package/dist/raw.browser.js

@@ -0,0 +1,279 @@
+// 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;
+  }
+}
+
+// client.ts
+var 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 });
+  }
+  insertArrowIPCFromPath(connection, path, name, schema, create, internal = false) {
+    return this.request({ id: this.nextId++, type: "insertArrowIPCFromPath", connection, path, name, schema, create, internal });
+  }
+  createTemporaryFile(bytes) {
+    const payload = bytes.slice();
+    return this.request({ id: this.nextId++, type: "createTemporaryFile", bytes: payload }, [payload.buffer]);
+  }
+  removeFile(path) {
+    return this.request({ id: this.nextId++, type: "removeFile", path });
+  }
+  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, transfer = []) {
+    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, transfer);
+      } 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();
+  }
+};
+
+// 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;
+  insertArrowIPCFromPath;
+  pollQuery;
+  cancelQuery;
+  releaseQuery;
+  resultState;
+  resultPayloadLength;
+  free;
+  nextTemporaryFile = 1;
+  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.insertArrowIPCFromPath = module.cwrap("hyperdb_wasm_arrow_insert_from_path", "pointer", ["number", "string", "string", "string", "number"]);
+    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) {
+    if (request.type === "createTemporaryFile") {
+      const path = `/tmp/hyperdb/arrow-${this.nextTemporaryFile++}.arrows`;
+      this.module.FS.mkdirTree("/tmp/hyperdb");
+      this.module.FS.writeFile(path, request.bytes);
+      return { response: { id: request.id, type: "response", result: { state: "ok", payload: new TextEncoder().encode(path) } }, transfer: [] };
+    }
+    if (request.type === "removeFile") {
+      this.module.FS.unlink(request.path);
+      return { response: { id: request.id, type: "response", result: { state: "ok", payload: new Uint8Array() } }, transfer: [] };
+    }
+    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 "insertArrowIPCFromPath": {
+        const path = request.internal ? request.path : this.module.resolveHyperDBPath?.(request.path) ?? request.path;
+        return this.insertArrowIPCFromPath(request.connection, path, request.name, request.schema ?? "", Number(request.create));
+      }
+      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);
+    }
+  }
+};
+
+// browser.ts
+var 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();
+  }
+};
+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" })));
+}
+export {
+  BrowserWorker,
+  HyperDBBindings,
+  HyperDBEngineClient,
+  createBrowserClient
+};

package/dist/raw.d.ts

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

package/dist/raw.node.d.ts

@@ -0,0 +1,3 @@
+export * from './raw.js';
+export { NodeWorker, createNodeClient } from './node.js';
+export type { NodeClientOptions, NodeWorkerLike } from './node.js';