hyperdb-wasm 0.0.27361-dev.wasm.g7817abf3 → 0.0.27367-dev.wasm.g50457039

package/dist/browser.d.ts

@@ -14,6 +14,8 @@ export interface BrowserClientOptions {
     /** 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;

package/dist/browser.js

@@ -52,7 +52,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 +72,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 +87,7 @@ var init_client = __esm({
         ];
       }
       onSetupProgress;
+      onLog;
       transport;
       pending = /* @__PURE__ */ new Map();
       readyPromise;
@@ -167,6 +169,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;
@@ -249,7 +258,8 @@ function createBrowserClient(options = {}) {
   const engineUrl = options.engineUrl ?? new URL("./hyperdb-wasm.js", import.meta.url);
   return new HyperDBEngineClient(
     new BrowserWorker(new Worker(resolveBrowserWorkerUrl(workerUrl, engineUrl, options.wasmUrl, options.storagePath), { type: "classic" })),
-    options.onSetupProgress
+    options.onSetupProgress,
+    options.onLog
   );
 }
 var memory64Probe, threadsProbe, exceptionsProbe, tailCallsProbe, BrowserWorker;
@@ -755,12 +765,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 +819,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);
   }

package/dist/browser_worker.js

@@ -483,11 +483,11 @@
         try {
           completeFetch(id, allocate(module, bytes), bytes.byteLength);
         } catch (error) {
-          transport.postMessage({ type: "log", text: `fetch failed: ${errorText(error)}` });
+          transport.postMessage({ type: "log", stream: "stderr", text: `fetch failed: ${errorText(error)}` });
           completeFetch(id, 0, -1);
         }
       }).catch(() => {
-        transport.postMessage({ type: "log", text: "fetch failed" });
+        transport.postMessage({ type: "log", stream: "stderr", text: "fetch failed" });
         completeFetch(id, 0, -1);
       });
     };
@@ -498,7 +498,7 @@
     if (!backend) return;
     module.hyperdbWasmExternalDirectoryReleaseGeneration = (locator, generation) => {
       void Promise.resolve().then(() => backend.releaseGeneration(locator, generation)).catch(() => {
-        transport.postMessage({ type: "log", text: "External directory generation cleanup failed; mount removal will retry" });
+        transport.postMessage({ type: "log", stream: "stderr", text: "External directory generation cleanup failed; mount removal will retry" });
       });
     };
     const listComplete = module._hyperdb_wasm_external_directory_list_complete;
@@ -703,8 +703,8 @@
     transport.onMessage((message) => {
       if (isEngineRequest(message)) handle(message);
     });
-    module.print = (text) => transport.postMessage({ type: "log", text });
-    module.printErr = (text) => transport.postMessage({ type: "log", text });
+    module.print = (text) => transport.postMessage({ type: "log", stream: "stdout", text });
+    module.printErr = (text) => transport.postMessage({ type: "log", stream: "stderr", text });
     module.onRuntimeInitialized = () => {
       if (failed) return;
       try {

package/dist/client.d.ts

@@ -2,6 +2,7 @@ import type { ConnectionSettings, HyperDBSettings, MountAccessMode } from './api
 import type { MountSource, SetupProgress, WasmResult, WorkerTransport } from './protocol.js';
 export declare class HyperDBEngineClient {
     private readonly onSetupProgress?;
+    private readonly onLog?;
     private readonly transport;
     private readonly pending;
     private readonly readyPromise;
@@ -11,7 +12,7 @@ export declare class HyperDBEngineClient {
     private failed;
     private termination;
     private readonly unsubscribe;
-    constructor(transport: WorkerTransport, onSetupProgress?: ((progress: SetupProgress) => void) | undefined);
+    constructor(transport: WorkerTransport, onSetupProgress?: ((progress: SetupProgress) => void) | undefined, onLog?: ((stream: "stdout" | "stderr", text: string) => void) | undefined);
     ready(): Promise<void>;
     get failure(): Error | undefined;
     initialize(settings: HyperDBSettings): Promise<WasmResult>;

package/dist/node.d.ts

@@ -21,6 +21,8 @@ export interface NodeClientOptions {
     readonly engineUrl?: string;
     /** Host directory mounted as the durable root; callers must prevent concurrent database access from other engines */
     readonly storagePath?: string;
+    /** Receives engine output; omitted callbacks discard output, and callback exceptions are ignored */
+    readonly onLog?: (stream: 'stdout' | 'stderr', text: string) => void;
 }
 export declare function resolveNodeEnginePath(engineUrl: URL): string;
 export declare function createNodeClient(options?: NodeClientOptions): HyperDBEngineClient;

package/dist/node.js

@@ -52,7 +52,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 +72,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 +87,7 @@ var init_client = __esm({
         ];
       }
       onSetupProgress;
+      onLog;
       transport;
       pending = /* @__PURE__ */ new Map();
       readyPromise;
@@ -167,6 +169,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;
@@ -249,7 +258,8 @@ function createBrowserClient(options = {}) {
   const engineUrl = options.engineUrl ?? new URL("./hyperdb-wasm.js", import.meta.url);
   return new HyperDBEngineClient(
     new BrowserWorker(new Worker(resolveBrowserWorkerUrl(workerUrl, engineUrl, options.wasmUrl, options.storagePath), { type: "classic" })),
-    options.onSetupProgress
+    options.onSetupProgress,
+    options.onLog
   );
 }
 var memory64Probe, threadsProbe, exceptionsProbe, tailCallsProbe, BrowserWorker;
@@ -755,12 +765,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 +819,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);
   }
@@ -877,7 +894,12 @@ function resolveNodeEnginePath(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, storagePath: options.storagePath } })));
+  const worker = new NativeWorker(workerUrl, {
+    workerData: { engineUrl, storagePath: options.storagePath },
+    stdout: true
+  });
+  worker.stdout.resume();
+  return new HyperDBEngineClient(new NodeWorker(worker), void 0, options.onLog);
 }
 
 // src/index.node.ts

package/dist/node_worker.js

@@ -477,11 +477,11 @@ function installHttpRuntime(module2, transport2) {
       try {
         completeFetch(id, allocate(module2, bytes), bytes.byteLength);
       } catch (error) {
-        transport2.postMessage({ type: "log", text: `fetch failed: ${errorText(error)}` });
+        transport2.postMessage({ type: "log", stream: "stderr", text: `fetch failed: ${errorText(error)}` });
         completeFetch(id, 0, -1);
       }
     }).catch(() => {
-      transport2.postMessage({ type: "log", text: "fetch failed" });
+      transport2.postMessage({ type: "log", stream: "stderr", text: "fetch failed" });
       completeFetch(id, 0, -1);
     });
   };
@@ -492,7 +492,7 @@ function installExternalDirectoryRuntime(module2, transport2) {
   if (!backend) return;
   module2.hyperdbWasmExternalDirectoryReleaseGeneration = (locator, generation) => {
     void Promise.resolve().then(() => backend.releaseGeneration(locator, generation)).catch(() => {
-      transport2.postMessage({ type: "log", text: "External directory generation cleanup failed; mount removal will retry" });
+      transport2.postMessage({ type: "log", stream: "stderr", text: "External directory generation cleanup failed; mount removal will retry" });
     });
   };
   const listComplete = module2._hyperdb_wasm_external_directory_list_complete;
@@ -697,8 +697,8 @@ function configureWorker(module2, transport2, configureFilesystem = () => void 0
   transport2.onMessage((message) => {
     if (isEngineRequest(message)) handle(message);
   });
-  module2.print = (text) => transport2.postMessage({ type: "log", text });
-  module2.printErr = (text) => transport2.postMessage({ type: "log", text });
+  module2.print = (text) => transport2.postMessage({ type: "log", stream: "stdout", text });
+  module2.printErr = (text) => transport2.postMessage({ type: "log", stream: "stderr", text });
   module2.onRuntimeInitialized = () => {
     if (failed) return;
     try {
@@ -1107,6 +1107,17 @@ var enginePort = parentPort;
 var options = workerData;
 var engineUrl = options?.engineUrl ?? fileURLToPath(new URL("./hyperdb-wasm.cjs", import.meta.url));
 var storagePath = resolve2(options?.storagePath ?? process.cwd());
+var storageInfo;
+try {
+  storageInfo = statSync(storagePath);
+} catch (error) {
+  if (typeof error === "object" && error !== null && "code" in error) {
+    if (error.code === "ENOENT") throw new Error(`Node storagePath does not exist: ${storagePath}`, { cause: error });
+    if (error.code === "ENOTDIR") throw new Error(`Node storagePath is not a directory: ${storagePath}`, { cause: error });
+  }
+  throw new Error(`Cannot access Node storagePath: ${storagePath}`, { cause: error });
+}
+if (!storageInfo.isDirectory()) throw new Error(`Node storagePath is not a directory: ${storagePath}`);
 var transport = {
   postMessage: (message, transfer = []) => enginePort.postMessage(message, [...transfer]),
   onMessage: (listener) => enginePort.on("message", listener)
@@ -1117,6 +1128,9 @@ var compiledWasm = await WebAssembly.compileStreaming(new Response(decompressedW
   headers: { "Content-Type": "application/wasm" }
 }));
 var moduleConfiguration = {
+  // Emscripten captures these callbacks while loading; its Node fallback writes directly to host fds
+  print: (text) => transport.postMessage({ type: "log", stream: "stdout", text }),
+  printErr: (text) => transport.postMessage({ type: "log", stream: "stderr", text }),
   instantiateWasm: (imports, receiveInstance) => {
     void WebAssembly.instantiate(compiledWasm, imports).then((instance) => receiveInstance(instance, compiledWasm));
     return {};

package/dist/protocol.d.ts

@@ -101,6 +101,7 @@ export type WorkerEvent = {
     error: string;
 } | {
     type: 'log';
+    stream: 'stdout' | 'stderr';
     text: string;
 } | WasmResponse;
 export interface WorkerTransport {

package/dist/raw.browser.js

@@ -37,7 +37,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:
@@ -47,8 +47,9 @@ function isWorkerEvent(message) {
 
 // src/client.ts
 var 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;
@@ -61,6 +62,7 @@ var HyperDBEngineClient = class {
     ];
   }
   onSetupProgress;
+  onLog;
   transport;
   pending = /* @__PURE__ */ new Map();
   readyPromise;
@@ -142,6 +144,13 @@ var HyperDBEngineClient = class {
       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;
@@ -568,7 +577,8 @@ function createBrowserClient(options = {}) {
   const engineUrl = options.engineUrl ?? new URL("./hyperdb-wasm.js", import.meta.url);
   return new HyperDBEngineClient(
     new BrowserWorker(new Worker(resolveBrowserWorkerUrl(workerUrl, engineUrl, options.wasmUrl, options.storagePath), { type: "classic" })),
-    options.onSetupProgress
+    options.onSetupProgress,
+    options.onLog
   );
 }
 export {

package/dist/raw.node.js

@@ -37,7 +37,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:
@@ -47,8 +47,9 @@ function isWorkerEvent(message) {
 
 // src/client.ts
 var 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;
@@ -61,6 +62,7 @@ var HyperDBEngineClient = class {
     ];
   }
   onSetupProgress;
+  onLog;
   transport;
   pending = /* @__PURE__ */ new Map();
   readyPromise;
@@ -142,6 +144,13 @@ var HyperDBEngineClient = class {
       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;
@@ -526,7 +535,12 @@ function resolveNodeEnginePath(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, storagePath: options.storagePath } })));
+  const worker = new NativeWorker(workerUrl, {
+    workerData: { engineUrl, storagePath: options.storagePath },
+    stdout: true
+  });
+  worker.stdout.resume();
+  return new HyperDBEngineClient(new NodeWorker(worker), void 0, options.onLog);
 }
 export {
   HyperDBBindings,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hyperdb-wasm",
-    "version": "0.0.27361-dev.wasm.g7817abf3",
+    "version": "0.0.27367-dev.wasm.g50457039",
     "type": "module",
     "engines": {
         "node": ">=24"