@cnstra/core 1.5.2 → 1.7.0

package/dist/index.cjs

@@ -106,7 +106,7 @@ var CNSFunctionalQueue = class {
             throw err;
           }
         );
-        break;
+        continue;
       }
       this.activeOperations--;
       if (typeof ret === "function") ret();
@@ -136,6 +136,11 @@ var CNSStimulation = class {
     this.cns = cns;
     this.options = options;
     this.scheduledCount = 0;
+    this.completed = new Promise((resolve, reject) => {
+      this.resolveCompleted = resolve;
+      this.rejectCompleted = reject;
+    });
+    this.isCompleted = false;
     /**
      * Track active SCCs: SCC index -> count of active neurons in that SCC
      */
@@ -151,6 +156,24 @@ var CNSStimulation = class {
     if (this.options?.maxNeuronHops) {
       this.nueronVisitMap = /* @__PURE__ */ new Map();
     }
+    if (this.options?.abortSignal) {
+      this.options.abortSignal.addEventListener("abort", () => {
+        this.tryResolveCompleted();
+      });
+    }
+  }
+  tryResolveCompleted() {
+    if (this.isCompleted) return;
+    const noActive = this.queue.getActiveOperationsCount() === 0;
+    const noPending = this.queue.length + this.scheduledCount === 0;
+    const aborted = !!this.options?.abortSignal?.aborted;
+    if (noPending && noActive || aborted && noActive) {
+      this.isCompleted = true;
+      this.resolveCompleted();
+    }
+  }
+  waitUntilComplete() {
+    return this.completed;
   }
   get concurrencyEnabled() {
     return this.options?.concurrency !== void 0 && this.options?.concurrency > 0;
@@ -224,15 +247,31 @@ var CNSStimulation = class {
         );
       }
     }
-    return {
+    const serialized = {
       neuronId: subscriber.neuron.name,
-      subscriber,
-      inputSignal
+      dendriteCollateralName: subscriber.dendrite.collateral.name,
+      input: inputSignal ? {
+        collateralName: inputSignal.collateralName,
+        payload: inputSignal.payload
+      } : void 0
     };
+    return serialized;
   }
   processQueueItem(item) {
-    const { subscriber, inputSignal } = item;
-    const { neuron: neuron2, dendrite } = subscriber;
+    const subscribers = this.cns.getSubscribers(
+      item.dendriteCollateralName
+    );
+    const subscriber = subscribers.find(
+      (s) => s.neuron.name === item.neuronId
+    );
+    if (!subscriber) return () => {
+    };
+    const neuron2 = subscriber.neuron;
+    const dendrite = subscriber.dendrite;
+    const inputSignal = item.input ? {
+      collateralName: item.input.collateralName,
+      payload: item.input.payload
+    } : void 0;
     const starter = () => {
       this.markNeuronActive(neuron2.name);
       const response = dendrite.response(
@@ -243,15 +282,38 @@ var CNSStimulation = class {
           set: (value) => this.ctx.set(neuron2.name, value),
           delete: () => this.ctx.delete(neuron2.name),
           abortSignal: this.options?.abortSignal,
-          cns: this.cns
+          cns: this.cns,
+          stimulationId: this.id
         }
       );
-      if (response instanceof Promise) {
-        return response.then(
+      const maxDuration = neuron2.maxDuration;
+      const asPromise = response instanceof Promise ? response : Promise.resolve(response);
+      const timedPromise = maxDuration && maxDuration > 0 ? new Promise((resolve, reject) => {
+        const t = setTimeout(() => {
+          const err = new Error(
+            `Neuron "${String(
+              neuron2.name
+            )}" exceeded maxDuration ${maxDuration}ms`
+          );
+          reject(err);
+        }, maxDuration);
+        asPromise.then(
+          (v) => {
+            clearTimeout(t);
+            resolve(v);
+          },
+          (e) => {
+            clearTimeout(t);
+            reject(e);
+          }
+        );
+      }) : asPromise;
+      if (response instanceof Promise || maxDuration) {
+        return timedPromise.then(
           (signal) => {
             return () => {
               this.markNeuronInactive(neuron2.name);
-              return this.processResponse(
+              return this.processResponseOrResponses(
                 inputSignal,
                 signal
               );
@@ -260,7 +322,7 @@ var CNSStimulation = class {
           (error) => {
             return () => {
               this.markNeuronInactive(neuron2.name);
-              return this.processResponse(
+              return this.processResponseOrResponses(
                 inputSignal,
                 void 0,
                 error
@@ -271,7 +333,7 @@ var CNSStimulation = class {
       } else {
         return () => {
           this.markNeuronInactive(neuron2.name);
-          return this.processResponse(
+          return this.processResponseOrResponses(
             inputSignal,
             response
           );
@@ -280,12 +342,25 @@ var CNSStimulation = class {
     };
     return this.instanceNeuronQueue.run(neuron2, starter);
   }
+  processResponseOrResponses(inputSignal, outputSignalOrSignals, error) {
+    if (Array.isArray(outputSignalOrSignals)) {
+      if (outputSignalOrSignals.length === 0) {
+        this.processResponse(inputSignal, void 0, error);
+        return;
+      }
+      for (const signal of outputSignalOrSignals) {
+        this.processResponse(inputSignal, signal, error);
+      }
+      return;
+    }
+    this.processResponse(inputSignal, outputSignalOrSignals, error);
+  }
   processResponse(inputSignal, outputSignal, error) {
-    const collateral2 = outputSignal?.collateral;
-    const ownerNeuron = collateral2 ? this.cns.getParentNeuronByCollateralName(collateral2.name) : void 0;
-    const subscribers = collateral2 ? this.cns.getSubscribers(collateral2.name) : [];
+    const collateralName = outputSignal?.collateralName;
+    const ownerNeuron = collateralName ? this.cns.getParentNeuronByCollateralName(collateralName) : void 0;
+    const subscribers = collateralName ? this.cns.getSubscribers(collateralName) : [];
     const subscriberQueueItems = [];
-    if (collateral2 && !error) {
+    if (collateralName && !error) {
       if (ownerNeuron) {
         this.cleanupCtxIfNeeded(ownerNeuron);
       }
@@ -296,28 +371,63 @@ var CNSStimulation = class {
       }
     }
     this.scheduledCount += subscriberQueueItems.length;
-    this.options?.onResponse?.({
-      inputSignal,
-      outputSignal,
-      ctx: this.ctx,
-      queueLength: this.queue.length + this.scheduledCount,
-      stimulationId: this.id,
-      hops: this.options?.maxNeuronHops && ownerNeuron ? this.nueronVisitMap?.get(ownerNeuron.name) ?? 0 : void 0,
-      error
-    });
+    let maybePromise;
+    try {
+      maybePromise = this.options?.onResponse?.({
+        inputSignal,
+        outputSignal,
+        ctx: this.ctx,
+        queueLength: this.queue.length + this.scheduledCount,
+        stimulationId: this.id,
+        hops: this.options?.maxNeuronHops && ownerNeuron ? this.nueronVisitMap?.get(ownerNeuron.name) ?? 0 : void 0,
+        error
+      });
+    } catch (e) {
+      this.rejectCompleted(e);
+      return;
+    }
+    if (maybePromise && typeof maybePromise.then === "function") {
+      maybePromise.then(
+        () => {
+          for (let i = 0; i < subscriberQueueItems.length; i++) {
+            this.scheduledCount--;
+            this.queue.enqueue(subscriberQueueItems[i]);
+          }
+          this.tryResolveCompleted();
+        },
+        (error2) => {
+          this.rejectCompleted(error2);
+        }
+      );
+      return;
+    }
     for (let i = 0; i < subscriberQueueItems.length; i++) {
       this.scheduledCount--;
       this.queue.enqueue(subscriberQueueItems[i]);
     }
+    this.tryResolveCompleted();
   }
-  responseToSignal(signal) {
+  responseToSignal(signalOrSignals) {
+    if (Array.isArray(signalOrSignals)) {
+      for (const signal of signalOrSignals) {
+        const ownerNeuron2 = this.cns.getParentNeuronByCollateralName(
+          signal.collateralName
+        );
+        if (ownerNeuron2) {
+          this.markNeuronActive(ownerNeuron2.name);
+        }
+      }
+      this.processResponseOrResponses(void 0, signalOrSignals);
+      return;
+    }
     const ownerNeuron = this.cns.getParentNeuronByCollateralName(
-      signal.collateral.name
+      signalOrSignals.collateralName
     );
     if (ownerNeuron) {
       this.markNeuronActive(ownerNeuron.name);
     }
-    this.processResponse(void 0, signal);
+    this.processResponse(void 0, signalOrSignals);
+    this.tryResolveCompleted();
   }
 };
 
@@ -553,16 +663,30 @@ var CNS = class {
       };
     }
     return (r) => {
-      try {
-        if (local) local(r);
-      } finally {
-        for (let i = 0; i < this.globalResponseListeners.length; i++) {
-          try {
-            this.globalResponseListeners[i](r);
-          } catch (e) {
-          }
+      let anyPromise = false;
+      const promises = [];
+      if (local) {
+        const res = local(r);
+        if (res && typeof res.then === "function") {
+          anyPromise = true;
+          promises.push(res);
+        }
+      }
+      for (let i = 0; i < this.globalResponseListeners.length; i++) {
+        const res = this.globalResponseListeners[i](r);
+        if (res && typeof res.then === "function") {
+          anyPromise = true;
+          promises.push(res);
         }
       }
+      if (anyPromise) {
+        return Promise.allSettled(promises).then((results) => {
+          const rejected = results.find(
+            (r2) => r2.status === "rejected"
+          );
+          if (rejected) throw rejected.reason;
+        });
+      }
     };
   }
   runWithNeuronConcurrency(neuron2, fn) {
@@ -842,16 +966,25 @@ var CNS = class {
   getNeurons() {
     return Array.from(this.neuronIndex.values());
   }
+  getCollateralByName(collateralName) {
+    return this.collateralIndex.get(
+      collateralName
+    );
+  }
+  getNeuronByName(neuronName) {
+    return this.neuronIndex.get(neuronName);
+  }
   getSubscribers(collateralName) {
     return this.subIndex.get(collateralName) ?? [];
   }
-  stimulate(signal, options) {
+  stimulate(signalOrSignals, options) {
     const wrapped = this.wrapOnResponse(options?.onResponse);
     const stimulation = new CNSStimulation(this, this.instanceNeuronQueue, {
       ...options,
       onResponse: wrapped
     });
-    stimulation.responseToSignal(signal);
+    stimulation.responseToSignal(signalOrSignals);
+    return stimulation.waitUntilComplete();
   }
 };
 
@@ -861,7 +994,7 @@ var CNSCollateral = class {
     this.name = name;
   }
   createSignal(payload) {
-    return { collateral: this, payload };
+    return { collateralName: this.name, payload };
   }
 };
 
@@ -874,6 +1007,10 @@ var neuron = (name, axon) => {
       api.concurrency = n;
       return api;
     },
+    setMaxDuration: (ms) => {
+      api.maxDuration = ms;
+      return api;
+    },
     bind: ((axon2, newDendrites) => {
       for (const key in newDendrites) {
         const value = newDendrites[key];
@@ -890,6 +1027,7 @@ var neuron = (name, axon) => {
     axon,
     name,
     concurrency: void 0,
+    maxDuration: void 0,
     dendrites,
     dendrite(s) {
       dendrites.push(