hyperdb-wasm 0.0.27361-dev.wasm.g7817abf3 → 0.0.27368-dev.wasm.ge6142229

package/dist/api.d.ts

@@ -14,6 +14,8 @@ export interface HyperDBClient {
     mount(source: MountSource, path: string, mode: MountAccessMode): Promise<WasmResult>;
     unmount(path: string): Promise<WasmResult>;
     refreshMount(path: string): Promise<WasmResult>;
+    listMount(path: string): Promise<WasmResult>;
+    readMountFile(path: string, file: string): Promise<WasmResult>;
     pollQuery(query: number): Promise<WasmResult>;
     cancelQuery(query: number): Promise<WasmResult>;
     finishQuery(query: number): Promise<WasmResult>;
@@ -31,8 +33,14 @@ export interface MountOptions {
 export interface MountedResource {
     readonly path: string;
     refresh(): Promise<void>;
+    list(): Promise<readonly MountFileEntry[]>;
+    readFile(path: string): Promise<Blob>;
     close(): Promise<void>;
 }
+export interface MountFileEntry {
+    readonly path: string;
+    readonly size: number;
+}
 export declare function validateMountPath(path: unknown): asserts path is string;
 export type HyperDBSettingValue = string | number | boolean | null | readonly HyperDBSettingValue[] | {
     readonly [key: string]: HyperDBSettingValue;

package/dist/browser.d.ts

@@ -8,12 +8,18 @@ export interface BrowserWorkerLike {
     terminate(): void;
 }
 export interface BrowserClientOptions {
+    /** Blob workers inline both scripts so pthreads can start without an origin */
+    readonly worker?: 'url' | 'blob';
+    /** Memory storage is private to this engine and discarded on termination */
+    readonly storage?: 'persistent' | 'memory';
     readonly workerUrl?: string | URL;
     readonly engineUrl?: string | URL;
     readonly wasmUrl?: string | URL;
     /** OPFS-relative directory mounted as the durable filesystem root. */
     readonly storagePath?: string;
     readonly onSetupProgress?: (progress: SetupProgress) => void;
+    /** Receives engine output; omitted callbacks discard output, and callback exceptions are ignored */
+    readonly onLog?: (stream: 'stdout' | 'stderr', text: string) => void;
 }
 type BrowserEnvironment = {
     readonly WebAssembly?: typeof WebAssembly;
@@ -28,10 +34,11 @@ type BrowserEnvironment = {
         };
     };
 };
-export declare function assertBrowserSupport(environment?: BrowserEnvironment): void;
+export declare function assertBrowserSupport(environment?: BrowserEnvironment, storage?: BrowserClientOptions['storage']): void;
 export declare class BrowserWorker implements WorkerTransport {
     private readonly worker;
-    constructor(worker: BrowserWorkerLike);
+    private blobUrl?;
+    constructor(worker: BrowserWorkerLike, blobUrl?: string | undefined);
     postMessage(message: EngineRequest, transfer?: readonly ArrayBuffer[]): void;
     onMessage(listener: (message: unknown) => void): () => void;
     onError(listener: (error: Error) => void): () => void;
@@ -39,5 +46,11 @@ export declare class BrowserWorker implements WorkerTransport {
     terminate(): void;
 }
 export declare function resolveBrowserWorkerUrl(workerUrl: string | URL, engineUrl: string | URL, wasmUrl?: string | URL, storagePath?: string, baseUrl?: string | URL): URL;
-export declare function createBrowserClient(options?: BrowserClientOptions): HyperDBEngineClient;
+export declare function createBrowserClient(options: BrowserClientOptions & {
+    worker: 'blob';
+}): Promise<HyperDBEngineClient>;
+export declare function createBrowserClient(options?: BrowserClientOptions & {
+    worker?: 'url';
+}): HyperDBEngineClient;
+export declare function createBrowserClient(options: BrowserClientOptions): HyperDBEngineClient | Promise<HyperDBEngineClient>;
 export {};

package/dist/browser.js

@@ -28,6 +28,10 @@ function isWasmResult(value) {
     case "ok":
     case "chunk":
       return hasKeys(value, ["state", "payload"]) && value.payload instanceof Uint8Array;
+    case "mountList":
+      return hasKeys(value, ["state", "entries"]) && Array.isArray(value.entries) && value.entries.every((entry) => isRecord(entry) && hasKeys(entry, ["path", "size"]) && typeof entry.path === "string" && !!entry.path && Number.isSafeInteger(entry.size) && entry.size >= 0);
+    case "mountFile":
+      return hasKeys(value, ["state", "blob"]) && value.blob instanceof Blob;
     case "pending":
     case "done":
       return hasKeys(value, ["state"]);
@@ -52,7 +56,7 @@ function isWorkerEvent(message) {
     case "fatal":
       return hasKeys(message, ["type", "error"]) && typeof message.error === "string";
     case "log":
-      return hasKeys(message, ["type", "text"]) && typeof message.text === "string";
+      return hasKeys(message, ["type", "stream", "text"]) && (message.stream === "stdout" || message.stream === "stderr") && typeof message.text === "string";
     case "response":
       return hasKeys(message, ["id", "type", "result"]) && Number.isSafeInteger(message.id) && isWasmResult(message.result);
     default:
@@ -72,8 +76,9 @@ var init_client = __esm({
     "use strict";
     init_protocol();
     HyperDBEngineClient = class {
-      constructor(transport, onSetupProgress) {
+      constructor(transport, onSetupProgress, onLog) {
         this.onSetupProgress = onSetupProgress;
+        this.onLog = onLog;
         this.transport = transport;
         this.readyPromise = new Promise((resolve, reject) => {
           this.resolveReady = resolve;
@@ -86,6 +91,7 @@ var init_client = __esm({
         ];
       }
       onSetupProgress;
+      onLog;
       transport;
       pending = /* @__PURE__ */ new Map();
       readyPromise;
@@ -125,6 +131,12 @@ var init_client = __esm({
       refreshMount(path) {
         return this.request({ id: this.nextId++, type: "refreshMount", path });
       }
+      listMount(path) {
+        return this.request({ id: this.nextId++, type: "listMount", path });
+      }
+      readMountFile(path, file) {
+        return this.request({ id: this.nextId++, type: "readMountFile", path, file });
+      }
       pollQuery(query) {
         return this.request({ id: this.nextId++, type: "pollQuery", query });
       }
@@ -167,6 +179,13 @@ var init_client = __esm({
           this.onSetupProgress?.({ bytesLoaded: message.bytesLoaded, bytesTotal: message.bytesTotal });
           return;
         }
+        if (message.type === "log") {
+          try {
+            this.onLog?.(message.stream, message.text);
+          } catch {
+          }
+          return;
+        }
         if (message.type === "fatal") {
           this.failAndTerminate(new Error(message.error || "engine aborted"));
           return;
@@ -201,7 +220,7 @@ __export(browser_exports, {
   createBrowserClient: () => createBrowserClient,
   resolveBrowserWorkerUrl: () => resolveBrowserWorkerUrl
 });
-function assertBrowserSupport(environment = globalThis) {
+function assertBrowserSupport(environment = globalThis, storage = "persistent") {
   if (typeof environment.WebAssembly?.validate !== "function") {
     throw new Error("HyperDB cannot initialize because this browser does not support WebAssembly");
   }
@@ -232,7 +251,7 @@ function assertBrowserSupport(environment = globalThis) {
   if (environment.crossOriginIsolated !== true) {
     throw new Error("HyperDB cannot initialize because this page is not cross-origin isolated");
   }
-  if (typeof environment.navigator?.storage?.getDirectory !== "function") {
+  if (storage !== "memory" && typeof environment.navigator?.storage?.getDirectory !== "function") {
     throw new Error("HyperDB cannot initialize because this browser does not support the origin-private file system");
   }
 }
@@ -244,14 +263,51 @@ function resolveBrowserWorkerUrl(workerUrl, engineUrl, wasmUrl, storagePath, bas
   return resolved;
 }
 function createBrowserClient(options = {}) {
-  assertBrowserSupport();
+  if (options.storage === "memory" && options.storagePath !== void 0) throw new Error("storagePath cannot be used with memory storage");
+  if (options.storage !== void 0 && options.storage !== "persistent" && options.storage !== "memory") throw new Error("Unsupported storage mode");
+  if (options.worker !== void 0 && options.worker !== "url" && options.worker !== "blob") throw new Error("Unsupported worker mode");
+  assertBrowserSupport(globalThis, options.storage);
   const workerUrl = options.workerUrl ?? new URL("./browser_worker.js", import.meta.url);
   const engineUrl = options.engineUrl ?? new URL("./hyperdb-wasm.js", import.meta.url);
+  if (options.worker === "blob") return createBlobClient(options, workerUrl, engineUrl);
+  const resolved = resolveBrowserWorkerUrl(workerUrl, engineUrl, options.wasmUrl, options.storagePath);
+  if (options.storage === "memory") resolved.searchParams.set("storage", "memory");
   return new HyperDBEngineClient(
-    new BrowserWorker(new Worker(resolveBrowserWorkerUrl(workerUrl, engineUrl, options.wasmUrl, options.storagePath), { type: "classic" })),
-    options.onSetupProgress
+    new BrowserWorker(new Worker(resolved, { type: "classic" })),
+    options.onSetupProgress,
+    options.onLog
   );
 }
+async function createBlobClient(options, workerUrl, engineUrl) {
+  const baseUrl = globalThis.document?.baseURI ?? globalThis.location?.href ?? import.meta.url;
+  const resolvedEngineUrl = new URL(engineUrl, baseUrl);
+  const configuration = {
+    engineUrl: resolvedEngineUrl.href,
+    wasmUrl: options.wasmUrl === void 0 ? new URL("hyperdb-wasm.wasm.br", resolvedEngineUrl).href : new URL(options.wasmUrl, baseUrl).href,
+    storage: options.storage ?? "persistent",
+    storagePath: options.storagePath ?? "",
+    inlineEngine: true
+  };
+  const fetchScript = async (url) => {
+    const response = await fetch(url, { mode: "cors", credentials: "omit" });
+    if (!response.ok) throw new Error(`Failed to fetch HyperDB script: ${response.status} ${response.statusText}`);
+    return (await response.text()).replace(/^#![^\r\n]*/, "");
+  };
+  const [workerScript, engineScript] = await Promise.all([fetchScript(new URL(workerUrl, baseUrl)), fetchScript(resolvedEngineUrl)]);
+  const blobUrl = URL.createObjectURL(new Blob([
+    `self.HYPERDB_WASM_CONFIGURATION = ${JSON.stringify(configuration)};
+`,
+    workerScript,
+    "\n",
+    engineScript
+  ], { type: "text/javascript" }));
+  try {
+    return new HyperDBEngineClient(new BrowserWorker(new Worker(blobUrl, { type: "classic" }), blobUrl), options.onSetupProgress, options.onLog);
+  } catch (error) {
+    URL.revokeObjectURL(blobUrl);
+    throw error;
+  }
+}
 var memory64Probe, threadsProbe, exceptionsProbe, tailCallsProbe, BrowserWorker;
 var init_browser = __esm({
   "src/browser.ts"() {
@@ -262,10 +318,12 @@ var init_browser = __esm({
     exceptionsProbe = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 13, 3, 1, 0, 0]);
     tailCallsProbe = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 10, 9, 2, 4, 0, 18, 1, 11, 2, 0, 11]);
     BrowserWorker = class {
-      constructor(worker) {
+      constructor(worker, blobUrl) {
         this.worker = worker;
+        this.blobUrl = blobUrl;
       }
       worker;
+      blobUrl;
       postMessage(message, transfer = []) {
         this.worker.postMessage(message, [...transfer]);
       }
@@ -283,7 +341,12 @@ var init_browser = __esm({
         return () => void 0;
       }
       terminate() {
-        this.worker.terminate();
+        try {
+          this.worker.terminate();
+        } finally {
+          if (this.blobUrl !== void 0) URL.revokeObjectURL(this.blobUrl);
+          this.blobUrl = void 0;
+        }
       }
     };
   }
@@ -291,6 +354,43 @@ var init_browser = __esm({
 
 // src/api.ts
 import { RecordBatchReader, Table } from "apache-arrow";
+
+// src/memory_directory.ts
+function validateMemoryFilePath(path) {
+  if (!path || path.startsWith("/") || path.endsWith("/") || path.includes("\\") || path.includes("\0") || path.split("/").some((segment) => !segment || segment === "." || segment === "..")) {
+    throw new Error("Memory directory file path must contain safe relative path segments");
+  }
+}
+var MemoryDirectory = class {
+  kind = "memory-directory";
+  files;
+  maxBytes;
+  constructor(options = {}) {
+    if (options.maxBytes !== void 0 && (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0)) {
+      throw new Error("Memory directory maxBytes must be a nonnegative safe integer");
+    }
+    const files = { ...options.files };
+    let size = 0;
+    for (const [path, blob] of Object.entries(files)) {
+      validateMemoryFilePath(path);
+      if (!(blob instanceof Blob)) throw new Error("Memory directory files must be Blobs");
+      size += blob.size;
+      if (!Number.isSafeInteger(size)) throw new Error("Memory directory size must be a safe integer");
+      const segments = path.split("/");
+      for (let index = 1; index < segments.length; ++index) {
+        if (Object.hasOwn(files, segments.slice(0, index).join("/"))) throw new Error("Memory directory file paths overlap");
+      }
+    }
+    if (options.maxBytes !== void 0 && size > options.maxBytes) throw new Error("Memory directory quota exceeded (maxBytes)");
+    this.files = Object.freeze(files);
+    if (options.maxBytes !== void 0) this.maxBytes = options.maxBytes;
+  }
+  toMountSource() {
+    return { kind: "memory-directory", files: this.files, ...this.maxBytes !== void 0 && { maxBytes: this.maxBytes } };
+  }
+};
+
+// src/api.ts
 function validateMountPath(path) {
   if (typeof path !== "string" || !path.startsWith("/mnt/external/")) {
     throw new Error("Mount path must be an absolute path below /mnt/external");
@@ -516,21 +616,33 @@ var EngineQueryOperation = class {
   }
 };
 var MountedResourceImpl = class {
-  constructor(path, unmount, refreshMount) {
+  constructor(path, unmount, refreshMount, listMount, readMountFile) {
     this.path = path;
     this.unmount = unmount;
     this.refreshMount = refreshMount;
+    this.listMount = listMount;
+    this.readMountFile = readMountFile;
   }
   path;
   unmount;
   refreshMount;
+  listMount;
+  readMountFile;
   closed = false;
   closing;
   async refresh() {
-    if (this.closed) throw new Error("mounted resource is closed");
-    if (this.closing) throw new Error("mounted resource is closing");
+    this.ensureOpen();
     await this.refreshMount(this.path);
   }
+  async list() {
+    this.ensureOpen();
+    return this.listMount(this.path);
+  }
+  async readFile(path) {
+    this.ensureOpen();
+    validateMemoryFilePath(path);
+    return this.readMountFile(this.path, path);
+  }
   async close() {
     if (this.closed) return;
     if (!this.closing) {
@@ -549,6 +661,10 @@ var MountedResourceImpl = class {
   releaseAfterShutdown() {
     this.closed = true;
   }
+  ensureOpen() {
+    if (this.closed) throw new Error("mounted resource is closed");
+    if (this.closing) throw new Error("mounted resource is closing");
+  }
 };
 var HyperDB = class _HyperDB {
   constructor(client) {
@@ -562,7 +678,7 @@ var HyperDB = class _HyperDB {
   mountedResources = /* @__PURE__ */ new Set();
   static async create(options = {}) {
     const { createBrowserClient: createBrowserClient2 } = await Promise.resolve().then(() => (init_browser(), browser_exports));
-    const client = createBrowserClient2(options);
+    const client = await createBrowserClient2(options);
     const database = new _HyperDB(client);
     try {
       await database.ready();
@@ -598,6 +714,16 @@ var HyperDB = class _HyperDB {
         (mounted) => this.unmount(mounted),
         (path2) => this.runDatabaseOperation(async () => {
           expectOk(await this.client.refreshMount(path2), "refresh mount");
+        }),
+        (path2) => this.runDatabaseOperation(async () => {
+          const result2 = await this.client.listMount(path2);
+          if (result2.state !== "mountList") throw readErrorFromResult(result2, "list mount");
+          return result2.entries;
+        }),
+        (path2, file) => this.runDatabaseOperation(async () => {
+          const result2 = await this.client.readMountFile(path2, file);
+          if (result2.state !== "mountFile") throw readErrorFromResult(result2, "read mount file");
+          return result2.blob;
         })
       );
       this.mountedResources.add(resource);
@@ -755,12 +881,17 @@ var HyperDBConnection = class {
     const result = {
       [Symbol.asyncIterator]() {
         return {
-          next() {
-            if (operation.aborted && !abortDelivered) {
-              abortDelivered = true;
-              return Promise.reject(operation.abortReason);
+          async next() {
+            try {
+              if (operation.aborted && !abortDelivered) {
+                abortDelivered = true;
+                throw operation.abortReason;
+              }
+              return await operation.interrupt(generator.next());
+            } catch (error) {
+              await generator.return(void 0);
+              throw error;
             }
-            return operation.interrupt(generator.next());
           },
           return(value) {
             return generator.return(value);
@@ -804,12 +935,14 @@ var HyperDBConnection = class {
     return queryPromise(result, stream.info);
   }
   query(sql, options = {}) {
-    const stream = this.queryStream(sql, options);
+    const stream = this.queryStreamIPC(sql, options);
     const result = (async () => {
-      const reader = await stream;
+      const reader = await RecordBatchReader.from(stream);
+      await reader.open();
+      const schema = reader.schema;
       const batches = [];
       for await (const batch of reader) batches.push(batch);
-      return new Table(reader.schema, batches);
+      return schema ? new Table(schema, batches) : new Table();
     })();
     return queryPromise(result, stream.info);
   }
@@ -844,7 +977,7 @@ var HyperDBConnection = class {
 init_browser();
 var HyperDB2 = class _HyperDB extends HyperDB {
   static async create(options = {}) {
-    const client = createBrowserClient(options);
+    const client = await createBrowserClient(options);
     const database = new _HyperDB(client);
     try {
       await database.ready();
@@ -861,6 +994,11 @@ var HyperDB2 = class _HyperDB extends HyperDB {
   async mount(source, options) {
     const path = options?.path;
     validateMountPath(path);
+    if (source && "kind" in source && source.kind === "memory-directory") {
+      const mode2 = options.mode ?? "read";
+      if (mode2 !== "read" && mode2 !== "readwrite") throw new Error(`Unsupported mount mode: ${String(mode2)}`);
+      return this.mountSource(new MemoryDirectory(source).toMountSource(), path, mode2);
+    }
     if (typeof File !== "undefined" && source instanceof File) {
       if (options.mode !== void 0 && options.mode !== "read") throw new Error("File mounts are always read-only");
       if (!source.name) throw new Error("Mounted file name must not be empty");
@@ -890,5 +1028,6 @@ var HyperDB2 = class _HyperDB extends HyperDB {
 export {
   HyperDB2 as HyperDB,
   HyperDBConnection,
-  HyperDBError
+  HyperDBError,
+  MemoryDirectory
 };