@workglow/util 0.0.89 → 0.0.91

package/dist/node.js

@@ -122,7 +122,7 @@ class EventEmitter {
     return this;
   }
   waitOn(event) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
       const listener = (...args) => {
         resolve(args);
       };
@@ -132,7 +132,7 @@ class EventEmitter {
   emit(event, ...args) {
     const listeners = this.listeners[event];
     if (listeners) {
-      listeners.forEach(({ listener, once }) => {
+      listeners.forEach(({ listener }) => {
         listener(...args);
       });
       this.listeners[event] = listeners.filter((l) => !l.once);
@@ -1444,6 +1444,34 @@ var TensorSchema = (annotations = {}) => ({
   additionalProperties: false,
   ...annotations
 });
+// src/vector/TypedArrayUtils.ts
+var WIDTH_RANK = {
+  Float64Array: 6,
+  Float32Array: 5,
+  Float16Array: 4,
+  Int16Array: 3,
+  Uint16Array: 3,
+  Int8Array: 2,
+  Uint8Array: 2
+};
+function getWidthRank(arr) {
+  return WIDTH_RANK[arr.constructor.name] ?? 0;
+}
+function widestConstructor(sources) {
+  let best = sources[0];
+  for (let i = 1;i < sources.length; i++) {
+    if (getWidthRank(sources[i]) > getWidthRank(best))
+      best = sources[i];
+  }
+  return best.constructor;
+}
+function createTypedArrayFrom(sources, values) {
+  const Ctor = widestConstructor(sources);
+  const result = new Ctor(values.length);
+  for (let i = 0;i < values.length; i++)
+    result[i] = values[i];
+  return result;
+}
 // src/vector/VectorSimilarityUtils.ts
 function cosineSimilarity(a, b) {
   if (a.length !== b.length) {
@@ -1655,6 +1683,80 @@ class WorkerManager {
       worker.postMessage(message, transferables);
     });
   }
+  async* callWorkerStreamFunction(workerName, functionName, args, options) {
+    const worker = this.workers.get(workerName);
+    if (!worker)
+      throw new Error(`Worker ${workerName} not found.`);
+    await this.readyWorkers.get(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();
+      }
+    };
+    const handleAbort = () => {
+      worker.postMessage({ id: requestId, type: "abort" });
+    };
+    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 });
+    }
+    const message = { id: requestId, type: "call", functionName, args, stream: true };
+    const transferables = extractTransferables(message);
+    worker.postMessage(message, transferables);
+    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;
+        });
+      }
+    } finally {
+      if (!completedNormally) {
+        worker.postMessage({ id: requestId, type: "abort" });
+      }
+      cleanup();
+    }
+  }
 }
 var WORKER_MANAGER = createServiceToken("worker.manager");
 globalServiceRegistry.register(WORKER_MANAGER, () => new WorkerManager, true);
@@ -1705,6 +1807,7 @@ class WorkerServer {
     });
   }
   functions = {};
+  streamFunctions = {};
   requestControllers = new Map;
   completedRequests = new Set;
   postResult = (id, result) => {
@@ -1722,15 +1825,27 @@ class WorkerServer {
     this.completedRequests.add(id);
     postMessage({ id, type: "error", data: errorMessage });
   };
+  postStreamChunk = (id, event) => {
+    if (this.completedRequests.has(id)) {
+      return;
+    }
+    postMessage({ id, type: "stream_chunk", data: event });
+  };
   registerFunction(name, fn) {
     this.functions[name] = fn;
   }
+  registerStreamFunction(name, fn) {
+    this.streamFunctions[name] = fn;
+  }
   async handleMessage(event) {
-    const { id, type, functionName, args } = event.data;
+    const { id, type, functionName, args, stream } = event.data;
     if (type === "abort") {
       return await this.handleAbort(id);
     }
     if (type === "call") {
+      if (stream) {
+        return await this.handleStreamCall(id, functionName, args);
+      }
       return await this.handleCall(id, functionName, args);
     }
   }
@@ -1767,6 +1882,48 @@ class WorkerServer {
       }, 1000);
     }
   }
+  async handleStreamCall(id, functionName, [input, model]) {
+    if (functionName in this.streamFunctions) {
+      try {
+        const abortController = new AbortController;
+        this.requestControllers.set(id, abortController);
+        const fn = this.streamFunctions[functionName];
+        const iterable = fn(input, model, abortController.signal);
+        for await (const event of iterable) {
+          if (this.completedRequests.has(id))
+            break;
+          this.postStreamChunk(id, event);
+        }
+        this.postResult(id, undefined);
+      } catch (error) {
+        this.postError(id, error.message);
+      } finally {
+        this.requestControllers.delete(id);
+        setTimeout(() => {
+          this.completedRequests.delete(id);
+        }, 1000);
+      }
+    } else if (functionName in this.functions) {
+      try {
+        const abortController = new AbortController;
+        this.requestControllers.set(id, abortController);
+        const fn = this.functions[functionName];
+        const noopProgress = () => {};
+        const result = await fn(input, model, noopProgress, abortController.signal);
+        this.postStreamChunk(id, { type: "finish", data: result });
+        this.postResult(id, undefined);
+      } catch (error) {
+        this.postError(id, error.message);
+      } finally {
+        this.requestControllers.delete(id);
+        setTimeout(() => {
+          this.completedRequests.delete(id);
+        }, 1000);
+      }
+    } else {
+      this.postError(id, `Function ${functionName} not found`);
+    }
+  }
 }
 var WORKER_SERVER = createServiceToken("worker.server");
 globalServiceRegistry.register(WORKER_SERVER, () => new WorkerServer, true);
@@ -1897,6 +2054,7 @@ export {
   forceArray,
   deepEqual,
   decompress,
+  createTypedArrayFrom,
   createServiceToken,
   cosineSimilarity,
   convertImageDataToUseableForm,
@@ -1927,4 +2085,4 @@ export {
   BaseError
 };
 
-//# debugId=7EBB738750BDF34E64756E2164756E21
+//# debugId=7EB96C55559F4FB464756E2164756E21