@cnstra/core 2.2.0 → 2.3.0

package/dist/index.js

@@ -1,79 +1,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 TASK_DENDRITE = /* @__PURE__ */ Symbol("cnstra.taskDendrite");
+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.neuronVisitMap = /* @__PURE__ */ new Map();
+    }
+    if (this.autoCleanupContextsEnabled) {
+      this.activeSccCounts = /* @__PURE__ */ new Map();
     }
-    this.items = new Array(this.capacity);
   }
+  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++;
+  }
+  /** 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;
   }
-  enqueueItem(neuronActivationTask) {
-    if (this.size === this.capacity) {
-      this.resize();
+  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) {
@@ -81,26 +156,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();
             }
@@ -110,7 +185,6 @@ var CNSNeuronActivationPump = class {
         continue;
       }
       this.activeOperations--;
-      this.activeTasks.delete(neuronActivationTask);
       if (typeof ret === "function") ret();
     }
     this.pumping = false;
@@ -119,73 +193,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"
@@ -195,37 +216,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
@@ -238,7 +269,7 @@ var CNSStimulation = class {
    */
   enqueueTasks(tasks) {
     for (const task of tasks) {
-      this.queue.enqueue(task);
+      this.qEnqueue(task);
     }
     this.tryResolveCompleted();
   }
@@ -266,20 +297,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`
@@ -290,7 +325,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
@@ -298,19 +334,19 @@ var CNSStimulation = class {
   }
   cleanupCtxIfNeeded(neuron2) {
     if (this.autoCleanupContextsEnabled && this.canNeuronBeGuaranteedDone(neuron2)) {
-      this.ctx.delete(neuron2);
+      this.ctxStore?.delete(neuron2);
     }
   }
   createSubscriberQueueItem(subscriber, inputSignal) {
     if (this.options?.maxNeuronHops) {
-      if ((this.nueronVisitMap?.get(subscriber.neuron) ?? 0) >= this.options?.maxNeuronHops) {
+      if ((this.neuronVisitMap?.get(subscriber.neuron) ?? 0) >= this.options?.maxNeuronHops) {
         throw new Error(
           `Max neuron hops reached when trying to enqueue subscriber`
         );
       } else {
-        this.nueronVisitMap?.set(
+        this.neuronVisitMap?.set(
           subscriber.neuron,
-          (this.nueronVisitMap?.get(subscriber.neuron) ?? 0) + 1
+          (this.neuronVisitMap?.get(subscriber.neuron) ?? 0) + 1
         );
       }
     }
@@ -319,17 +355,24 @@ var CNSStimulation = class {
       dendriteCollateral: subscriber.dendrite.collateral,
       input: inputSignal
     };
+    neuronActivationTask[TASK_DENDRITE] = subscriber;
     return neuronActivationTask;
   }
   executeActivationTask(neuronActivationTask) {
-    const subscribers = this.cns.network.getSubscribers(
-      neuronActivationTask.dendriteCollateral
-    );
-    const subscriber = subscribers.find(
-      (s) => s.neuron === neuronActivationTask.neuron
-    );
+    let subscriber = neuronActivationTask[TASK_DENDRITE];
     if (!subscriber) {
-      this.failedTasks.push({
+      const subscribers = this.cns.network.getSubscribers(
+        neuronActivationTask.dendriteCollateral
+      );
+      for (let i = 0; i < subscribers.length; i++) {
+        if (subscribers[i].neuron === neuronActivationTask.neuron) {
+          subscriber = subscribers[i];
+          break;
+        }
+      }
+    }
+    if (!subscriber) {
+      this.pushFailedTask({
         task: neuronActivationTask,
         error: new Error(
           `Subscriber not found for activation task`
@@ -342,40 +385,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(() => {
@@ -395,48 +456,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)) {
@@ -454,36 +512,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.neuronVisitMap?.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;
@@ -493,8 +577,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();
         },
@@ -502,8 +586,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();
         }
@@ -512,8 +596,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();
   }
@@ -589,8 +673,12 @@ var CNSNetwork = class {
     /**
      * Strongly Connected Components of the neuron graph.
      * Each component is a set of neuron objects that can reach each other.
+     *
+     * Computed lazily on first access: the SCC machinery is only needed for
+     * `autoCleanupContexts` (off by default), so most networks never pay for it.
      */
-    this.stronglyConnectedComponents = [];
+    this._stronglyConnectedComponents = [];
+    this.sccBuilt = false;
     /**
      * Quick lookup: neuron -> SCC index for fast reachability checks.
      */
@@ -608,21 +696,18 @@ var CNSNetwork = class {
      * Built once at construction time.
      */
     this.subIndex = /* @__PURE__ */ new Map();
-    this.dendriteIndex = /* @__PURE__ */ new Map();
-    this.collateralIndex = /* @__PURE__ */ new Set();
     this.parentNeuronByCollateral = /* @__PURE__ */ new Map();
-    this.validateUniqueIdentifiers();
     this.buildIndexes();
-    this.buildSCC();
   }
-  /**
-   * Validate uniqueness constraints:
-   * - (legacy) collateral instances used to be single-owner; in object-identity routing
-   *   a collateral can be emitted by multiple neurons (fan-in), so we no longer
-   *   enforce single ownership here.
-   * Throws aggregated error if violations are found.
-   */
-  validateUniqueIdentifiers() {
+  get stronglyConnectedComponents() {
+    this.ensureSCC();
+    return this._stronglyConnectedComponents;
+  }
+  /** Build the SCC analysis the first time anything needs it. */
+  ensureSCC() {
+    if (this.sccBuilt) return;
+    this.sccBuilt = true;
+    this.buildSCC();
   }
   /**
    * Build the neuron graph where neurons are connected if one can stimulate the other.
@@ -697,7 +782,7 @@ var CNSNetwork = class {
         strongConnect(neuron2);
       }
     }
-    this.stronglyConnectedComponents = components;
+    this._stronglyConnectedComponents = components;
     for (let i = 0; i < components.length; i++) {
       for (const neuronId of Array.from(components[i])) {
         this.neuronToSCC.set(neuronId, i);
@@ -711,11 +796,11 @@ var CNSNetwork = class {
    */
   buildSCCDAG(neuronGraph) {
     this.sccDag.clear();
-    for (let i = 0; i < this.stronglyConnectedComponents.length; i++) {
+    for (let i = 0; i < this._stronglyConnectedComponents.length; i++) {
       this.sccDag.set(i, /* @__PURE__ */ new Set());
     }
-    for (let i = 0; i < this.stronglyConnectedComponents.length; i++) {
-      const scc = this.stronglyConnectedComponents[i];
+    for (let i = 0; i < this._stronglyConnectedComponents.length; i++) {
+      const scc = this._stronglyConnectedComponents[i];
       for (const neuron2 of Array.from(scc)) {
         const neighbors = neuronGraph.get(neuron2) || /* @__PURE__ */ new Set();
         for (const neighbor of Array.from(neighbors)) {
@@ -733,25 +818,27 @@ var CNSNetwork = class {
    */
   buildSCCAncestors() {
     this.sccAncestors.clear();
-    for (let i = 0; i < this.stronglyConnectedComponents.length; i++) {
+    for (let i = 0; i < this._stronglyConnectedComponents.length; i++) {
       this.sccAncestors.set(i, /* @__PURE__ */ new Set());
     }
+    const n = this._stronglyConnectedComponents.length;
+    const forward = Array.from({ length: n }, () => []);
     const inDegree = /* @__PURE__ */ new Map();
     const queue = [];
-    for (let i = 0; i < this.stronglyConnectedComponents.length; i++) {
-      const incomingEdges = this.sccDag.get(i) || /* @__PURE__ */ new Set();
-      inDegree.set(i, incomingEdges.size);
-      if (incomingEdges.size === 0) {
-        queue.push(i);
+    for (let target = 0; target < n; target++) {
+      const sources = this.sccDag.get(target) || /* @__PURE__ */ new Set();
+      inDegree.set(target, sources.size);
+      if (sources.size === 0) queue.push(target);
+      for (const source of Array.from(sources)) {
+        forward[source].push(target);
       }
     }
     while (queue.length > 0) {
       const current = queue.shift();
-      const outgoingEdges = this.getOutgoingEdges(current);
-      for (const neighbor of Array.from(outgoingEdges)) {
+      const currentAncestors = this.sccAncestors.get(current);
+      for (const neighbor of forward[current]) {
         const neighborAncestors = this.sccAncestors.get(neighbor);
         neighborAncestors.add(current);
-        const currentAncestors = this.sccAncestors.get(current);
         for (const ancestor of Array.from(currentAncestors)) {
           neighborAncestors.add(ancestor);
         }
@@ -763,32 +850,22 @@ var CNSNetwork = class {
       }
     }
   }
-  /**
-   * Get outgoing edges for a given SCC index
-   */
-  getOutgoingEdges(sccIndex) {
-    const outgoing = /* @__PURE__ */ new Set();
-    for (const [targetScc, incomingEdges] of Array.from(this.sccDag)) {
-      if (incomingEdges.has(sccIndex)) {
-        outgoing.add(targetScc);
-      }
-    }
-    return outgoing;
-  }
   /**
    * Check if a neuron can be reached again (including self-calling).
    * Returns true if the neuron is in a strongly connected component with more than one member,
    * or if it's in a single-member SCC that can reach itself.
    */
   getSCCSetByNeuron(neuron2) {
+    this.ensureSCC();
     const sccIndex = this.neuronToSCC.get(neuron2);
     if (sccIndex === void 0) return;
-    return this.stronglyConnectedComponents[sccIndex];
+    return this._stronglyConnectedComponents[sccIndex];
   }
   /**
    * Get the SCC index for a given neuron
    */
   getSccIndexByNeuron(neuron2) {
+    this.ensureSCC();
     return this.neuronToSCC.get(neuron2);
   }
   /**
@@ -796,6 +873,7 @@ var CNSNetwork = class {
    * This is the core logic for safe context cleanup.
    */
   canNeuronBeGuaranteedDone(neuron2, activeSccCounts) {
+    this.ensureSCC();
     const sccIndex = this.neuronToSCC.get(neuron2);
     if (sccIndex === void 0) return true;
     if (activeSccCounts.get(sccIndex) && activeSccCounts.get(sccIndex) > 0) {
@@ -813,8 +891,6 @@ var CNSNetwork = class {
   buildIndexes() {
     this.subIndex.clear();
     this.parentNeuronByCollateral.clear();
-    this.dendriteIndex.clear();
-    this.collateralIndex.clear();
     for (const neuron2 of this.neurons) {
       for (const dendrite of neuron2.dendrites) {
         const key = dendrite.collateral;
@@ -824,25 +900,40 @@ var CNSNetwork = class {
           key,
           arr
         );
-        this.dendriteIndex.set(key, dendrite);
       }
       Object.values(neuron2.axon).forEach((collateral2) => {
         this.parentNeuronByCollateral.set(
           collateral2,
           neuron2
         );
-        this.collateralIndex.add(collateral2);
       });
     }
   }
   getParentNeuronByCollateral(collateral2) {
     return this.parentNeuronByCollateral.get(collateral2);
   }
+  // Computed on demand (rarely used): one dendrite per collateral, last wins —
+  // preserving the previous index semantics without building it every construct.
   getDendrites() {
-    return Array.from(this.dendriteIndex.values());
+    const byCollateral = /* @__PURE__ */ new Map();
+    for (const neuron2 of this.neurons) {
+      for (const dendrite of neuron2.dendrites) {
+        byCollateral.set(
+          dendrite.collateral,
+          dendrite
+        );
+      }
+    }
+    return Array.from(byCollateral.values());
   }
   getCollaterals() {
-    return Array.from(this.collateralIndex.values());
+    const collaterals = /* @__PURE__ */ new Set();
+    for (const neuron2 of this.neurons) {
+      for (const collateral2 of Object.values(neuron2.axon)) {
+        collaterals.add(collateral2);
+      }
+    }
+    return Array.from(collaterals);
   }
   getSubscribers(collateral2) {
     return this.subIndex.get(collateral2) ?? [];
@@ -877,8 +968,7 @@ var CNS = class {
   }
   wrapOnResponse(local) {
     if (this.globalResponseListeners.length === 0 && !local) {
-      return () => {
-      };
+      return void 0;
     }
     return (r) => {
       let anyPromise = false;
@@ -922,10 +1012,8 @@ var CNS = class {
     const stimulation = new CNSStimulation(
       this,
       this.instanceNeuronQueue,
-      {
-        ...options,
-        onResponse: wrapped
-      }
+      options,
+      wrapped
     );
     stimulation.responseToSignal(signalOrSignals);
     return stimulation;
@@ -938,10 +1026,8 @@ var CNS = class {
     const stimulation = new CNSStimulation(
       this,
       this.instanceNeuronQueue,
-      {
-        ...options,
-        onResponse: wrapped
-      }
+      options,
+      wrapped
     );
     stimulation.enqueueTasks(tasks);
     return stimulation;
@@ -1121,27 +1207,26 @@ var neuron = (axon) => {
         modality: singleModality,
         modalities: multipleModalities,
         afferentPaths: singleAfferentPaths,
-        default: singleDefaultHandler,
-        default: globalDefaultHandler,
+        default: defaultHandler,
         output
       } = s;
       const modalityConfigs = multipleModalities ? multipleModalities : singleModality ? [
         {
           modality: singleModality,
           afferentPaths: singleAfferentPaths,
-          default: singleDefaultHandler
+          default: defaultHandler
         }
       ] : [];
       const response = (payload, axon2, ctx) => {
         const stimulation = ctx.stimulation;
         const stimOptions = stimulation?.options;
         const runGlobalDefault = () => {
-          if (!globalDefaultHandler) {
+          if (!defaultHandler) {
             throw new Error(
               `modalityDendrite: No handler found for modality and no default handler provided`
             );
           }
-          const res = globalDefaultHandler(payload, axon2, ctx);
+          const res = defaultHandler(payload, axon2, ctx);
           if (res && typeof res.then === "function") {
             return res.then(
               (result) => output(result, axon2, ctx)
@@ -1160,7 +1245,7 @@ var neuron = (axon) => {
         }
         const stimAfferentPath = stimOptions.afferentPath;
         const handler = stimAfferentPath && matchingConfig.afferentPaths ? matchingConfig.afferentPaths.get(stimAfferentPath) : void 0;
-        const effectiveHandler = handler ?? matchingConfig.default ?? globalDefaultHandler;
+        const effectiveHandler = handler ?? matchingConfig.default ?? defaultHandler;
         if (!effectiveHandler) {
           throw new Error(
             `modalityDendrite: No handler found for afferent path in modality and no default handler provided`