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

package/dist/api.d.ts

@@ -12,6 +12,7 @@ export interface HyperDBClient {
     startQuery(connection: number, sql: string): Promise<WasmResult>;
     mount(source: MountSource, path: string, mode: MountAccessMode): Promise<WasmResult>;
     unmount(path: string): Promise<WasmResult>;
+    refreshMount(path: string): Promise<WasmResult>;
     pollQuery(query: number): Promise<WasmResult>;
     cancelQuery(query: number): Promise<WasmResult>;
     finishQuery(query: number): Promise<WasmResult>;
@@ -28,6 +29,7 @@ export interface MountOptions {
 }
 export interface MountedResource {
     readonly path: string;
+    refresh(): Promise<void>;
     close(): Promise<void>;
 }
 export declare function validateMountPath(path: unknown): asserts path is string;
@@ -97,7 +99,7 @@ export declare class HyperDB {
     static create(options?: BrowserCreateOptions): Promise<HyperDB>;
     ready(): Promise<void>;
     connect(options?: HyperDBConnectOptions): Promise<HyperDBConnection>;
-    protected mountSource(source: MountSource, path: string, mode: MountAccessMode, cleanup?: () => void): Promise<MountedResource>;
+    protected mountSource(source: MountSource, path: string, mode: MountAccessMode): Promise<MountedResource>;
     terminate(): Promise<void>;
     private ensureRunning;
     protected runDatabaseOperation<Result>(operation: () => Promise<Result>): Promise<Result>;

package/dist/browser.js

@@ -118,6 +118,9 @@ var init_client = __esm({
       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 });
       }
@@ -498,17 +501,21 @@ var EngineQueryOperation = class {
   }
 };
 var MountedResourceImpl = class {
-  constructor(path, unmount, cleanup) {
+  constructor(path, unmount, refreshMount) {
     this.path = path;
     this.unmount = unmount;
-    this.cleanup = cleanup;
+    this.refreshMount = refreshMount;
   }
   path;
   unmount;
-  cleanup;
+  refreshMount;
   closed = false;
   closing;
-  cleaned = false;
+  async refresh() {
+    if (this.closed) throw new Error("mounted resource is closed");
+    if (this.closing) throw new Error("mounted resource is closing");
+    await this.refreshMount(this.path);
+  }
   async close() {
     if (this.closed) return;
     if (!this.closing) {
@@ -519,19 +526,13 @@ var MountedResourceImpl = class {
           this.closing = void 0;
           throw error;
         }
-        this.release();
+        this.closed = true;
       })();
     }
     await this.closing;
   }
   releaseAfterShutdown() {
-    this.release();
-  }
-  release() {
     this.closed = true;
-    if (this.cleaned) return;
-    this.cleaned = true;
-    this.cleanup();
   }
 };
 var HyperDB = class _HyperDB {
@@ -571,13 +572,19 @@ var HyperDB = class _HyperDB {
     this.connections.add(result);
     return result;
   }
-  mountSource(source, path, mode, cleanup = () => void 0) {
+  mountSource(source, path, mode) {
     return this.runDatabaseOperation(async () => {
       const result = await this.client.mount(source, path, mode);
       expectOk(result, "mount");
       const mountedPath = new TextDecoder("utf-8", { fatal: true }).decode(result.payload);
       if (mountedPath !== path) throw new Error("mount returned an invalid path");
-      const resource = new MountedResourceImpl(mountedPath, (mounted) => this.unmount(mounted), cleanup);
+      const resource = new MountedResourceImpl(
+        mountedPath,
+        (mounted) => this.unmount(mounted),
+        (path2) => this.runDatabaseOperation(async () => {
+          expectOk(await this.client.refreshMount(path2), "refresh mount");
+        })
+      );
       this.mountedResources.add(resource);
       return resource;
     });
@@ -845,13 +852,7 @@ var HyperDB2 = class _HyperDB extends HyperDB {
         throw new Error("Mounted file name must be a basename without path separators");
       }
       if (!Number.isSafeInteger(source.size) || source.size < 0) throw new Error("Mounted file size must be a nonnegative safe integer");
-      const url = URL.createObjectURL(source);
-      try {
-        return await this.mountSource({ kind: "browser-file", name: source.name, url, size: source.size }, path, "read", () => URL.revokeObjectURL(url));
-      } catch (error) {
-        URL.revokeObjectURL(url);
-        throw error;
-      }
+      return this.mountSource({ kind: "browser-file", file: source }, path, "read");
     }
     const handle = source;
     const mode = options.mode ?? "read";

package/dist/browser_external_directory.d.ts

@@ -8,22 +8,27 @@ export declare class BrowserExternalDirectoryBackend implements ExternalDirector
     private readonly paths;
     private readonly files;
     private readonly writers;
+    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;
     removed(pathOrLocator: string): void;
     list(locator: string): Promise<readonly string[]>;
     listEntries(locator: string, path: string): Promise<readonly BrowserDirectoryEntry[]>;
-    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;
     }>;

package/dist/browser_worker.js

@@ -61,6 +61,7 @@
     registerExternalFile;
     registerExternalDirectory;
     removeExternalRegistration;
+    refreshExternalDirectory;
     projectExternalFile;
     projectExternalDirectory;
     startQuery;
@@ -71,6 +72,7 @@
     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"]);
@@ -80,6 +82,7 @@
       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"]);
@@ -99,20 +102,32 @@
         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),
@@ -124,12 +139,14 @@
         }
         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()
@@ -164,6 +181,8 @@
         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);
@@ -184,13 +203,13 @@
       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: [] };
@@ -205,12 +224,15 @@
         }
         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;
       }
     }
@@ -234,12 +256,14 @@
             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 });
             }
@@ -333,7 +357,7 @@
         if (!hasKeys(value, ["id", "type", "source", "path", "mode"]) || typeof value.path !== "string" || !value.path.startsWith("/mnt/external/") || new TextEncoder().encode(value.path.slice("/mnt/external/".length)).byteLength === 0 || new TextEncoder().encode(value.path.slice("/mnt/external/".length)).byteLength > 200 || value.path.slice("/mnt/external/".length).split("/").some((component) => !component || component === "." || component === ".." || !/^[A-Za-z0-9._-]+$/.test(component)) || value.mode !== "read" && value.mode !== "readwrite" || !isRecord(value.source)) return false;
         switch (value.source.kind) {
           case "browser-file":
-            return value.mode === "read" && hasKeys(value.source, ["kind", "name", "url", "size"]) && typeof value.source.name === "string" && typeof value.source.url === "string" && typeof value.source.size === "number" && Number.isSafeInteger(value.source.size) && value.source.size >= 0;
+            return value.mode === "read" && hasKeys(value.source, ["kind", "file"]) && typeof File !== "undefined" && value.source.file instanceof File;
           case "browser-directory":
             return hasKeys(value.source, ["kind", "handle"]) && isRecord(value.source.handle) && value.source.handle.kind === "directory";
           case "node-path":
@@ -343,6 +367,7 @@
         }
       }
       case "unmount":
+      case "refreshMount":
         return hasKeys(value, ["id", "type", "path"]) && typeof value.path === "string" && !!value.path && !value.path.includes("\0");
       case "pollQuery":
       case "cancelQuery":
@@ -440,9 +465,14 @@
     };
     module.hyperdbWasmFetchCancel = (id) => fetches.get(id)?.abort();
   }
-  function installExternalDirectoryRuntime(module) {
+  function installExternalDirectoryRuntime(module, transport) {
     const backend = module.externalDirectoryBackend;
     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" });
+      });
+    };
     const listComplete = module._hyperdb_wasm_external_directory_list_complete;
     const openComplete = module._hyperdb_wasm_external_directory_open_complete;
     if (listComplete) {
@@ -455,8 +485,8 @@
       };
     }
     if (openComplete) {
-      module.hyperdbWasmExternalDirectoryOpenStart = (id, locator, path) => {
-        void backend.open(locator, path).then((file) => {
+      module.hyperdbWasmExternalDirectoryOpenStart = (id, locator, path, generation) => {
+        void backend.open(locator, path, generation).then((file) => {
           openComplete(id, safePointer(module.stringToNewUTF8(file.locator), "external file locator pointer"), file.size);
         }).catch((error) => openComplete(id, 0, isNotFoundError(error) ? -2 : -1));
       };
@@ -545,8 +575,8 @@
         complete(id, safePointer(module.stringToNewUTF8(JSON.stringify(encoded)), "filesystem listing pointer"), 0);
       }).catch(() => complete(id, 0, -1));
     };
-    module.hyperdbWasmFilesystemLookupStart = (id, locator, path) => {
-      const lookup = module.externalDirectoryBackend?.lookup?.(locator, path);
+    module.hyperdbWasmFilesystemLookupStart = (id, locator, path, generation) => {
+      const lookup = module.externalDirectoryBackend?.lookup?.(locator, path, generation);
       if (!lookup) {
         complete(id, 0, -1);
         return;
@@ -558,13 +588,7 @@
       }).catch(() => complete(id, 0, -1));
     };
     module.hyperdbWasmFilesystemReadStart = (id, locator, offset, length, expectedSize, pointerValue) => {
-      const read = module.externalFileBackend?.read(locator, offset, length, expectedSize) ?? module.externalDirectoryBackend?.read(locator, offset, length, expectedSize) ?? (locator.startsWith("blob:") ? fetch(locator, { headers: { Range: `bytes=${offset}-${offset + length - 1}` } }).then(async (response) => {
-        const contentRange = /^bytes (\d+)-(\d+)\/(\d+)$/.exec(response.headers.get("content-range") ?? "");
-        if (response.status !== 206 || !contentRange || contentRange[1] !== String(offset) || contentRange[2] !== String(offset + length - 1) || contentRange[3] !== String(expectedSize)) {
-          throw new Error("Blob URL returned an invalid byte range");
-        }
-        return new Uint8Array(await response.arrayBuffer());
-      }) : void 0);
+      const read = module.externalFileBackend?.read(locator, offset, length, expectedSize) ?? module.externalDirectoryBackend?.read(locator, offset, length, expectedSize);
       if (!read) {
         complete(id, 0, -1);
         return;
@@ -611,7 +635,7 @@
         configureFilesystem(module);
         installHttpRuntime(module, transport);
         installHostFileRuntime(module);
-        installExternalDirectoryRuntime(module);
+        installExternalDirectoryRuntime(module, transport);
         installFilesystemProjectionRuntime(module);
         bindings = new HyperDBBindings(module);
         transport.postMessage({ type: "ready" });
@@ -660,27 +684,51 @@
     paths = /* @__PURE__ */ new Map();
     files = /* @__PURE__ */ new Map();
     writers = /* @__PURE__ */ new Map();
+    registerFile(file) {
+      if (typeof file !== "object" || file === null || !("size" in file) || typeof file.size !== "number" || !("slice" in file) || typeof file.slice !== "function") {
+        throw new Error("External file is invalid");
+      }
+      nonnegativeSafeInteger(file.size, "External file size");
+      const locator = `${fileLocatorPrefix}${opaqueId()}`;
+      this.files.set(locator, file);
+      return { locator, size: file.size };
+    }
     register(handle, mode) {
       const directoryHandle = asDirectoryHandle(handle);
       validateSegment(directoryHandle.name);
       const locator = `${directoryLocatorPrefix}${opaqueId()}`;
-      this.directories.set(locator, { handle: directoryHandle, mode, files: /* @__PURE__ */ new Map(), locators: /* @__PURE__ */ new Set() });
+      this.directories.set(locator, { handle: directoryHandle, mode, generations: /* @__PURE__ */ new Map(), locators: /* @__PURE__ */ new Set() });
       return { name: directoryHandle.name, locator };
     }
     registered(path, locator) {
-      if (!this.directories.has(locator)) throw new Error("External directory registration is unavailable");
+      if (!this.directories.has(locator) && !this.files.has(locator)) throw new Error("External registration is unavailable");
       this.paths.set(path, locator);
     }
+    releaseGeneration(locator, generation) {
+      const directory = this.directories.get(locator);
+      const state = directory?.generations.get(generation);
+      if (!directory || !state) return;
+      directory.generations.delete(generation);
+      for (const fileLocator of state.locators) {
+        this.files.delete(fileLocator);
+        directory.locators.delete(fileLocator);
+      }
+    }
     removed(pathOrLocator) {
       const locator = this.paths.get(pathOrLocator) ?? pathOrLocator;
       const directory = this.directories.get(locator);
-      if (!directory) return;
-      for (const fileLocator of directory.locators) this.files.delete(fileLocator);
-      for (const [writer, state] of this.writers) {
-        if (state.locator === locator) void this.abort(writer).catch(() => void 0);
+      if (directory) {
+        for (const fileLocator of directory.locators) this.files.delete(fileLocator);
+        for (const [writer, state] of this.writers) {
+          if (state.locator === locator) void this.abort(writer).catch(() => void 0);
+        }
+        this.directories.delete(locator);
+      } else {
+        this.files.delete(locator);
+      }
+      for (const [path, registeredLocator] of this.paths) {
+        if (registeredLocator === locator) this.paths.delete(path);
       }
-      this.directories.delete(locator);
-      this.paths.delete(pathOrLocator);
     }
     async list(locator) {
       const directory = this.getDirectory(locator);
@@ -709,7 +757,7 @@
       entries.sort((left, right) => left.name.localeCompare(right.name));
       return entries;
     }
-    async lookup(locator, path) {
+    async lookup(locator, path, generation) {
       const directory = this.getDirectory(locator);
       const segments = relativeSegments(path);
       const parent = await this.openDirectory(directory, segments.slice(0, -1));
@@ -719,14 +767,19 @@
         validateSegment(child.name);
         if (child.name !== name) continue;
         if (child.kind === "directory") return { kind: "directory" };
-        if (child.kind === "file") return { kind: "file", ...await this.open(locator, path) };
+        if (child.kind === "file") return { kind: "file", ...await this.open(locator, path, generation) };
         throw new Error("External directory contains an unsupported entry");
       }
       return void 0;
     }
-    async open(locator, path) {
+    async open(locator, path, generation) {
       const directory = this.getDirectory(locator);
-      const cached = directory.files.get(path);
+      let state = directory.generations.get(generation);
+      if (!state) {
+        state = { files: /* @__PURE__ */ new Map(), locators: /* @__PURE__ */ new Set() };
+        directory.generations.set(generation, state);
+      }
+      const cached = state.files.get(path);
       if (cached) {
         const file = await cached;
         return { locator: file.locator, size: file.file.size };
@@ -744,25 +797,24 @@
         const fileHandle = await parent.getFileHandle(name);
         if (fileHandle.kind !== "file" || fileHandle.name !== name) throw new Error("External directory returned an unexpected file handle");
         const file = await fileHandle.getFile();
-        if (!Number.isSafeInteger(file.size) || file.size < 0) throw new Error("External file size must be a nonnegative safe integer");
-        const fileLocator = `${fileLocatorPrefix}${opaqueId()}`;
-        this.files.set(fileLocator, file);
+        const { locator: fileLocator } = this.registerFile(file);
         directory.locators.add(fileLocator);
+        state.locators.add(fileLocator);
         return { locator: fileLocator, file };
       })();
-      directory.files.set(path, snapshot);
+      state.files.set(path, snapshot);
       try {
         const file = await snapshot;
         return { locator: file.locator, size: file.file.size };
       } catch (error) {
-        directory.files.delete(path);
+        if (state.files.get(path) === snapshot) state.files.delete(path);
         throw error;
       }
     }
     read(locator, offset, length, expectedSize) {
       if (!locator.startsWith(fileLocatorPrefix)) return void 0;
       const file = this.files.get(locator);
-      if (!file) return Promise.reject(new Error("External directory file registration does not exist"));
+      if (!file) return Promise.reject(new Error("External file registration does not exist"));
       const end = offset + length;
       if (expectedSize !== file.size || !Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(length) || length < 0 || !Number.isSafeInteger(end) || end > file.size) {
         return Promise.reject(new Error("External file byte range is invalid"));
@@ -847,7 +899,7 @@
           await this.cleanupWriter(state).catch(() => void 0);
           throw failure;
         }
-        this.getDirectory(state.locator).files.delete(state.path);
+        for (const generation of this.getDirectory(state.locator).generations.values()) generation.files.delete(state.path);
       }, true);
       return operation.finally(() => this.writers.delete(writer));
     }
@@ -889,7 +941,7 @@
       return state;
     }
     async cleanupWriter(state) {
-      this.directories.get(state.locator)?.files.delete(state.path);
+      for (const generation of this.directories.get(state.locator)?.generations.values() ?? []) generation.files.delete(state.path);
       try {
         await state.stream?.abort();
       } finally {
@@ -968,7 +1020,6 @@
     };
     self.Module = module;
     configureWorker(module, transport, (runtime) => {
-      runtime.externalFileBackendAvailable = true;
       runtime.externalDirectoryBackend = new BrowserExternalDirectoryBackend();
       if (!runtime.OPFS) throw new Error("OPFS backend is unavailable");
       runtime.FS.mkdirTree("/mnt/fs");

package/dist/client.d.ts

@@ -19,6 +19,7 @@ export declare class HyperDBEngineClient {
     startQuery(connection: number, sql: string, sqlTestMode?: boolean): Promise<WasmResult>;
     mount(source: MountSource, path: string, mode: MountAccessMode): Promise<WasmResult>;
     unmount(path: string): Promise<WasmResult>;
+    refreshMount(path: string): Promise<WasmResult>;
     pollQuery(query: number): Promise<WasmResult>;
     cancelQuery(query: number): Promise<WasmResult>;
     finishQuery(query: number): Promise<WasmResult>;