hyperdb-wasm 0.0.27001-dev.wasm.gc5d11398 → 0.0.27099-dev.wasm.g0a1be56f

package/dist/browser.d.ts

@@ -38,6 +38,6 @@ export declare class BrowserWorker implements WorkerTransport {
     onClose(): () => void;
     terminate(): void;
 }
-export declare function resolveBrowserWorkerUrl(workerUrl: string | URL, engineUrl: string | URL, wasmUrl?: string | URL, storagePath?: string): URL;
+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 {};

package/dist/browser.js

@@ -228,10 +228,10 @@ function assertBrowserSupport(environment = globalThis) {
     throw new Error("HyperDB cannot initialize because this browser does not support the origin-private file system");
   }
 }
-function resolveBrowserWorkerUrl(workerUrl, engineUrl, wasmUrl, storagePath) {
-  const resolved = new URL(workerUrl);
-  resolved.searchParams.set("engineUrl", new URL(engineUrl).href);
-  if (wasmUrl != null) resolved.searchParams.set("wasmUrl", new URL(wasmUrl).href);
+function resolveBrowserWorkerUrl(workerUrl, engineUrl, wasmUrl, storagePath, baseUrl = globalThis.document?.baseURI ?? globalThis.location?.href ?? import.meta.url) {
+  const resolved = new URL(workerUrl, baseUrl);
+  resolved.searchParams.set("engineUrl", new URL(engineUrl, baseUrl).href);
+  if (wasmUrl != null) resolved.searchParams.set("wasmUrl", new URL(wasmUrl, baseUrl).href);
   if (storagePath != null) resolved.searchParams.set("storagePath", storagePath);
   return resolved;
 }
@@ -12236,8 +12236,7 @@ function expectOk(result, operation) {
   if (result.state !== "ok") throw readErrorFromResult(result, operation);
 }
 async function initializeHyperDB(client, settings) {
-  if (settings === void 0) return;
-  const serialized = JSON.stringify(settings);
+  const serialized = JSON.stringify(settings ?? {});
   if (serialized === void 0) throw new Error("HyperDB settings must be JSON-serializable");
   expectOk(await client.initialize(serialized), "initialize HyperDB settings");
 }
@@ -12502,6 +12501,8 @@ var HyperDBConnection = class {
     const result = (async () => {
       const reader = await RecordBatchReader.from(stream.result);
       if (!reader.isAsync() || !reader.isStream()) throw new Error("query did not produce an Arrow async stream");
+      await reader.open();
+      if (!reader.schema) throw new Error("query did not produce an Arrow schema");
       return reader;
     })();
     return queryResult(result, stream.info);

package/dist/browser_worker.js

@@ -12,9 +12,12 @@
     if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 0) throw new Error(`${name} must be a nonnegative safe integer`);
     return number;
   }
+  function validateCStringContents(value, name) {
+    if (value.includes("\0")) throw new Error(`${name} must not contain NUL`);
+  }
   function validateCString(value, name) {
     if (!value) throw new Error(`${name} must not be empty`);
-    if (value.includes("\0")) throw new Error(`${name} must not contain NUL`);
+    validateCStringContents(value, name);
   }
   function resultError(result) {
     if (result.state === "error" || result.state === "busy") {
@@ -157,6 +160,7 @@
       switch (request.type) {
         case "initialize":
           validateCString(request.settings, "settings");
+          validateCStringContents(this.module.hyperdbWasmStoragePath ?? "", "storage path");
           return this.initialize(request.settings, this.module.hyperdbWasmStoragePath ?? "");
         case "connect":
           return this.connect();
@@ -170,9 +174,13 @@
           validateCString(request.path, "external registration path");
           return this.removeExternalRegistration(request.path);
         case "startQuery":
+          validateCStringContents(request.sql, "SQL");
           return this.startQuery(request.connection, request.sql, Number(request.sqlTestMode ?? false));
         case "insertArrowIPCFromPath": {
           const path = request.internal || request.path.startsWith("/mnt/external/") ? request.path : this.module.resolveHyperDBPath?.(request.path) ?? request.path;
+          validateCString(path, "Arrow IPC input path");
+          validateCString(request.name, "Arrow insert table name");
+          validateCStringContents(request.schema ?? "", "Arrow insert schema name");
           return this.insertArrowIPCFromPath(request.connection, path, request.name, request.schema ?? "", Number(request.create));
         }
         case "pollQuery":
@@ -227,9 +235,11 @@
       if (!backend) {
         return { response: { id: request.id, type: "response", result: { state: "error", error: "External directories are not supported by this client" } }, transfer: [] };
       }
+      validateCString(request.path, "external registration path");
       const registration = backend.register(source, request.mode);
       let preserveBackend = false;
       try {
+        validateCString(registration.locator, "external directory locator");
         const pointer = safeInteger(this.registerExternalDirectory(request.path, registration.locator, Number(request.mode === "readwrite")), "result pointer");
         const result = this.decodeResult(pointer);
         if (result.state === "ok") {
@@ -385,6 +395,11 @@
     );
   }
   function installHttpRuntime(module, transport) {
+    const fetches = /* @__PURE__ */ new Map();
+    const completeFetch = (id, pointer, length) => {
+      if (!fetches.delete(id)) return;
+      module._hyperdb_wasm_fetch_complete(id, pointer, length);
+    };
     module.hyperdbWasmFetchStart = (id, url, offset, length, expectedSize) => {
       if (url.startsWith("hyperdb-node-file:") || url.startsWith("hyperdb-node-host-file:") || url.startsWith("hyperdb-node-directory-file:") || url.startsWith("hyperdb-browser-file:")) {
         const read = module.externalFileBackend?.read(url, offset, length, expectedSize) ?? module.externalDirectoryBackend?.read(url, offset, length, expectedSize);
@@ -401,63 +416,39 @@
       }
       const headers = new Headers();
       if (length > 0) headers.set("Range", `bytes=${offset}-${offset + length - 1}`);
-      void fetch(url, { headers, redirect: "manual" }).then(async (response) => {
+      const controller = new AbortController();
+      fetches.set(id, controller);
+      void fetch(url, { headers, redirect: "manual", signal: controller.signal }).then(async (response) => {
         if (!response.ok || response.type === "opaqueredirect" || (length === 0 ? response.status !== 200 : response.status !== 206)) {
           void response.body?.cancel().catch(() => void 0);
-          module._hyperdb_wasm_fetch_complete(id, 0, -1);
+          completeFetch(id, 0, -1);
           return;
         }
         if (length > 0) {
           const contentRange = /^bytes (\d+)-(\d+)\/(\d+)$/.exec(response.headers.get("content-range") ?? "");
           if (!contentRange || contentRange[1] !== String(offset) || contentRange[2] !== String(offset + length - 1) || expectedSize >= 0 && contentRange[3] !== String(expectedSize)) {
             void response.body?.cancel().catch(() => void 0);
-            module._hyperdb_wasm_fetch_complete(id, 0, -1);
+            completeFetch(id, 0, -1);
             return;
           }
         }
         const bytes = new Uint8Array(await response.arrayBuffer());
         if (length > 0 && bytes.byteLength !== length) {
-          module._hyperdb_wasm_fetch_complete(id, 0, -1);
+          completeFetch(id, 0, -1);
           return;
         }
         try {
-          module._hyperdb_wasm_fetch_complete(id, allocate(module, bytes), bytes.byteLength);
+          completeFetch(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);
+          completeFetch(id, 0, -1);
         }
       }).catch(() => {
         transport.postMessage({ type: "log", text: "fetch failed" });
-        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);
+        completeFetch(id, 0, -1);
       });
     };
+    module.hyperdbWasmFetchCancel = (id) => fetches.get(id)?.abort();
   }
   function installExternalDirectoryRuntime(module) {
     const backend = module.externalDirectoryBackend;
@@ -949,8 +940,7 @@
   }
   var storagePath = normalizeStoragePath(configuredStoragePath);
   function isPthreadWorker() {
-    const location = self.location;
-    return self.name === "em-pthread" || location.search?.includes("pthread") === true;
+    return self.name === "em-pthread";
   }
   if (isPthreadWorker()) {
     self.importScripts(resolvedEngineUrl.href);
@@ -998,7 +988,7 @@
       runtime.hyperdbWasmStoragePath = storagePath;
       runtime.resolveHyperDBPath = (path) => {
         const relativePath = normalizeStoragePath(path);
-        return `${storagePath ? `/mnt/fs/${storagePath}` : "/mnt/fs"}/${relativePath}`;
+        return `/mnt/fs/${relativePath}`;
       };
     });
     self.importScripts(resolvedEngineUrl.href);