@cnstra/core 2.2.0 → 2.2.1

package/dist/index.cjs

@@ -2,80 +2,154 @@
 
 // src/CNSStimulationContextStore.ts
 var CNSStimulationContextStore = class {
-  constructor(ctx = /* @__PURE__ */ new Map()) {
+  constructor(ctx) {
     this.ctx = ctx;
   }
   get(key) {
-    return this.ctx.get(key);
+    return this.ctx?.get(key);
   }
   set(key, value) {
-    this.ctx.set(key, value);
+    (this.ctx ?? (this.ctx = /* @__PURE__ */ new Map())).set(key, value);
   }
   getAll() {
-    return new Map(this.ctx);
+    return this.ctx ? new Map(this.ctx) : /* @__PURE__ */ new Map();
   }
   setAll(values) {
-    this.ctx.clear();
-    for (const [key, value] of values) this.ctx.set(key, value);
+    const ctx = this.ctx ?? (this.ctx = /* @__PURE__ */ new Map());
+    ctx.clear();
+    for (const [key, value] of values) ctx.set(key, value);
   }
   delete(key) {
-    this.ctx.delete(key);
+    this.ctx?.delete(key);
   }
 };
 
-// src/CNSNeuronActivationPump.ts
-var CNSNeuronActivationPump = class {
-  constructor(processor, concurrency, abortSignal, initialCapacity) {
-    this.processor = processor;
-    this.concurrency = concurrency;
+// src/CNSStimulation.ts
+var CNSDendriteContext = class {
+  constructor(stimulation, neuron2, abortSignal, cns) {
+    this.stimulation = stimulation;
+    this.neuron = neuron2;
     this.abortSignal = abortSignal;
-    this.items = [];
-    this.head = 0;
-    this.tail = 0;
-    this.size = 0;
-    this.capacity = 16;
+    this.cns = cns;
+  }
+  get() {
+    return this.stimulation.getContext().get(this.neuron);
+  }
+  set(value) {
+    this.stimulation.getContext().set(this.neuron, value);
+  }
+  delete() {
+    this.stimulation.getContext().delete(this.neuron);
+  }
+};
+var CNSStimulationResponseImpl = class {
+  constructor(stimulation, store, inputSignal, outputSignal, queueLength, hops, error) {
+    this.stimulation = stimulation;
+    this.store = store;
+    this.inputSignal = inputSignal;
+    this.outputSignal = outputSignal;
+    this.queueLength = queueLength;
+    this.hops = hops;
+    this.error = error;
+  }
+  get contextValue() {
+    return this.store ? this.store.getAll() : /* @__PURE__ */ new Map();
+  }
+};
+var CNSStimulation = class {
+  constructor(cns, instanceNeuronQueue, options, onResponse) {
+    this.cns = cns;
+    this.options = options;
+    this.qHead = 0;
+    this.qTail = 0;
+    this.qSize = 0;
+    this.qCapacity = 4;
     this.activeOperations = 0;
-    this.activeTasks = /* @__PURE__ */ new Set();
-    // NEW: prevent re-entrant pump; defer extra runs
+    // Re-entrancy guard for the pump loop.
     this.pumping = false;
     this.needsPump = false;
-    if (initialCapacity && initialCapacity > 0) {
-      this.capacity = initialCapacity;
+    this.scheduledCount = 0;
+    this.isCompleted = false;
+    this.completionRejected = false;
+    this.ctxStore = options?.ctx;
+    this.instanceNeuronQueue = instanceNeuronQueue;
+    this.onResponse = onResponse;
+    if (this.options?.maxNeuronHops) {
+      this.nueronVisitMap = /* @__PURE__ */ new Map();
     }
-    this.items = new Array(this.capacity);
+    if (this.autoCleanupContextsEnabled) {
+      this.activeSccCounts = /* @__PURE__ */ new Map();
+    }
+  }
+  pushFailedTask(failure) {
+    (this.failedTasks ?? (this.failedTasks = [])).push(failure);
+  }
+  finalizeResolve() {
+    this.completionRejected = false;
+    this.resolveCompleted?.();
+  }
+  finalizeReject(error) {
+    this.completionRejected = true;
+    this.completionError = error;
+    this.rejectCompleted?.(error);
+  }
+  /** Lazily-created neuron context store (see {@link ctxStore}). */
+  get ctx() {
+    return this.ctxStore ?? (this.ctxStore = new CNSStimulationContextStore());
   }
+  // ----- Inlined activation queue / pump -----
   get canStartOperation() {
-    const limit = this.concurrency ?? Infinity;
-    return this.activeOperations < limit && !this.abortSignal?.aborted;
-  }
-  resize() {
-    const oldCapacity = this.capacity;
-    this.capacity = oldCapacity * 2;
-    const newItems = new Array(this.capacity);
-    let oldIndex = this.head;
-    for (let i = 0; i < this.size; i++) {
-      newItems[i] = this.items[oldIndex];
+    const limit = this.options?.concurrency ?? Infinity;
+    return this.activeOperations < limit && !this.options?.abortSignal?.aborted;
+  }
+  qResize() {
+    const oldCapacity = this.qCapacity;
+    const oldItems = this.qItems;
+    this.qCapacity = oldCapacity * 2;
+    const newItems = new Array(this.qCapacity);
+    let oldIndex = this.qHead;
+    for (let i = 0; i < this.qSize; i++) {
+      newItems[i] = oldItems[oldIndex];
       oldIndex = (oldIndex + 1) % oldCapacity;
     }
-    this.items = newItems;
-    this.head = 0;
-    this.tail = this.size;
-  }
-  dequeue() {
-    if (this.size === 0) return void 0;
-    const neuronActivationTask = this.items[this.head];
-    this.items[this.head] = void 0;
-    this.head = (this.head + 1) % this.capacity;
-    this.size--;
-    return neuronActivationTask;
+    this.qItems = newItems;
+    this.qHead = 0;
+    this.qTail = this.qSize;
+  }
+  qDequeue() {
+    if (this.qSize === 0) return void 0;
+    const items = this.qItems;
+    const task = items[this.qHead];
+    items[this.qHead] = void 0;
+    this.qHead = (this.qHead + 1) % this.qCapacity;
+    this.qSize--;
+    return task;
+  }
+  qEnqueueItem(task) {
+    if (!this.qItems) {
+      this.qItems = new Array(this.qCapacity);
+    } else if (this.qSize === this.qCapacity) {
+      this.qResize();
+    }
+    this.qItems[this.qTail] = task;
+    this.qTail = (this.qTail + 1) % this.qCapacity;
+    this.qSize++;
   }
-  enqueueItem(neuronActivationTask) {
-    if (this.size === this.capacity) {
-      this.resize();
+  /** Enqueue a task and drive the pump unless one is already running. */
+  qEnqueue(task) {
+    this.qEnqueueItem(task);
+    if (!this.pumping) this.pump();
+    else this.needsPump = true;
+  }
+  qGetQueuedTasks() {
+    const result = [];
+    if (!this.qItems) return result;
+    let index = this.qHead;
+    for (let i = 0; i < this.qSize; i++) {
+      result.push(this.qItems[index]);
+      index = (index + 1) % this.qCapacity;
     }
-    this.items[this.tail] = neuronActivationTask;
-    this.tail = (this.tail + 1) % this.capacity;
-    this.size++;
+    return result;
   }
   pump() {
     if (this.pumping) {
@@ -83,26 +157,26 @@ var CNSNeuronActivationPump = class {
       return;
     }
     this.pumping = true;
-    while (this.canStartOperation && this.size > 0) {
-      const neuronActivationTask = this.dequeue();
+    while (this.canStartOperation && this.qSize > 0) {
+      const task = this.qDequeue();
       this.activeOperations++;
-      this.activeTasks.add(neuronActivationTask);
-      const ret = this.processor(neuronActivationTask);
+      const ret = this.executeActivationTask(task);
       if (ret && typeof ret.then === "function") {
+        (this.activeTasks ?? (this.activeTasks = /* @__PURE__ */ new Set())).add(task);
         ret.then(
           (cb) => {
             this.activeOperations--;
-            this.activeTasks.delete(neuronActivationTask);
+            this.activeTasks.delete(task);
             if (typeof cb === "function") cb();
-            if (this.size > 0 && this.canStartOperation) {
+            if (this.qSize > 0 && this.canStartOperation) {
               if (this.pumping) this.needsPump = true;
               else this.pump();
             }
           },
           (err) => {
             this.activeOperations--;
-            this.activeTasks.delete(neuronActivationTask);
-            if (this.size > 0 && this.canStartOperation) {
+            this.activeTasks.delete(task);
+            if (this.qSize > 0 && this.canStartOperation) {
               if (this.pumping) this.needsPump = true;
               else this.pump();
             }
@@ -112,7 +186,6 @@ var CNSNeuronActivationPump = class {
         continue;
       }
       this.activeOperations--;
-      this.activeTasks.delete(neuronActivationTask);
       if (typeof ret === "function") ret();
     }
     this.pumping = false;
@@ -121,73 +194,20 @@ var CNSNeuronActivationPump = class {
       this.pump();
     }
   }
-  enqueue(neuronActivationTask) {
-    this.enqueueItem(neuronActivationTask);
-    if (!this.pumping) this.pump();
-    else this.needsPump = true;
-  }
-  get length() {
-    return this.size;
-  }
-  getActiveOperationsCount() {
-    return this.activeOperations;
-  }
-  getQueuedTasks() {
-    const result = [];
-    let index = this.head;
-    for (let i = 0; i < this.size; i++) {
-      result.push(this.items[index]);
-      index = (index + 1) % this.capacity;
-    }
-    return result;
-  }
-  getActiveTasks() {
-    return Array.from(this.activeTasks);
-  }
-};
-
-// src/CNSStimulation.ts
-var CNSStimulation = class {
-  constructor(cns, instanceNeuronQueue, options) {
-    this.cns = cns;
-    this.options = options;
-    this.scheduledCount = 0;
-    this.pendingTasks = /* @__PURE__ */ new Set();
-    this.failedTasks = [];
-    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
-     */
-    this.activeSccCounts = /* @__PURE__ */ new Map();
-    this.ctx = options?.ctx ?? new CNSStimulationContextStore();
-    this.queue = new CNSNeuronActivationPump(
-      (neuronActivationTask) => this.executeActivationTask(neuronActivationTask),
-      options?.concurrency,
-      options?.abortSignal
-    );
-    this.instanceNeuronQueue = instanceNeuronQueue;
-    if (this.options?.maxNeuronHops) {
-      this.nueronVisitMap = /* @__PURE__ */ new Map();
-    }
-  }
   tryResolveCompleted() {
     if (this.isCompleted) return;
-    const noActive = this.queue.getActiveOperationsCount() === 0;
-    const noPending = this.queue.length + this.scheduledCount === 0;
+    const noActive = this.activeOperations === 0;
+    const noPending = this.qSize + this.scheduledCount === 0;
     const aborted = !!this.options?.abortSignal?.aborted;
     if (noPending && noActive || aborted && noActive && !noPending) {
       if (aborted) {
-        const queuedTasks = this.queue.getQueuedTasks();
+        const queuedTasks = this.qGetQueuedTasks();
         for (const task of [...queuedTasks]) {
-          const alreadyTracked = this.failedTasks.some(
+          const alreadyTracked = this.failedTasks?.some(
             (ft) => ft.task === task
           );
           if (!alreadyTracked) {
-            this.failedTasks.push({
+            this.pushFailedTask({
               task,
               error: new Error(
                 "Task aborted - not started due to abort signal"
@@ -197,37 +217,47 @@ var CNSStimulation = class {
           }
         }
         this.isCompleted = true;
-        this.rejectCompleted(new Error("Stimulation aborted"));
+        this.finalizeReject(new Error("Stimulation aborted"));
         return;
       }
       this.isCompleted = true;
-      if (this.failedTasks.length > 0 || this.onResponseError) {
+      const failedCount = this.failedTasks?.length ?? 0;
+      if (failedCount > 0 || this.onResponseError) {
         const error = this.onResponseError || new Error(
-          `Stimulation completed with ${this.failedTasks.length} failed task(s)`
+          `Stimulation completed with ${failedCount} failed task(s)`
         );
-        this.rejectCompleted(error);
+        this.finalizeReject(error);
       } else {
-        this.resolveCompleted();
+        this.finalizeResolve();
       }
     }
   }
   waitUntilComplete() {
+    if (this.completed) return this.completed;
+    if (this.isCompleted) {
+      this.completed = this.completionRejected ? Promise.reject(this.completionError) : Promise.resolve();
+      return this.completed;
+    }
+    this.completed = new Promise((resolve, reject) => {
+      this.resolveCompleted = resolve;
+      this.rejectCompleted = reject;
+    });
     return this.completed;
   }
   /**
    * Returns all current activation tasks: queued, active, and pending (scheduled but not yet enqueued)
    */
   getAllActivationTasks() {
-    const queuedTasks = this.queue.getQueuedTasks();
-    const activeTasks = this.queue.getActiveTasks();
-    const pendingTasks = Array.from(this.pendingTasks);
+    const queuedTasks = this.qGetQueuedTasks();
+    const activeTasks = this.activeTasks ? Array.from(this.activeTasks) : [];
+    const pendingTasks = this.pendingTasks ? Array.from(this.pendingTasks) : [];
     return [...queuedTasks, ...activeTasks, ...pendingTasks];
   }
   /**
    * Returns all tasks that failed or were aborted
    */
   getFailedTasks() {
-    return [...this.failedTasks];
+    return this.failedTasks ? [...this.failedTasks] : [];
   }
   /**
    * Get the context store for this stimulation
@@ -240,7 +270,7 @@ var CNSStimulation = class {
    */
   enqueueTasks(tasks) {
     for (const task of tasks) {
-      this.queue.enqueue(task);
+      this.qEnqueue(task);
     }
     this.tryResolveCompleted();
   }
@@ -268,20 +298,24 @@ var CNSStimulation = class {
    * Increment the active count for the SCC containing this neuron
    */
   incrementSccCount(neuron2) {
+    const counts = this.activeSccCounts;
+    if (!counts) return;
     const sccIndex = this.cns.network.getSccIndexByNeuron(neuron2);
     if (sccIndex === void 0) return;
-    const currentCount = this.activeSccCounts.get(sccIndex) || 0;
-    this.activeSccCounts.set(sccIndex, currentCount + 1);
+    const currentCount = counts.get(sccIndex) || 0;
+    counts.set(sccIndex, currentCount + 1);
   }
   /**
    * Decrement the active count for the SCC containing this neuron
    */
   decrementSccCount(neuron2) {
+    const counts = this.activeSccCounts;
+    if (!counts) return;
     const sccIndex = this.cns.network.getSccIndexByNeuron(neuron2);
     if (sccIndex === void 0) return;
-    const currentCount = this.activeSccCounts.get(sccIndex) || 0;
+    const currentCount = counts.get(sccIndex) || 0;
     const nextCount = Math.max(0, currentCount - 1);
-    this.activeSccCounts.set(sccIndex, nextCount);
+    counts.set(sccIndex, nextCount);
     if (currentCount === 0) {
       console.warn(
         `[CNSStimulation] Attempting to decrement SCC count below 0 for neuron`
@@ -292,7 +326,8 @@ var CNSStimulation = class {
    * Check if a neuron can be guaranteed not to be visited again
    */
   canNeuronBeGuaranteedDone(neuron2) {
-    if (!this.autoCleanupContextsEnabled) return false;
+    if (!this.autoCleanupContextsEnabled || !this.activeSccCounts)
+      return false;
     return this.cns.network.canNeuronBeGuaranteedDone(
       neuron2,
       this.activeSccCounts
@@ -300,7 +335,7 @@ var CNSStimulation = class {
   }
   cleanupCtxIfNeeded(neuron2) {
     if (this.autoCleanupContextsEnabled && this.canNeuronBeGuaranteedDone(neuron2)) {
-      this.ctx.delete(neuron2);
+      this.ctxStore?.delete(neuron2);
     }
   }
   createSubscriberQueueItem(subscriber, inputSignal) {
@@ -327,11 +362,15 @@ var CNSStimulation = class {
     const subscribers = this.cns.network.getSubscribers(
       neuronActivationTask.dendriteCollateral
     );
-    const subscriber = subscribers.find(
-      (s) => s.neuron === neuronActivationTask.neuron
-    );
+    let subscriber;
+    for (let i = 0; i < subscribers.length; i++) {
+      if (subscribers[i].neuron === neuronActivationTask.neuron) {
+        subscriber = subscribers[i];
+        break;
+      }
+    }
     if (!subscriber) {
-      this.failedTasks.push({
+      this.pushFailedTask({
         task: neuronActivationTask,
         error: new Error(
           `Subscriber not found for activation task`
@@ -344,40 +383,58 @@ var CNSStimulation = class {
     const neuron2 = subscriber.neuron;
     const dendrite = subscriber.dendrite;
     const inputSignal = neuronActivationTask.input;
-    const starter = () => {
-      this.markNeuronActive(neuron2);
-      let response;
-      try {
-        response = dendrite.response(
-          inputSignal?.payload,
-          neuron2.axon,
-          {
-            get: () => this.ctx.get(neuron2),
-            set: (value) => this.ctx.set(neuron2, value),
-            delete: () => this.ctx.delete(neuron2),
-            abortSignal: this.options?.abortSignal,
-            cns: this.cns,
-            stimulation: this
-          }
-        );
-      } catch (error) {
-        this.markNeuronInactive(neuron2);
-        const isAborted = this.options?.abortSignal?.aborted ?? false;
-        this.failedTasks.push({
-          task: neuronActivationTask,
-          error: error instanceof Error ? error : new Error(String(error)),
-          aborted: isAborted
-        });
-        this.processResponseOrResponses(
+    const concurrency = neuron2.concurrency;
+    if (concurrency === void 0 || concurrency <= 0) {
+      return this.runStarter(
+        neuron2,
+        dendrite,
+        inputSignal,
+        neuronActivationTask
+      );
+    }
+    return this.instanceNeuronQueue.run(
+      neuron2,
+      () => this.runStarter(
+        neuron2,
+        dendrite,
+        inputSignal,
+        neuronActivationTask
+      )
+    );
+  }
+  runStarter(neuron2, dendrite, inputSignal, neuronActivationTask) {
+    this.markNeuronActive(neuron2);
+    let response;
+    try {
+      response = dendrite.response(
+        inputSignal?.payload,
+        neuron2.axon,
+        new CNSDendriteContext(
+          this,
           neuron2,
-          inputSignal,
-          void 0,
-          error
-        );
-        return () => {
-        };
-      }
-      const maxDuration = neuron2.maxDuration;
+          this.options?.abortSignal,
+          this.cns
+        )
+      );
+    } catch (error) {
+      this.markNeuronInactive(neuron2);
+      const isAborted = this.options?.abortSignal?.aborted ?? false;
+      this.pushFailedTask({
+        task: neuronActivationTask,
+        error: error instanceof Error ? error : new Error(String(error)),
+        aborted: isAborted
+      });
+      this.processResponseOrResponses(
+        neuron2,
+        inputSignal,
+        void 0,
+        error
+      );
+      return () => {
+      };
+    }
+    const maxDuration = neuron2.maxDuration;
+    if (response instanceof Promise || maxDuration) {
       const asPromise = response instanceof Promise ? response : Promise.resolve(response);
       const timedPromise = maxDuration && maxDuration > 0 ? new Promise((resolve, reject) => {
         const t = setTimeout(() => {
@@ -397,48 +454,45 @@ var CNSStimulation = class {
           }
         );
       }) : asPromise;
-      if (response instanceof Promise || maxDuration) {
-        return timedPromise.then(
-          (signal) => {
-            return () => {
-              this.markNeuronInactive(neuron2);
-              return this.processResponseOrResponses(
-                neuron2,
-                inputSignal,
-                signal
-              );
-            };
-          },
-          (error) => {
-            return () => {
-              this.markNeuronInactive(neuron2);
-              const isAborted = this.options?.abortSignal?.aborted ?? false;
-              this.failedTasks.push({
-                task: neuronActivationTask,
-                error: error instanceof Error ? error : new Error(String(error)),
-                aborted: isAborted
-              });
-              return this.processResponseOrResponses(
-                neuron2,
-                inputSignal,
-                void 0,
-                error
-              );
-            };
-          }
+      return timedPromise.then(
+        (signal) => {
+          return () => {
+            this.markNeuronInactive(neuron2);
+            return this.processResponseOrResponses(
+              neuron2,
+              inputSignal,
+              signal
+            );
+          };
+        },
+        (error) => {
+          return () => {
+            this.markNeuronInactive(neuron2);
+            const isAborted = this.options?.abortSignal?.aborted ?? false;
+            this.pushFailedTask({
+              task: neuronActivationTask,
+              error: error instanceof Error ? error : new Error(String(error)),
+              aborted: isAborted
+            });
+            return this.processResponseOrResponses(
+              neuron2,
+              inputSignal,
+              void 0,
+              error
+            );
+          };
+        }
+      );
+    } else {
+      return () => {
+        this.markNeuronInactive(neuron2);
+        return this.processResponseOrResponses(
+          neuron2,
+          inputSignal,
+          response
         );
-      } else {
-        return () => {
-          this.markNeuronInactive(neuron2);
-          return this.processResponseOrResponses(
-            neuron2,
-            inputSignal,
-            response
-          );
-        };
-      }
-    };
-    return this.instanceNeuronQueue.run(neuron2, starter);
+      };
+    }
   }
   processResponseOrResponses(emitter, inputSignal, outputSignalOrSignals, error) {
     if (Array.isArray(outputSignalOrSignals)) {
@@ -456,36 +510,62 @@ var CNSStimulation = class {
   processResponse(emitter, inputSignal, outputSignal, error) {
     const collateral2 = outputSignal?.collateral;
     const subscribers = collateral2 ? this.cns.network.getSubscribers(collateral2) : [];
+    const onResponse = this.onResponse;
+    if (!onResponse) {
+      if (collateral2 && !error) {
+        if (emitter) this.cleanupCtxIfNeeded(emitter);
+        const n = subscribers.length;
+        if (n > 0) {
+          const tasks = new Array(n);
+          for (let i = 0; i < n; i++) {
+            tasks[i] = this.createSubscriberQueueItem(
+              subscribers[i],
+              outputSignal
+            );
+          }
+          this.scheduledCount += n;
+          for (let i = 0; i < n; i++) {
+            this.scheduledCount--;
+            this.qEnqueue(tasks[i]);
+          }
+        }
+      }
+      this.tryResolveCompleted();
+      return;
+    }
     const subscriberActivationTasks = [];
     if (collateral2 && !error) {
       if (emitter) this.cleanupCtxIfNeeded(emitter);
+      const pending = this.pendingTasks ?? (this.pendingTasks = /* @__PURE__ */ new Set());
       for (let i = 0; i < subscribers.length; i++) {
         const task = this.createSubscriberQueueItem(
           subscribers[i],
           outputSignal
         );
         subscriberActivationTasks.push(task);
-        this.pendingTasks.add(task);
+        pending.add(task);
       }
     }
     this.scheduledCount += subscriberActivationTasks.length;
     let maybePromise;
     try {
-      maybePromise = this.options?.onResponse?.({
-        inputSignal,
-        outputSignal,
-        contextValue: this.ctx.getAll(),
-        queueLength: this.queue.length + this.scheduledCount,
-        stimulation: this,
-        hops: this.options?.maxNeuronHops && emitter ? this.nueronVisitMap?.get(emitter) ?? 0 : void 0,
-        error
-      });
+      maybePromise = onResponse(
+        new CNSStimulationResponseImpl(
+          this,
+          this.ctxStore,
+          inputSignal,
+          outputSignal,
+          this.qSize + this.scheduledCount,
+          this.options?.maxNeuronHops && emitter ? this.nueronVisitMap?.get(emitter) ?? 0 : void 0,
+          error
+        )
+      );
     } catch (e) {
       this.onResponseError = e instanceof Error ? e : new Error(String(e));
       for (let i = 0; i < subscriberActivationTasks.length; i++) {
         this.scheduledCount--;
-        this.pendingTasks.delete(subscriberActivationTasks[i]);
-        this.queue.enqueue(subscriberActivationTasks[i]);
+        this.pendingTasks?.delete(subscriberActivationTasks[i]);
+        this.qEnqueue(subscriberActivationTasks[i]);
       }
       this.tryResolveCompleted();
       return;
@@ -495,8 +575,8 @@ var CNSStimulation = class {
         () => {
           for (let i = 0; i < subscriberActivationTasks.length; i++) {
             this.scheduledCount--;
-            this.pendingTasks.delete(subscriberActivationTasks[i]);
-            this.queue.enqueue(subscriberActivationTasks[i]);
+            this.pendingTasks?.delete(subscriberActivationTasks[i]);
+            this.qEnqueue(subscriberActivationTasks[i]);
           }
           this.tryResolveCompleted();
         },
@@ -504,8 +584,8 @@ var CNSStimulation = class {
           this.onResponseError = error2 instanceof Error ? error2 : new Error(String(error2));
           for (let i = 0; i < subscriberActivationTasks.length; i++) {
             this.scheduledCount--;
-            this.pendingTasks.delete(subscriberActivationTasks[i]);
-            this.queue.enqueue(subscriberActivationTasks[i]);
+            this.pendingTasks?.delete(subscriberActivationTasks[i]);
+            this.qEnqueue(subscriberActivationTasks[i]);
           }
           this.tryResolveCompleted();
         }
@@ -514,8 +594,8 @@ var CNSStimulation = class {
     }
     for (let i = 0; i < subscriberActivationTasks.length; i++) {
       this.scheduledCount--;
-      this.pendingTasks.delete(subscriberActivationTasks[i]);
-      this.queue.enqueue(subscriberActivationTasks[i]);
+      this.pendingTasks?.delete(subscriberActivationTasks[i]);
+      this.qEnqueue(subscriberActivationTasks[i]);
     }
     this.tryResolveCompleted();
   }
@@ -879,8 +959,7 @@ var CNS = class {
   }
   wrapOnResponse(local) {
     if (this.globalResponseListeners.length === 0 && !local) {
-      return () => {
-      };
+      return void 0;
     }
     return (r) => {
       let anyPromise = false;
@@ -924,10 +1003,8 @@ var CNS = class {
     const stimulation = new CNSStimulation(
       this,
       this.instanceNeuronQueue,
-      {
-        ...options,
-        onResponse: wrapped
-      }
+      options,
+      wrapped
     );
     stimulation.responseToSignal(signalOrSignals);
     return stimulation;
@@ -940,10 +1017,8 @@ var CNS = class {
     const stimulation = new CNSStimulation(
       this,
       this.instanceNeuronQueue,
-      {
-        ...options,
-        onResponse: wrapped
-      }
+      options,
+      wrapped
     );
     stimulation.enqueueTasks(tasks);
     return stimulation;