@cnstra/core 1.4.0 → 1.6.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;
@@ -215,7 +238,7 @@ var CNSStimulation = class {
     if (this.options?.maxNeuronHops) {
       if (this.nueronVisitMap?.get(subscriber.neuron.name) ?? 0 >= this.options?.maxNeuronHops) {
         throw new Error(
-          `Max neuron hops reached for neuron "${subscriber.neuron.name}" when trying to enqueue subscriber "${subscriber.dendrite.collateral.type}" in stimulation "${this.id}"`
+          `Max neuron hops reached for neuron "${subscriber.neuron.name}" when trying to enqueue subscriber "${subscriber.dendrite.collateral.name}" in stimulation "${this.id}"`
         );
       } else {
         this.nueronVisitMap?.set(
@@ -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(
@@ -241,16 +280,40 @@ var CNSStimulation = class {
         {
           get: () => this.ctx.get(neuron2.name),
           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
               );
@@ -259,7 +322,7 @@ var CNSStimulation = class {
           (error) => {
             return () => {
               this.markNeuronInactive(neuron2.name);
-              return this.processResponse(
+              return this.processResponseOrResponses(
                 inputSignal,
                 void 0,
                 error
@@ -270,7 +333,7 @@ var CNSStimulation = class {
       } else {
         return () => {
           this.markNeuronInactive(neuron2.name);
-          return this.processResponse(
+          return this.processResponseOrResponses(
             inputSignal,
             response
           );
@@ -279,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.getParentNeuronByCollateralId(collateral2.type) : void 0;
-    const subscribers = collateral2 ? this.cns.getSubscribers(collateral2.type) : [];
+    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);
       }
@@ -295,27 +371,63 @@ var CNSStimulation = class {
       }
     }
     this.scheduledCount += subscriberQueueItems.length;
-    this.options?.onResponse?.({
-      inputSignal,
-      outputSignal,
-      ctx: this.ctx,
-      queueLength: this.queue.length + this.scheduledCount,
-      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) {
-    const ownerNeuron = this.cns.getParentNeuronByCollateralId(
-      signal.collateral.type
+  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(
+      signalOrSignals.collateralName
     );
     if (ownerNeuron) {
       this.markNeuronActive(ownerNeuron.name);
     }
-    this.processResponse(void 0, signal);
+    this.processResponse(void 0, signalOrSignals);
+    this.tryResolveCompleted();
   }
 };
 
@@ -462,11 +574,14 @@ var CNS = class {
     this.neurons = neurons;
     this.options = options;
     /**
-     * Fast lookup: collateralId -> list of (neuron, dendrite) subscribers.
+     * Fast lookup: collateralName -> list of (neuron, dendrite) subscribers.
      * Built once at construction time.
      */
     this.subIndex = /* @__PURE__ */ new Map();
-    this.parentNeuronByCollateralId = /* @__PURE__ */ new Map();
+    this.neuronIndex = /* @__PURE__ */ new Map();
+    this.dendriteIndex = /* @__PURE__ */ new Map();
+    this.collateralIndex = /* @__PURE__ */ new Map();
+    this.parentNeuronByCollateralName = /* @__PURE__ */ new Map();
     /**
      * Strongly Connected Components of the neuron graph.
      * Each component is a set of neuron IDs that can reach each other.
@@ -548,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) {
@@ -613,22 +742,28 @@ var CNS = class {
   }
   buildIndexes() {
     this.subIndex.clear();
-    this.parentNeuronByCollateralId.clear();
+    this.parentNeuronByCollateralName.clear();
     for (const neuron2 of this.neurons) {
+      this.neuronIndex.set(neuron2.name, neuron2);
       for (const dendrite of neuron2.dendrites) {
-        const key = dendrite.collateral.type;
+        const key = dendrite.collateral.name;
         const arr = this.subIndex.get(key) ?? [];
         arr.push({ neuron: neuron2, dendrite });
         this.subIndex.set(
           key,
           arr
         );
+        this.dendriteIndex.set(key, dendrite);
       }
       Object.values(neuron2.axon).forEach((collateral2) => {
-        this.parentNeuronByCollateralId.set(
-          collateral2.type,
+        this.parentNeuronByCollateralName.set(
+          collateral2.name,
           neuron2
         );
+        this.collateralIndex.set(
+          collateral2.name,
+          collateral2
+        );
       });
     }
   }
@@ -645,8 +780,8 @@ var CNS = class {
       const reachableNeurons = /* @__PURE__ */ new Set();
       for (const axonKey in neuron2.axon) {
         const collateral2 = neuron2.axon[axonKey];
-        const collateralType = collateral2.type;
-        const subscribers = this.subIndex.get(collateralType);
+        const collateralName = collateral2.name;
+        const subscribers = this.subIndex.get(collateralName);
         if (subscribers) {
           for (const { neuron: targetNeuron } of subscribers) {
             reachableNeurons.add(targetNeuron.name);
@@ -819,34 +954,52 @@ var CNS = class {
     }
     return true;
   }
-  getParentNeuronByCollateralId(collateralType) {
-    return this.parentNeuronByCollateralId.get(collateralType);
+  getParentNeuronByCollateralName(collateralName) {
+    return this.parentNeuronByCollateralName.get(collateralName);
+  }
+  getDendrites() {
+    return Array.from(this.dendriteIndex.values());
+  }
+  getCollaterals() {
+    return Array.from(this.collateralIndex.values());
+  }
+  getNeurons() {
+    return Array.from(this.neuronIndex.values());
+  }
+  getCollateralByName(collateralName) {
+    return this.collateralIndex.get(
+      collateralName
+    );
+  }
+  getNeuronByName(neuronName) {
+    return this.neuronIndex.get(neuronName);
   }
-  getSubscribers(collateralType) {
-    return this.subIndex.get(collateralType) ?? [];
+  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();
   }
 };
 
 // src/CNSCollateral.ts
 var CNSCollateral = class {
-  constructor(type) {
-    this.type = type;
+  constructor(name) {
+    this.name = name;
   }
   createSignal(payload) {
-    return { collateral: this, payload };
+    return { collateralName: this.name, payload };
   }
 };
 
 // src/factory/index.ts
-var collateral = (type) => new CNSCollateral(type);
+var collateral = (name) => new CNSCollateral(name);
 var neuron = (name, axon) => {
   const dendrites = [];
   const api = {
@@ -854,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];
@@ -870,6 +1027,7 @@ var neuron = (name, axon) => {
     axon,
     name,
     concurrency: void 0,
+    maxDuration: void 0,
     dendrites,
     dendrite(s) {
       dendrites.push(
@@ -885,30 +1043,10 @@ var withCtx = () => ({
     return neuron(name, axon);
   }
 });
-var fa = {
-  test1: new CNSCollateral("test1"),
-  test2: new CNSCollateral("test2")
-};
-var fb = {
-  test4: collateral("test4"),
-  test5: collateral("test5")
-};
-withCtx().neuron("test", {
-  test1: fa.test1,
-  test2: fa.test2
-}).bind(fb, {
-  test4: (payload, axon) => {
-    const ok = payload.test44;
-    return axon.test1.createSignal(ok);
-  },
-  test5: (payload, axon) => {
-    const ok2 = payload.test44;
-    return axon.test2.createSignal(ok2);
-  }
-});
 
 exports.CNS = CNS;
 exports.CNSCollateral = CNSCollateral;
+exports.CNSStimulationContextStore = CNSStimulationContextStore;
 exports.collateral = collateral;
 exports.neuron = neuron;
 exports.withCtx = withCtx;