hyperdb-wasm 0.0.27136-dev.wasm.gd997ff1c → 0.0.27136-dev.wasm.ged3c25a2

package/dist/raw.node.js

@@ -93,6 +93,9 @@ var HyperDBEngineClient = class {
   unmount(path) {
     return this.request({ id: this.nextId++, type: "unmount", path });
   }
+  refreshMount(path) {
+    return this.request({ id: this.nextId++, type: "refreshMount", path });
+  }
   pollQuery(query) {
     return this.request({ id: this.nextId++, type: "pollQuery", query });
   }
@@ -209,6 +212,7 @@ var HyperDBBindings = class {
   registerExternalFile;
   registerExternalDirectory;
   removeExternalRegistration;
+  refreshExternalDirectory;
   projectExternalFile;
   projectExternalDirectory;
   startQuery;
@@ -219,6 +223,7 @@ var HyperDBBindings = class {
   resultPayloadLength;
   free;
   mountedPaths = /* @__PURE__ */ new Set();
+  mountedDirectoryPaths = /* @__PURE__ */ new Set();
   constructor(module) {
     this.module = module;
     this.initialize = module.cwrap("hyperdb_wasm_initialize", "pointer", ["string", "string", "number"]);
@@ -228,6 +233,7 @@ var HyperDBBindings = class {
     this.registerExternalFile = module.cwrap("hyperdb_wasm_register_external_file", "pointer", ["string", "string", "number", "number"]);
     this.registerExternalDirectory = module.cwrap("hyperdb_wasm_register_external_directory", "pointer", ["string", "string", "number", "number"]);
     this.removeExternalRegistration = module.cwrap("hyperdb_wasm_remove_external_registration", "pointer", ["string", "number"]);
+    this.refreshExternalDirectory = module.cwrap("hyperdb_wasm_refresh_external_directory", "pointer", ["string", "number"]);
     this.projectExternalFile = module.cwrap("hyperdb_wasm_project_external_file", "pointer", ["string", "string", "number", "number"]);
     this.projectExternalDirectory = module.cwrap("hyperdb_wasm_project_external_directory", "pointer", ["string", "string", "number"]);
     this.startQuery = module.cwrap("hyperdb_wasm_query_start", "pointer", ["number", "string", "number", "number"]);
@@ -247,20 +253,32 @@ var HyperDBBindings = class {
       if (registration.kind === "directory") return this.mountDirectory(request, request.source.path);
       return this.mountFile(request, registration.locator, registration.size, this.module.externalFileBackend);
     }
-    if (request.type === "mount" && request.source.kind === "browser-file" && !this.module.externalFileBackendAvailable) {
-      return { response: { id: request.id, type: "response", result: { state: "error", error: "Blob external files are supported only by the browser client" } }, transfer: [] };
-    }
     if (request.type === "mount" && request.source.kind === "browser-directory") {
       return this.mountDirectory(request, request.source.handle);
     }
     if (request.type === "mount" && request.source.kind === "browser-file") {
-      return this.mountFile(request, request.source.url, safeInteger(request.source.size, "external file size"));
+      validateCString(request.path, "external registration path");
+      const backend = this.module.externalDirectoryBackend;
+      if (!backend?.registerFile) {
+        return { response: { id: request.id, type: "response", result: { state: "error", error: "Browser external files are supported only by the browser client" } }, transfer: [] };
+      }
+      const file = backend.registerFile(request.source.file);
+      return this.mountFile(request, file.locator, file.size, backend);
+    }
+    if (request.type === "refreshMount") {
+      validateCString(request.path, "external registration path");
+      if (!this.module.externalDirectoryBackend) return { response: { id: request.id, type: "response", result: { state: "error", error: "External directories are not supported by this client" } }, transfer: [] };
+      if (!this.mountedDirectoryPaths.has(request.path)) {
+        const error = this.mountedPaths.has(request.path) ? "Only directory mounts can be refreshed" : "External directory registration was not found";
+        return { response: { id: request.id, type: "response", result: { state: "error", error } }, transfer: [] };
+      }
     }
     if (request.type === "unmount" && (this.module.externalFileBackend || this.module.externalDirectoryBackend)) {
       validateCString(request.path, "external registration path");
       const pointer2 = safeInteger(this.removeExternalRegistration(request.path, request.id), "result pointer");
       const result2 = this.decodeResult(pointer2);
       if (result2.state === "ok" || result2.state === "error" && result2.error === "External registration was not found" && this.mountedPaths.has(request.path)) {
+        this.mountedDirectoryPaths.delete(request.path);
         const cleanup = async () => {
           await Promise.all([
             this.module.externalFileBackend?.removed(request.path),
@@ -272,12 +290,14 @@ var HyperDBBindings = class {
       }
       return { response: { id: request.id, type: "response", result: result2 }, transfer: [] };
     }
-    if (request.type === "unmount" && !this.module.externalFileBackendAvailable) {
+    if (request.type === "unmount") {
       return { response: { id: request.id, type: "response", result: { state: "error", error: "External files are not supported by this client" } }, transfer: [] };
     }
     const pointer = safeInteger(this.invoke(request), "result pointer");
     const result = this.decodeResult(pointer);
     if (request.type === "shutdown" && result.state === "ok") {
+      this.mountedPaths.clear();
+      this.mountedDirectoryPaths.clear();
       const completion = completionFor([
         this.module.externalFileBackend?.shutdown(),
         this.module.externalDirectoryBackend?.shutdown()
@@ -312,6 +332,8 @@ var HyperDBBindings = class {
       case "unmount":
         validateCString(request.path, "external registration path");
         return this.removeExternalRegistration(request.path, request.id);
+      case "refreshMount":
+        return this.refreshExternalDirectory(request.path, request.id);
       case "startQuery":
         validateCStringContents(request.sql, "SQL");
         return this.startQuery(request.connection, request.sql, Number(request.sqlTestMode ?? false), request.id);
@@ -332,13 +354,13 @@ var HyperDBBindings = class {
     try {
       const result = this.decodeResult(safeInteger(this.registerExternalFile(request.path, locator, size, request.id), "result pointer"));
       if (result.state !== "ok") {
-        backend?.removed(locator);
-        return { response: { id: request.id, type: "response", result }, transfer: [] };
+        const completion = completionFor([backend.removed(locator)]);
+        return { response: { id: request.id, type: "response", result }, transfer: [], ...completion && { completion } };
       }
       path = new TextDecoder("utf-8", { fatal: true }).decode(result.payload);
       const projection = this.decodeResult(safeInteger(this.projectExternalFile(path, locator, size, request.id), "result pointer"));
       if (projection.state !== "ok") throw new Error(resultError(projection));
-      backend?.registered(path, locator);
+      backend.registered(path, locator);
       registered = true;
       this.mountedPaths.add(path);
       return { response: { id: request.id, type: "response", result }, transfer: [] };
@@ -353,12 +375,15 @@ var HyperDBBindings = class {
       }
       if (rollbackError !== void 0) {
         if (path !== void 0) {
-          backend?.registered(path, locator);
+          backend.registered(path, locator);
           this.mountedPaths.add(path);
         }
         throw new Error(`mount failed and rollback also failed: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`, { cause: error });
       }
-      backend?.removed(registered && path !== void 0 ? path : locator);
+      const completion = completionFor([backend.removed(registered && path !== void 0 ? path : locator)]);
+      if (completion) {
+        return { response: { id: request.id, type: "response", result: { state: "error", error: error instanceof Error ? error.message : String(error) } }, transfer: [], completion };
+      }
       throw error;
     }
   }
@@ -382,12 +407,14 @@ var HyperDBBindings = class {
           if (projection.state !== "ok") throw new Error(resultError(projection));
           backend.registered(path, registration.locator);
           this.mountedPaths.add(path);
+          this.mountedDirectoryPaths.add(path);
         } catch (error) {
           const cleanupPointer = safeInteger(this.removeExternalRegistration(path, request.id), "result pointer");
           const cleanup = this.decodeResult(cleanupPointer);
           if (cleanup.state !== "ok") {
             backend.registered(path, registration.locator);
             this.mountedPaths.add(path);
+            this.mountedDirectoryPaths.add(path);
             preserveBackend = true;
             throw new Error(`mount failed and rollback also failed: ${resultError(cleanup)}`, { cause: error });
           }

package/dist/wasm_bindings.d.ts

@@ -22,25 +22,30 @@ export interface ExternalFileBackend {
     shutdown(): void;
 }
 export interface ExternalDirectoryBackend {
+    registerFile?(file: unknown): {
+        readonly locator: string;
+        readonly size: number;
+    };
     register(handle: unknown, mode: 'read' | 'readwrite'): {
         readonly name: string;
         readonly locator: string;
     };
     registered(path: string, locator: string): void;
+    releaseGeneration(locator: string, generation: string): void | Promise<void>;
     removed(path: string): void | Promise<void>;
     list(locator: string): Promise<readonly string[]>;
     listEntries?(locator: string, path: string): Promise<readonly {
         readonly name: string;
         readonly kind: 'file' | 'directory';
     }[]>;
-    lookup?(locator: string, path: string): Promise<{
+    lookup?(locator: string, path: string, generation: string): Promise<{
         readonly kind: 'directory';
     } | {
         readonly kind: 'file';
         readonly locator: string;
         readonly size: number;
     } | undefined>;
-    open(locator: string, path: string): Promise<{
+    open(locator: string, path: string, generation: string): Promise<{
         readonly locator: string;
         readonly size: number;
     }>;
@@ -60,7 +65,6 @@ export interface HyperDBWasmModule {
         mount(type: unknown, options: Record<string, unknown>, path: string): void;
     };
     hyperdbWasmStoragePath?: string;
-    externalFileBackendAvailable?: boolean;
     externalFileBackend?: ExternalFileBackend;
     externalDirectoryBackend?: ExternalDirectoryBackend;
     _malloc(size: number): number | bigint;
@@ -80,6 +84,7 @@ export declare class HyperDBBindings {
     private readonly registerExternalFile;
     private readonly registerExternalDirectory;
     private readonly removeExternalRegistration;
+    private readonly refreshExternalDirectory;
     private readonly projectExternalFile;
     private readonly projectExternalDirectory;
     private readonly startQuery;
@@ -90,6 +95,7 @@ export declare class HyperDBBindings {
     private readonly resultPayloadLength;
     private readonly free;
     private readonly mountedPaths;
+    private readonly mountedDirectoryPaths;
     constructor(module: HyperDBWasmModule);
     handle(request: EngineRequest): BindingResponse;
     private invoke;

package/dist/worker_setup.d.ts

@@ -35,13 +35,14 @@ export interface HyperDBWasmRuntimeModule extends HyperDBWasmModule {
     hyperdbWasmHostFileClose?: (id: number) => void;
     hyperdbWasmHostDirectoryListStart?: (id: number, path: string) => void;
     hyperdbWasmExternalDirectoryListStart?: (id: number, locator: string) => void;
-    hyperdbWasmExternalDirectoryOpenStart?: (id: number, locator: string, path: string) => void;
+    hyperdbWasmExternalDirectoryOpenStart?: (id: number, locator: string, path: string, generation: string) => void;
+    hyperdbWasmExternalDirectoryReleaseGeneration?: (locator: string, generation: string) => void;
     hyperdbWasmExternalDirectoryCreateDirectoriesStart?: (id: number, locator: string, path: string) => void;
     hyperdbWasmExternalDirectoryWriterWriteStart?: (writer: number, id: number, locator: string, path: string, offset: number, pointer: number | bigint, length: number) => void;
     hyperdbWasmExternalDirectoryWriterFinishStart?: (writer: number, id: number, locator: string, path: string, size: number) => void;
     hyperdbWasmExternalDirectoryWriterAbortStart?: (writer: number, id: number) => void;
     hyperdbWasmFilesystemListStart?: (id: number, locator: string, path: string) => void;
-    hyperdbWasmFilesystemLookupStart?: (id: number, locator: string, path: string) => void;
+    hyperdbWasmFilesystemLookupStart?: (id: number, locator: string, path: string, generation: string) => void;
     hyperdbWasmFilesystemReadStart?: (id: number, locator: string, offset: number, length: number, expectedSize: number, pointer: number | bigint) => void;
     hyperdbWasmShouldOpenHostFile?: (path: string) => boolean;
     hyperdbWasmShouldListHostDirectory?: (path: string) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hyperdb-wasm",
-    "version": "0.0.27136-dev.wasm.gd997ff1c",
+    "version": "0.0.27136-dev.wasm.ged3c25a2",
     "type": "module",
     "engines": {
         "node": ">=24"