hyperdb-wasm 0.0.27136-dev.wasm.g077c0cd8 → 0.0.27136-dev.wasm.g5f4b267e

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;

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,24 @@ var EngineQueryOperation = class {
   }
 };
 var MountedResourceImpl = class {
-  constructor(path, unmount, cleanup) {
+  constructor(path, unmount, refreshMount, cleanup) {
     this.path = path;
     this.unmount = unmount;
+    this.refreshMount = refreshMount;
     this.cleanup = cleanup;
   }
   path;
   unmount;
+  refreshMount;
   cleanup;
   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) {
@@ -577,7 +587,14 @@ var HyperDB = class _HyperDB {
       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");
+        }),
+        cleanup
+      );
       this.mountedResources.add(resource);
       return resource;
     });

package/dist/browser_external_directory.d.ts

@@ -13,17 +13,19 @@ export declare class BrowserExternalDirectoryBackend implements ExternalDirector
         readonly locator: string;
     };
     registered(path: string, locator: string): void;
+    refresh(path: 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"]);
@@ -108,11 +111,22 @@
       if (request.type === "mount" && request.source.kind === "browser-file") {
         return this.mountFile(request, request.source.url, safeInteger(request.source.size, "external file size"));
       }
+      if (request.type === "refreshMount") {
+        validateCString(request.path, "external registration path");
+        const backend = this.module.externalDirectoryBackend;
+        if (!backend) 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: [] };
+        }
+        backend.refresh(request.path);
+      }
       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),
@@ -130,6 +144,8 @@
       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()
@@ -141,6 +157,7 @@
         };
       }
       const response = { id: request.id, type: "response", result };
+      if (request.type === "unmount" && result.state === "ok") this.mountedPaths.delete(request.path);
       return { response, transfer: result.state === "chunk" ? [result.payload.buffer] : [] };
     }
     invoke(request) {
@@ -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);
@@ -234,12 +253,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 });
             }
@@ -343,6 +364,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 +462,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 +482,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 +572,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;
@@ -582,22 +609,7 @@
   function configureWorker(module, transport, configureFilesystem = () => void 0) {
     const queuedRequests = [];
     let bindings;
-    let failed = false;
-    const fail = (error) => {
-      if (failed) return;
-      failed = true;
-      bindings = void 0;
-      queuedRequests.length = 0;
-      transport.postMessage({ type: "fatal", error });
-      module.PThread?.terminateAllThreads();
-    };
-    const handleError = (request, error) => {
-      if (failed) return;
-      if (error instanceof WebAssembly.RuntimeError) fail(`engine trapped: ${errorText(error)}`);
-      else transport.postMessage({ id: request.id, type: "response", result: { state: "error", error: errorText(error) } });
-    };
     const handle = (request) => {
-      if (failed) return;
       if (!bindings) {
         queuedRequests.push(request);
         return;
@@ -605,14 +617,15 @@
       try {
         const result = bindings.handle(request);
         const complete = () => {
-          if (failed) return;
           if (request.type === "shutdown" && result.response.result.state === "ok") module.PThread.terminateAllThreads();
           transport.postMessage(result.response, result.transfer);
         };
-        if (result.completion) void result.completion.then(complete).catch((error) => handleError(request, error));
+        if (result.completion) void result.completion.then(complete, (error) => {
+          transport.postMessage({ id: request.id, type: "response", result: { state: "error", error: errorText(error) } });
+        });
         else complete();
       } catch (error) {
-        handleError(request, error);
+        transport.postMessage({ id: request.id, type: "response", result: { state: "error", error: errorText(error) } });
       }
     };
     transport.onMessage((message) => {
@@ -621,21 +634,20 @@
     module.print = (text) => transport.postMessage({ type: "log", text });
     module.printErr = (text) => transport.postMessage({ type: "log", text });
     module.onRuntimeInitialized = () => {
-      if (failed) return;
       try {
         configureFilesystem(module);
         installHttpRuntime(module, transport);
         installHostFileRuntime(module);
-        installExternalDirectoryRuntime(module);
+        installExternalDirectoryRuntime(module, transport);
         installFilesystemProjectionRuntime(module);
         bindings = new HyperDBBindings(module);
         transport.postMessage({ type: "ready" });
         for (const request of queuedRequests.splice(0)) handle(request);
       } catch (error) {
-        fail(`engine initialization failed: ${errorText(error)}`);
+        transport.postMessage({ type: "fatal", error: `engine initialization failed: ${errorText(error)}` });
       }
     };
-    module.onAbort = (reason) => fail(`engine aborted: ${String(reason)}`);
+    module.onAbort = (reason) => transport.postMessage({ type: "fatal", error: `engine aborted: ${String(reason)}` });
   }
 
   // src/browser_external_directory.ts
@@ -679,13 +691,29 @@
       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");
       this.paths.set(path, locator);
     }
+    /// Clears future path lookups, retaining File locators until generation release
+    refresh(path) {
+      const locator = this.paths.get(path);
+      if (locator === void 0) throw new Error("External directory registration does not exist");
+      for (const generation of this.getDirectory(locator).generations.values()) generation.files.clear();
+    }
+    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);
@@ -724,7 +752,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));
@@ -734,14 +762,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 };
@@ -763,14 +796,15 @@
         const fileLocator = `${fileLocatorPrefix}${opaqueId()}`;
         this.files.set(fileLocator, 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;
       }
     }
@@ -862,7 +896,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));
     }
@@ -904,7 +938,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 {

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>;