hyperdb-wasm 0.0.26281-dev.wasm.g39d82636

package/dist/protocol.d.ts

@@ -0,0 +1,67 @@
+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: '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,252 @@
+// 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 });
+  }
+  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();
+  }
+};
+
+// 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);
+    }
+  }
+};
+
+// 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';

package/dist/raw.node.js

@@ -0,0 +1,254 @@
+// 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 });
+  }
+  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();
+  }
+};
+
+// 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);
+    }
+  }
+};
+
+// node.ts
+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 } })));
+}
+export {
+  HyperDBBindings,
+  HyperDBEngineClient,
+  NodeWorker,
+  createNodeClient
+};

package/dist/wasm_bindings.d.ts

@@ -0,0 +1,27 @@
+import type { EngineRequest, WasmResponse } from './protocol.js';
+type CFunction = (...args: readonly unknown[]) => unknown;
+export interface HyperDBWasmModule {
+    readonly HEAPU8: Uint8Array;
+    cwrap(name: string, returnType?: string | null, argumentTypes?: readonly string[]): CFunction;
+}
+export type BindingResponse = {
+    response: WasmResponse;
+    transfer: readonly ArrayBuffer[];
+};
+export declare class HyperDBBindings {
+    private readonly module;
+    private readonly connect;
+    private readonly disconnect;
+    private readonly startQuery;
+    private readonly pollQuery;
+    private readonly cancelQuery;
+    private readonly releaseQuery;
+    private readonly resultState;
+    private readonly resultPayloadLength;
+    private readonly free;
+    constructor(module: HyperDBWasmModule);
+    handle(request: EngineRequest): BindingResponse;
+    private invoke;
+    private decodeResult;
+}
+export {};

package/dist/worker_setup.d.ts

@@ -0,0 +1,22 @@
+import type { HyperDBWasmModule } from './wasm_bindings.js';
+import type { WorkerEvent } from './protocol.js';
+export interface WorkerHostTransport {
+    postMessage(message: WorkerEvent, transfer?: readonly ArrayBuffer[]): void;
+    onMessage(listener: (message: unknown) => void): void;
+}
+export interface HyperDBWasmRuntimeModule extends HyperDBWasmModule {
+    HEAPU8: Uint8Array;
+    _malloc(size: number): number | bigint;
+    _hyperdb_wasm_fetch_complete(id: number, pointer: number, length: number): void;
+    _hyperdb_wasm_http_complete(id: number, status: number, headersPointer: number, bodyPointer: number, bodyLength: number): void;
+    stringToNewUTF8(value: string): number | bigint;
+    arguments?: string[];
+    print?: (text: string) => void;
+    printErr?: (text: string) => void;
+    onRuntimeInitialized?: () => void;
+    onAbort?: (reason: unknown) => void;
+    locateFile?: (path: string, prefix: string) => string;
+    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;
+}
+export declare function configureWorker(module: HyperDBWasmRuntimeModule, transport: WorkerHostTransport): void;