@workglow/util 0.2.5 → 0.2.7

package/dist/browser.js

@@ -844,22 +844,28 @@ class WorkerManager {
   workerFunctions = new Map;
   workerStreamFunctions = new Map;
   workerReactiveFunctions = new Map;
-  lazyFactories = new Map;
+  workerFactories = new Map;
+  idleTimeouts = new Map;
   lazyInitPromises = new Map;
-  registerWorker(name, workerOrFactory) {
+  activeCallCounts = new Map;
+  idleTimers = new Map;
+  terminationPromises = new Map;
+  registerWorker(name, workerOrFactory, options) {
     if (this.workers.has(name)) {
       throw new Error(`Worker ${name} is already registered.`);
     }
-    if (this.lazyFactories.has(name)) {
+    if (this.workerFactories.has(name)) {
       throw new Error(`Worker ${name} is already registered.`);
     }
+    this.idleTimeouts.set(name, options?.idleTimeoutMs ?? 0);
     if (typeof workerOrFactory === "function") {
-      this.lazyFactories.set(name, workerOrFactory);
+      this.workerFactories.set(name, workerOrFactory);
     } else {
       this.attachWorkerInstance(name, workerOrFactory);
     }
   }
   attachWorkerInstance(name, worker) {
+    this.clearIdleTimer(name);
     this.workers.set(name, worker);
     worker.addEventListener("error", (event) => {
       console.error("Worker Error:", event.message, "at", event.filename, "line:", event.lineno);
@@ -896,23 +902,27 @@ class WorkerManager {
     this.readyWorkers.set(name, readyPromise);
   }
   async ensureWorkerReady(name) {
+    await this.terminationPromises.get(name);
     if (this.workers.has(name)) {
       await this.readyWorkers.get(name);
       return;
     }
-    const factory = this.lazyFactories.get(name);
+    const factory = this.workerFactories.get(name);
     if (!factory) {
       throw new Error(`Worker ${name} not found.`);
     }
     let init = this.lazyInitPromises.get(name);
     if (!init) {
       init = (async () => {
+        let worker;
         try {
-          const f = this.lazyFactories.get(name);
-          this.lazyFactories.delete(name);
-          const worker = f();
+          const f = this.workerFactories.get(name);
+          worker = f();
           this.attachWorkerInstance(name, worker);
           await this.readyWorkers.get(name);
+        } catch (error) {
+          await this.cleanupFailedInitialization(name, worker);
+          throw error;
         } finally {
           this.lazyInitPromises.delete(name);
         }
@@ -927,105 +937,187 @@ class WorkerManager {
       throw new Error(`Worker ${name} not found.`);
     return worker;
   }
+  beginWorkerActivity(name) {
+    this.clearIdleTimer(name);
+    this.activeCallCounts.set(name, (this.activeCallCounts.get(name) ?? 0) + 1);
+  }
+  endWorkerActivity(name) {
+    const nextCount = (this.activeCallCounts.get(name) ?? 0) - 1;
+    if (nextCount > 0) {
+      this.activeCallCounts.set(name, nextCount);
+      return;
+    }
+    this.activeCallCounts.delete(name);
+    this.scheduleIdleTermination(name);
+  }
+  clearIdleTimer(name) {
+    const timer = this.idleTimers.get(name);
+    if (timer !== undefined) {
+      clearTimeout(timer);
+      this.idleTimers.delete(name);
+    }
+  }
+  scheduleIdleTermination(name) {
+    this.clearIdleTimer(name);
+    const idleTimeoutMs = this.idleTimeouts.get(name) ?? 0;
+    if (idleTimeoutMs <= 0 || !this.workerFactories.has(name) || !this.workers.has(name)) {
+      return;
+    }
+    const timer = setTimeout(() => {
+      this.idleTimers.delete(name);
+      if ((this.activeCallCounts.get(name) ?? 0) > 0 || !this.workers.has(name)) {
+        return;
+      }
+      this.terminateWorkerInstance(name).catch((error) => {
+        getLogger().warn(`Worker ${name} idle termination failed.`, { error });
+      });
+    }, idleTimeoutMs);
+    this.idleTimers.set(name, timer);
+  }
+  async cleanupFailedInitialization(name, worker) {
+    this.clearIdleTimer(name);
+    if (worker !== undefined && this.workers.get(name) === worker) {
+      this.workers.delete(name);
+    }
+    this.readyWorkers.delete(name);
+    this.workerFunctions.delete(name);
+    this.workerStreamFunctions.delete(name);
+    this.workerReactiveFunctions.delete(name);
+    this.activeCallCounts.delete(name);
+    if (worker && "terminate" in worker && typeof worker.terminate === "function") {
+      try {
+        await worker.terminate();
+      } catch {}
+    }
+  }
+  async terminateWorkerInstance(name) {
+    const existing = this.terminationPromises.get(name);
+    if (existing) {
+      await existing;
+      return;
+    }
+    const termination = (async () => {
+      this.clearIdleTimer(name);
+      const worker = this.workers.get(name);
+      this.workers.delete(name);
+      this.readyWorkers.delete(name);
+      this.workerFunctions.delete(name);
+      this.workerStreamFunctions.delete(name);
+      this.workerReactiveFunctions.delete(name);
+      this.activeCallCounts.delete(name);
+      try {
+        if (worker && "terminate" in worker && typeof worker.terminate === "function") {
+          await worker.terminate();
+        }
+      } catch {}
+    })();
+    this.terminationPromises.set(name, termination);
+    try {
+      await termination;
+    } finally {
+      this.terminationPromises.delete(name);
+    }
+  }
   async callWorkerFunction(workerName, functionName, args, options) {
     await this.ensureWorkerReady(workerName);
     const worker = this.workers.get(workerName);
     if (!worker)
       throw new Error(`Worker ${workerName} not found.`);
-    const knownFunctions = this.workerFunctions.get(workerName);
-    if (knownFunctions && !knownFunctions.has(functionName)) {
-      throw new Error(`Function "${functionName}" is not registered on worker "${workerName}".`);
-    }
-    return new Promise((resolve, reject) => {
-      const requestId = crypto.randomUUID();
-      const handleMessage = (event) => {
-        const { id, type, data } = event.data;
-        if (id !== requestId)
-          return;
-        if (type === "progress" && options?.onProgress) {
-          options.onProgress(data.progress, data.message, data.details);
-          getLogger().debug(`Worker ${workerName} function ${functionName} progress: ${data.progress}, `, { data });
-        } else if (type === "complete") {
-          cleanup();
-          getLogger().debug(`Worker ${workerName} function ${functionName} complete.`, { data });
-          resolve(data);
-        } else if (type === "error") {
-          cleanup();
-          getLogger().debug(`Worker ${workerName} function ${functionName} error.`, { data });
-          const err = typeof data === "object" && data !== null ? Object.assign(new Error(data.message ?? String(data)), {
-            name: data.name ?? "Error"
-          }) : new Error(String(data));
-          reject(err);
-        }
-      };
-      const handleAbort = () => {
-        worker.postMessage({ id: requestId, type: "abort" });
-        getLogger().info(`Worker ${workerName} function ${functionName} aborted.`);
-      };
-      const cleanup = () => {
-        worker.removeEventListener("message", handleMessage);
-        options?.signal?.removeEventListener("abort", handleAbort);
-      };
-      worker.addEventListener("message", handleMessage);
-      if (options?.signal) {
-        options.signal.addEventListener("abort", handleAbort, { once: true });
+    this.beginWorkerActivity(workerName);
+    try {
+      const knownFunctions = this.workerFunctions.get(workerName);
+      if (knownFunctions && !knownFunctions.has(functionName)) {
+        throw new Error(`Function "${functionName}" is not registered on worker "${workerName}".`);
       }
-      const message = { id: requestId, type: "call", functionName, args };
-      worker.postMessage(message);
-      getLogger().info(`Worker ${workerName} function ${functionName} called.`);
-    });
+      return await new Promise((resolve, reject) => {
+        const requestId = crypto.randomUUID();
+        const handleMessage = (event) => {
+          const { id, type, data } = event.data;
+          if (id !== requestId)
+            return;
+          if (type === "progress" && options?.onProgress) {
+            options.onProgress(data.progress, data.message, data.details);
+            getLogger().debug(`Worker ${workerName} function ${functionName} progress: ${data.progress}, `, { data });
+          } else if (type === "complete") {
+            cleanup();
+            getLogger().debug(`Worker ${workerName} function ${functionName} complete.`, { data });
+            resolve(data);
+          } else if (type === "error") {
+            cleanup();
+            getLogger().debug(`Worker ${workerName} function ${functionName} error.`, { data });
+            const err = typeof data === "object" && data !== null ? Object.assign(new Error(data.message ?? String(data)), {
+              name: data.name ?? "Error"
+            }) : new Error(String(data));
+            reject(err);
+          }
+        };
+        const handleAbort = () => {
+          worker.postMessage({ id: requestId, type: "abort" });
+          getLogger().info(`Worker ${workerName} function ${functionName} aborted.`);
+        };
+        const cleanup = () => {
+          worker.removeEventListener("message", handleMessage);
+          options?.signal?.removeEventListener("abort", handleAbort);
+        };
+        worker.addEventListener("message", handleMessage);
+        if (options?.signal) {
+          options.signal.addEventListener("abort", handleAbort, { once: true });
+        }
+        const message = { id: requestId, type: "call", functionName, args };
+        worker.postMessage(message);
+        getLogger().info(`Worker ${workerName} function ${functionName} called.`);
+      });
+    } finally {
+      this.endWorkerActivity(workerName);
+    }
   }
   async callWorkerReactiveFunction(workerName, functionName, args) {
     await this.ensureWorkerReady(workerName);
     const worker = this.workers.get(workerName);
     if (!worker)
       return;
-    const knownReactive = this.workerReactiveFunctions.get(workerName);
-    if (knownReactive && !knownReactive.has(functionName))
-      return;
-    return new Promise((resolve) => {
-      const requestId = crypto.randomUUID();
-      const handleMessage = (event) => {
-        const { id, type, data } = event.data;
-        if (id !== requestId)
-          return;
-        if (type === "complete") {
-          cleanup();
-          resolve(data);
-        } else if (type === "error") {
-          cleanup();
-          getLogger().warn(`Worker ${workerName} reactive function ${functionName} error:`, {
-            error: data
-          });
-          resolve(undefined);
-        }
-      };
-      const cleanup = () => {
-        worker.removeEventListener("message", handleMessage);
-      };
-      worker.addEventListener("message", handleMessage);
-      const message = { id: requestId, type: "call", functionName, args, reactive: true };
-      worker.postMessage(message);
-      getLogger().info(`Worker ${workerName} reactive function ${functionName} called.`);
-    });
+    this.beginWorkerActivity(workerName);
+    try {
+      const knownReactive = this.workerReactiveFunctions.get(workerName);
+      if (knownReactive && !knownReactive.has(functionName))
+        return;
+      return await new Promise((resolve) => {
+        const requestId = crypto.randomUUID();
+        const handleMessage = (event) => {
+          const { id, type, data } = event.data;
+          if (id !== requestId)
+            return;
+          if (type === "complete") {
+            cleanup();
+            resolve(data);
+          } else if (type === "error") {
+            cleanup();
+            getLogger().warn(`Worker ${workerName} reactive function ${functionName} error:`, {
+              error: data
+            });
+            resolve(undefined);
+          }
+        };
+        const cleanup = () => {
+          worker.removeEventListener("message", handleMessage);
+        };
+        worker.addEventListener("message", handleMessage);
+        const message = { id: requestId, type: "call", functionName, args, reactive: true };
+        worker.postMessage(message);
+        getLogger().info(`Worker ${workerName} reactive function ${functionName} called.`);
+      });
+    } finally {
+      this.endWorkerActivity(workerName);
+    }
   }
   async terminateWorker(name) {
-    const worker = this.workers.get(name);
-    this.workers.delete(name);
-    this.readyWorkers.delete(name);
-    this.workerFunctions.delete(name);
-    this.workerStreamFunctions.delete(name);
-    this.workerReactiveFunctions.delete(name);
-    this.lazyFactories.delete(name);
+    await this.terminateWorkerInstance(name);
+    this.workerFactories.delete(name);
+    this.idleTimeouts.delete(name);
     this.lazyInitPromises.delete(name);
-    try {
-      if (worker && "terminate" in worker && typeof worker.terminate === "function") {
-        await worker.terminate();
-      }
-    } catch {}
   }
   async dispose() {
-    const names = [...this.workers.keys(), ...this.lazyFactories.keys()];
+    const names = [...new Set([...this.workers.keys(), ...this.workerFactories.keys()])];
     for (const name of names) {
       await this.terminateWorker(name);
     }
@@ -1038,80 +1130,85 @@ class WorkerManager {
     const worker = this.workers.get(workerName);
     if (!worker)
       throw new Error(`Worker ${workerName} not found.`);
-    const knownStream = this.workerStreamFunctions.get(workerName);
-    const knownFns = this.workerFunctions.get(workerName);
-    if (knownStream && knownFns && !knownStream.has(functionName) && !knownFns.has(functionName)) {
-      throw new Error(`Function "${functionName}" is not registered on worker "${workerName}".`);
-    }
-    const requestId = crypto.randomUUID();
-    const queue = [];
-    let waiting = null;
-    const notify = () => {
-      if (waiting) {
-        const resolve = waiting;
-        waiting = null;
-        resolve();
-      }
-    };
-    const handleMessage = (event) => {
-      const { id, type, data } = event.data;
-      if (id !== requestId)
-        return;
-      if (type === "stream_chunk") {
-        queue.push({ kind: "event", data });
-        notify();
-      } else if (type === "complete") {
-        queue.push({ kind: "done" });
-        notify();
-      } else if (type === "error") {
-        queue.push({ kind: "error", error: new Error(data) });
-        notify();
+    this.beginWorkerActivity(workerName);
+    try {
+      const knownStream = this.workerStreamFunctions.get(workerName);
+      const knownFns = this.workerFunctions.get(workerName);
+      if (knownStream && knownFns && !knownStream.has(functionName) && !knownFns.has(functionName)) {
+        throw new Error(`Function "${functionName}" is not registered on worker "${workerName}".`);
       }
-    };
-    const handleAbort = () => {
-      worker.postMessage({ id: requestId, type: "abort" });
-      getLogger().info(`Worker ${workerName} stream function ${functionName} aborted.`);
-    };
-    const cleanup = () => {
-      worker.removeEventListener("message", handleMessage);
-      options?.signal?.removeEventListener("abort", handleAbort);
-    };
-    worker.addEventListener("message", handleMessage);
-    if (options?.signal) {
-      if (options.signal.aborted) {
-        cleanup();
-        throw new Error("Operation aborted");
+      const requestId = crypto.randomUUID();
+      const queue = [];
+      let waiting = null;
+      const notify = () => {
+        if (waiting) {
+          const resolve = waiting;
+          waiting = null;
+          resolve();
+        }
+      };
+      const handleMessage = (event) => {
+        const { id, type, data } = event.data;
+        if (id !== requestId)
+          return;
+        if (type === "stream_chunk") {
+          queue.push({ kind: "event", data });
+          notify();
+        } else if (type === "complete") {
+          queue.push({ kind: "done" });
+          notify();
+        } else if (type === "error") {
+          queue.push({ kind: "error", error: new Error(data) });
+          notify();
+        }
+      };
+      const handleAbort = () => {
+        worker.postMessage({ id: requestId, type: "abort" });
+        getLogger().info(`Worker ${workerName} stream function ${functionName} aborted.`);
+      };
+      const cleanup = () => {
+        worker.removeEventListener("message", handleMessage);
+        options?.signal?.removeEventListener("abort", handleAbort);
+      };
+      worker.addEventListener("message", handleMessage);
+      if (options?.signal) {
+        if (options.signal.aborted) {
+          cleanup();
+          throw new Error("Operation aborted");
+        }
+        options.signal.addEventListener("abort", handleAbort, { once: true });
       }
-      options.signal.addEventListener("abort", handleAbort, { once: true });
-    }
-    const message = { id: requestId, type: "call", functionName, args, stream: true };
-    worker.postMessage(message);
-    getLogger().info(`Worker ${workerName} stream function ${functionName} called.`);
-    let completedNormally = false;
-    try {
-      while (true) {
-        while (queue.length > 0) {
-          const item = queue.shift();
-          if (item.kind === "event") {
-            yield item.data;
-          } else if (item.kind === "done") {
-            completedNormally = true;
-            return;
-          } else if (item.kind === "error") {
-            completedNormally = true;
-            throw item.error;
+      const message = { id: requestId, type: "call", functionName, args, stream: true };
+      worker.postMessage(message);
+      getLogger().info(`Worker ${workerName} stream function ${functionName} called.`);
+      let completedNormally = false;
+      try {
+        while (true) {
+          while (queue.length > 0) {
+            const item = queue.shift();
+            if (item.kind === "event") {
+              yield item.data;
+            } else if (item.kind === "done") {
+              completedNormally = true;
+              return;
+            } else if (item.kind === "error") {
+              completedNormally = true;
+              throw item.error;
+            }
           }
+          await new Promise((resolve) => {
+            waiting = resolve;
+          });
         }
-        await new Promise((resolve) => {
-          waiting = resolve;
-        });
+      } finally {
+        if (!completedNormally) {
+          worker.postMessage({ id: requestId, type: "abort" });
+          getLogger().info(`Worker ${workerName} stream function ${functionName} aborted.`);
+        }
+        cleanup();
       }
     } finally {
-      if (!completedNormally) {
-        worker.postMessage({ id: requestId, type: "abort" });
-        getLogger().info(`Worker ${workerName} stream function ${functionName} aborted.`);
-      }
-      cleanup();
+      this.endWorkerActivity(workerName);
     }
   }
 }
@@ -1647,6 +1744,39 @@ function getTelemetryProvider() {
 function setTelemetryProvider(provider) {
   globalServiceRegistry.registerInstance(TELEMETRY_PROVIDER, provider);
 }
+// src/resource/ResourceScope.ts
+class ResourceScope {
+  disposers = new Map;
+  register(key, disposer) {
+    if (!this.disposers.has(key)) {
+      this.disposers.set(key, disposer);
+    }
+  }
+  async dispose(key) {
+    const disposer = this.disposers.get(key);
+    if (disposer) {
+      this.disposers.delete(key);
+      await disposer();
+    }
+  }
+  async disposeAll() {
+    const fns = [...this.disposers.values()];
+    this.disposers.clear();
+    await Promise.allSettled(fns.map((fn) => fn()));
+  }
+  has(key) {
+    return this.disposers.has(key);
+  }
+  keys() {
+    return this.disposers.keys();
+  }
+  get size() {
+    return this.disposers.size;
+  }
+  async[Symbol.asyncDispose]() {
+    await this.disposeAll();
+  }
+}
 // src/worker/WorkerServerBase.ts
 var WORKER_SERVER = createServiceToken("worker.server");
 function extractTransferables(obj) {
@@ -1907,6 +2037,7 @@ export {
   TELEMETRY_PROVIDER,
   SpanStatusCode,
   ServiceRegistry,
+  ResourceScope,
   OtpPassphraseCache,
   OTelTelemetryProvider,
   NullLogger,
@@ -1929,4 +2060,4 @@ export {
   BaseError
 };
 
-//# debugId=F3EE4A1B6E6F8E6A64756E2164756E21
+//# debugId=3A2CD1B45874D8F364756E2164756E21