@reicek/neataptic-ts 0.1.25 → 0.1.26

package/src/architecture/network/activate/README.md

@@ -2,57 +2,24 @@
 
 ## architecture/network/activate/network.activate.utils.types.ts
 
-### INPUT_NODE_TYPE
-
-Node role label used by activation traversal for input neurons.
-
-### OUTPUT_NODE_TYPE
-
-Node role label used by activation traversal for output neurons.
-
-### NO_TRACE_FAST_SLAB_TRAINING_FLAG
-
-Training flag value used by no-trace fast slab eligibility checks.
-
-### INITIAL_OUTPUT_WRITE_INDEX
-
-Initial write index used when collecting output activations.
-
-### OUTPUT_WRITE_INDEX_INCREMENT
-
-Increment applied after writing one output activation value.
-
-### UNDEFINED_INPUT_LENGTH_TEXT
-
-Fallback text for undefined input lengths when formatting validation errors.
-
-### DEFAULT_MAX_ACTIVATION_DEPTH
-
-Default hard limit for recursive activation depth in raw activation mode.
+### ActivateRuntimeNetworkProps
 
-### BATCH_INPUTS_COLLECTION_ERROR_MESSAGE
+Runtime network view used by the object-graph activation pipeline.
 
-Error message used when batch activation receives a non-array container.
+This intentionally describes the internal fields activation reads/writes
+(training step, RNG, regularization knobs, and slab fast-path hooks).
 
 ### ActivationOutputBuffer
 
 Pooled activation output array type acquired from the shared activation array pool.
 
-### NoTraceActivationContext
-
-Shared state used by no-trace activation orchestration and helpers.
-
-### NoTraceNodeTraversalContext
-
-Shared state used for node traversal during no-trace activation.
-
-### SingleNodeNoTraceActivationContext
+### ActivationStats
 
-Shared state used while activating one node during no-trace traversal.
+Activation telemetry collected during a single activation pass.
 
-### RawActivationContext
+### BATCH_INPUTS_COLLECTION_ERROR_MESSAGE
 
-Shared state used by raw activation orchestration.
+Error message used when batch activation receives a non-array container.
 
 ### BatchActivationContext
 
@@ -62,12 +29,17 @@ Shared state used by batch activation orchestration.
 
 Shared state used while validating and activating one row in a batch.
 
-### ActivateRuntimeNetworkProps
+### DEFAULT_MAX_ACTIVATION_DEPTH
 
-Runtime network view used by the object-graph activation pipeline.
+Default hard limit for recursive activation depth in raw activation mode.
 
-This intentionally describes the internal fields activation reads/writes
-(training step, RNG, regularization knobs, and slab fast-path hooks).
+### INITIAL_OUTPUT_WRITE_INDEX
+
+Initial write index used when collecting output activations.
+
+### INPUT_NODE_TYPE
+
+Node role label used by activation traversal for input neurons.
 
 ### NetworkLayer
 
@@ -77,94 +49,65 @@ Layer container type used by the layered activation paths.
 
 Node collection type attached to a single network layer.
 
-### WeightNoiseStats
+### NO_TRACE_FAST_SLAB_TRAINING_FLAG
 
-Weight-noise telemetry collected during a single activation pass.
+Training flag value used by no-trace fast slab eligibility checks.
 
-### ActivationStats
+### NoTraceActivationContext
 
-Activation telemetry collected during a single activation pass.
+Shared state used by no-trace activation orchestration and helpers.
 
-### WeightNoiseApplyResult
+### NoTraceNodeTraversalContext
 
-Marker returned by weight-noise application to drive safe restore logic.
+Shared state used for node traversal during no-trace activation.
 
-## architecture/network/activate/network.activate.utils.ts
+### OUTPUT_NODE_TYPE
 
-### noTraceActivate
+Node role label used by activation traversal for output neurons.
 
-```ts
-noTraceActivate(
-  input: number[],
-): number[]
-```
+### OUTPUT_WRITE_INDEX_INCREMENT
 
-Perform a forward pass without creating or updating training / gradient traces.
+Increment applied after writing one output activation value.
 
-This is the most allocation‑sensitive activation path. Internally it will attempt
-to leverage a compact "fast slab" routine (an optimized, vectorized broadcast over
-contiguous activation buffers) when the Network instance indicates that such a path
-is currently valid. If that attempt fails (for instance because the slab is stale
-after a structural mutation) execution gracefully falls back to a node‑by‑node loop.
+### RawActivationContext
 
-Algorithm outline:
- 1. (Optional) Refresh cached topological order if the network enforces acyclicity
-    and a structural change marked the order as dirty.
- 2. Validate the input dimensionality.
- 3. Try the fast slab path; if it throws, continue with the standard path.
- 4. Acquire a pooled output buffer sized to the number of output neurons.
- 5. Iterate all nodes in their internal order:
-      - Input nodes: directly assign provided input values.
-      - Hidden nodes: compute activation via Node.noTraceActivate (no bookkeeping).
-      - Output nodes: compute activation and store it (in sequence) inside the
-        pooled output buffer.
- 6. Copy the pooled buffer into a fresh array (detaches user from the pool) and
-    release the pooled buffer back to the pool.
+Shared state used by raw activation orchestration.
 
-Complexity considerations:
- - Time: O(N + E) where N = number of nodes, E = number of inbound edges processed
-   inside each Node.noTraceActivate call (not explicit here but inside the node).
- - Space: O(O) transient (O = number of outputs) due to the pooled output buffer.
+### SingleNodeNoTraceActivationContext
 
-Parameters:
-- `this` - - Bound Network instance.
-- `input` - - Flat numeric vector whose length must equal network.input.
+Shared state used while activating one node during no-trace traversal.
 
-Returns: Array of output neuron activations (length == network.output).
+### UNDEFINED_INPUT_LENGTH_TEXT
 
-Example:
+Fallback text for undefined input lengths when formatting validation errors.
 
-const out = net.noTraceActivate([0.1, 0.2, 0.3]);
-console.log(out); // => e.g. [0.5123, 0.0441]
+### WeightNoiseApplyResult
 
-### activateRaw
+Marker returned by weight-noise application to drive safe restore logic.
+
+### WeightNoiseStats
+
+Weight-noise telemetry collected during a single activation pass.
+
+## architecture/network/activate/network.activate.utils.ts
+
+### activate
 
 ```ts
-activateRaw(
+activate(
   input: number[],
   training: boolean,
-  maxActivationDepth: number,
 ): number[]
 ```
 
-Thin semantic alias to the network's main activation path.
-
-At present this simply forwards to {@link Network.activate}. The indirection is useful for:
- - Future differentiation between raw (immediate) activation and a mode that performs reuse /
-   staged batching logic.
- - Providing a stable exported symbol for external tooling / instrumentation.
+Execute the main activation routine and return plain numeric outputs.
 
 Parameters:
-- `this` - - Bound Network instance.
-- `input` - - Input vector (length == network.input).
-- `training` - - Whether to retain training traces / gradients (delegated downstream).
-- `maxActivationDepth` - - Guard against runaway recursion / cyclic activation attempts.
-
-Returns: Implementation-defined result of Network.activate (typically an output vector).
-
-Example:
+- `this` - Bound network instance.
+- `input` - Input values with length matching network input count.
+- `training` - Whether training-time stochastic behavior is enabled.
 
-const y = net.activateRaw([0,1,0]);
+Returns: Output activation values.
 
 ### activateBatch
 
@@ -196,23 +139,34 @@ Example:
 const batchOut = net.activateBatch([[0,0,1],[1,0,0],[0,1,0]]);
 console.log(batchOut.length); // 3 rows
 
-### activate
+### activateRaw
 
 ```ts
-activate(
+activateRaw(
   input: number[],
   training: boolean,
+  maxActivationDepth: number,
 ): number[]
 ```
 
-Execute the main activation routine and return plain numeric outputs.
+Thin semantic alias to the network's main activation path.
+
+At present this simply forwards to {@link Network.activate}. The indirection is useful for:
+ - Future differentiation between raw (immediate) activation and a mode that performs reuse /
+   staged batching logic.
+ - Providing a stable exported symbol for external tooling / instrumentation.
 
 Parameters:
-- `this` - Bound network instance.
-- `input` - Input values with length matching network input count.
-- `training` - Whether training-time stochastic behavior is enabled.
+- `this` - - Bound Network instance.
+- `input` - - Input vector (length == network.input).
+- `training` - - Whether to retain training traces / gradients (delegated downstream).
+- `maxActivationDepth` - - Guard against runaway recursion / cyclic activation attempts.
 
-Returns: Output activation values.
+Returns: Implementation-defined result of Network.activate (typically an output vector).
+
+Example:
+
+const y = net.activateRaw([0,1,0]);
 
 ### gaussianRand
 
@@ -229,25 +183,68 @@ Parameters:
 
 Returns: Standard normal sample with mean 0 and variance 1.
 
+### noTraceActivate
+
+```ts
+noTraceActivate(
+  input: number[],
+): number[]
+```
+
+Perform a forward pass without creating or updating training / gradient traces.
+
+This is the most allocation‑sensitive activation path. Internally it will attempt
+to leverage a compact "fast slab" routine (an optimized, vectorized broadcast over
+contiguous activation buffers) when the Network instance indicates that such a path
+is currently valid. If that attempt fails (for instance because the slab is stale
+after a structural mutation) execution gracefully falls back to a node‑by‑node loop.
+
+Algorithm outline:
+ 1. (Optional) Refresh cached topological order if the network enforces acyclicity
+    and a structural change marked the order as dirty.
+ 2. Validate the input dimensionality.
+ 3. Try the fast slab path; if it throws, continue with the standard path.
+ 4. Acquire a pooled output buffer sized to the number of output neurons.
+ 5. Iterate all nodes in their internal order:
+      - Input nodes: directly assign provided input values.
+      - Hidden nodes: compute activation via Node.noTraceActivate (no bookkeeping).
+      - Output nodes: compute activation and store it (in sequence) inside the
+        pooled output buffer.
+ 6. Copy the pooled buffer into a fresh array (detaches user from the pool) and
+    release the pooled buffer back to the pool.
+
+Complexity considerations:
+ - Time: O(N + E) where N = number of nodes, E = number of inbound edges processed
+   inside each Node.noTraceActivate call (not explicit here but inside the node).
+ - Space: O(O) transient (O = number of outputs) due to the pooled output buffer.
+
+Parameters:
+- `this` - - Bound Network instance.
+- `input` - - Flat numeric vector whose length must equal network.input.
+
+Returns: Array of output neuron activations (length == network.output).
+
+Example:
+
+const out = net.noTraceActivate([0.1, 0.2, 0.3]);
+console.log(out); // => e.g. [0.5123, 0.0441]
+
 ## architecture/network/activate/network.activate.raw.utils.ts
 
-### executeRawActivation
+### activateViaNetworkDelegate
 
 ```ts
-executeRawActivation(
+activateViaNetworkDelegate(
   activationContext: RawActivationContext,
 ): number[]
 ```
 
-Execute raw activation through the network delegate using a compact orchestration flow.
-
-This helper keeps the exported activation method focused on context creation while this
-module owns the execution path and future branching behavior.
+Delegate raw activation to the core network activation implementation.
 
 Parameters:
 - `activationContext` - - Shared raw activation state.
 
-Returns: Activation output vector from the network delegate.
+Returns: Activation output vector.
 
 ### activateWithSelectedReusePath
 
@@ -264,37 +261,40 @@ Parameters:
 
 Returns: Activation output vector.
 
-### activateViaNetworkDelegate
+### executeRawActivation
 
 ```ts
-activateViaNetworkDelegate(
+executeRawActivation(
   activationContext: RawActivationContext,
 ): number[]
 ```
 
-Delegate raw activation to the core network activation implementation.
+Execute raw activation through the network delegate using a compact orchestration flow.
+
+This helper keeps the exported activation method focused on context creation while this
+module owns the execution path and future branching behavior.
 
 Parameters:
 - `activationContext` - - Shared raw activation state.
 
-Returns: Activation output vector.
+Returns: Activation output vector from the network delegate.
 
 ## architecture/network/activate/network.activate.core.utils.ts
 
-### gaussianRand
+### acquireOutputBuffer
 
 ```ts
-gaussianRand(
-  rng: () => number,
-): number
+acquireOutputBuffer(
+  outputSize: number,
+): ActivationArray
 ```
 
-Produce a normally distributed random sample using the Box-Muller transform.
+Acquire a pooled activation output buffer for the current output width.
 
 Parameters:
-- `rng` - Pseudo-random source in the interval [0, 1).
+- `outputSize` - Number of output slots.
 
-Returns: Standard normal sample with mean 0 and variance 1.
+Returns: Mutable pooled output buffer.
 
 ### activate
 
@@ -314,215 +314,261 @@ Parameters:
 
 Returns: Output activation values.
 
-### prepareTopologyForActivation
+### activateLayer
 
 ```ts
-prepareTopologyForActivation(
-  runtimeNetwork: ActivateRuntimeNetworkProps,
-): void
+activateLayer(
+  currentLayer: default,
+  layerIndex: number,
+  inputVector: number[],
+  isTraining: boolean,
+): number[]
 ```
 
-Ensure topological order is refreshed before activation when acyclic mode requires it.
+Activate one layer, routing input only for the first layer.
 
 Parameters:
-- `runtimeNetwork` - Runtime activation internals.
+- `currentLayer` - Layer instance to activate.
+- `layerIndex` - Layer index.
+- `inputVector` - Network input vector.
+- `isTraining` - Training-time flag.
 
-Returns: Nothing.
+Returns: Layer activations.
 
-### validateInputVector
+### activateLayeredNetworkWithDropout
 
 ```ts
-validateInputVector(
+activateLayeredNetworkWithDropout(
   network: default,
+  runtimeNetwork: ActivateRuntimeNetworkProps,
   inputVector: number[],
+  isTraining: boolean,
+  outputBuffer: ActivationArray,
+  stats: ActivationStats,
 ): void
 ```
 
-Validate that the incoming input vector exists and matches expected input size.
+Run layered activation with dropout masks and no stochastic-depth skips.
 
 Parameters:
 - `network` - Network being activated.
-- `inputVector` - Input vector to validate.
+- `runtimeNetwork` - Runtime activation internals.
+- `inputVector` - Input vector.
+- `isTraining` - Training-time flag.
+- `outputBuffer` - Mutable output buffer.
+- `stats` - Activation stats accumulator.
 
 Returns: Nothing.
 
-### tryFastSlabActivation
+### activateLayeredNetworkWithStochasticDepth
 
 ```ts
-tryFastSlabActivation(
+activateLayeredNetworkWithStochasticDepth(
+  network: default,
   runtimeNetwork: ActivateRuntimeNetworkProps,
   inputVector: number[],
   isTraining: boolean,
-): number[] | undefined
+  outputBuffer: ActivationArray,
+  stats: ActivationStats,
+): void
 ```
 
-Attempt fast slab activation and safely fall back to regular activation on failure.
+Run layered activation with stochastic-depth skipping and inverse-survival scaling.
 
 Parameters:
+- `network` - Network being activated.
 - `runtimeNetwork` - Runtime activation internals.
 - `inputVector` - Input vector.
 - `isTraining` - Training-time flag.
+- `outputBuffer` - Mutable output buffer.
+- `stats` - Activation stats accumulator.
 
-Returns: Fast slab output when available, otherwise undefined.
+Returns: Nothing.
 
-### acquireOutputBuffer
+### activateNodeNetworkFallback
 
 ```ts
-acquireOutputBuffer(
-  outputSize: number,
-): ActivationArray
+activateNodeNetworkFallback(
+  network: default,
+  runtimeNetwork: ActivateRuntimeNetworkProps,
+  inputVector: number[],
+  isTraining: boolean,
+  outputBuffer: ActivationArray,
+  stats: ActivationStats,
+): void
 ```
 
-Acquire a pooled activation output buffer for the current output width.
+Run fallback node-by-node activation for networks without explicit layer definitions.
 
 Parameters:
-- `outputSize` - Number of output slots.
+- `network` - Network being activated.
+- `runtimeNetwork` - Runtime activation internals.
+- `inputVector` - Input vector.
+- `isTraining` - Training-time flag.
+- `outputBuffer` - Mutable output buffer.
+- `stats` - Activation stats accumulator.
 
-Returns: Mutable pooled output buffer.
+Returns: Nothing.
 
-### validateNetworkNodes
+### activateNodesAndCollectOutputs
 
 ```ts
-validateNetworkNodes(
-  network: default,
+activateNodesAndCollectOutputs(
+  nodes: default[],
+  inputVector: number[],
+  outputBuffer: ActivationArray,
 ): void
 ```
 
-Assert that the network contains nodes before executing activation routines.
+Activate raw nodes in order and collect output-node activations into output buffer.
 
 Parameters:
-- `network` - Network being activated.
+- `nodes` - Network nodes in activation order.
+- `inputVector` - Input vector.
+- `outputBuffer` - Mutable output buffer.
 
 Returns: Nothing.
 
-### resetSkippedLayers
+### applyDropConnect
 
 ```ts
-resetSkippedLayers(
+applyDropConnect(
   network: default,
+  runtimeNetwork: ActivateRuntimeNetworkProps,
+  isTraining: boolean,
+  stats: ActivationStats,
 ): void
 ```
 
-Clear the runtime list of skipped layers before current activation pass.
+Apply drop-connect masking and restore original weights where required.
 
 Parameters:
-- `network` - Network runtime owner.
+- `network` - Network being activated.
+- `runtimeNetwork` - Runtime activation internals.
+- `isTraining` - Training-time flag.
+- `stats` - Activation stats accumulator.
 
 Returns: Nothing.
 
-### createActivationStats
+### applyFallbackHiddenDropout
 
 ```ts
-createActivationStats(
-  totalConnections: number,
-): ActivationStats
+applyFallbackHiddenDropout(
+  hiddenNodes: default[],
+  runtimeNetwork: ActivateRuntimeNetworkProps,
+  dropoutProbability: number,
+  isTraining: boolean,
+  stats: ActivationStats,
+): void
 ```
 
-Create activation statistics container for the current pass.
+Apply fallback dropout for hidden nodes in raw node traversal mode.
 
 Parameters:
-- `totalConnections` - Number of network connections.
-
-Returns: Initialized activation stats object.
-
-### createWeightNoiseStats
-
-```ts
-createWeightNoiseStats(): WeightNoiseStats
-```
-
-Create the weight-noise statistics record with zeroed aggregates.
+- `hiddenNodes` - Hidden nodes.
+- `runtimeNetwork` - Runtime activation internals.
+- `dropoutProbability` - Dropout probability.
+- `isTraining` - Training-time flag.
+- `stats` - Activation stats accumulator.
 
-Returns: Zero-initialized weight-noise stats.
+Returns: Nothing.
 
-### applyTrainingWeightNoise
+### applyFallbackWeightNoise
 
 ```ts
-applyTrainingWeightNoise(
+applyFallbackWeightNoise(
   network: default,
   runtimeNetwork: ActivateRuntimeNetworkProps,
   isTraining: boolean,
-): WeightNoiseApplyResult
+): void
 ```
 
-Apply per-connection training noise for the main activation flow.
+Apply raw fallback weight noise to all connections using global standard deviation.
 
 Parameters:
 - `network` - Network being activated.
 - `runtimeNetwork` - Runtime activation internals.
 - `isTraining` - Training-time flag.
 
-Returns: Applied-state information for downstream restore logic.
+Returns: Nothing.
 
-### resolveDynamicWeightNoiseStd
+### applyHiddenLayerDropout
 
 ```ts
-resolveDynamicWeightNoiseStd(
+applyHiddenLayerDropout(
+  layer: default,
+  rawActivations: number[],
   runtimeNetwork: ActivateRuntimeNetworkProps,
-): number
+  dropoutProbability: number,
+  isTraining: boolean,
+  stats: ActivationStats,
+): void
 ```
 
-Resolve the training-step adjusted global weight-noise standard deviation.
+Apply dropout masks to hidden layer nodes and enforce at least one active node.
 
 Parameters:
+- `layer` - Hidden layer instance.
+- `rawActivations` - Raw layer activations.
 - `runtimeNetwork` - Runtime activation internals.
+- `dropoutProbability` - Layer dropout probability.
+- `isTraining` - Training-time flag.
+- `stats` - Activation stats accumulator.
 
-Returns: Effective weight-noise standard deviation for current training step.
+Returns: Nothing.
 
-### resolveConnectionNoiseStd
+### applyTrainingDropConnect
 
 ```ts
-resolveConnectionNoiseStd(
+applyTrainingDropConnect(
   network: default,
   runtimeNetwork: ActivateRuntimeNetworkProps,
-  connection: default,
-  fallbackStandardDeviation: number,
-): number
+  stats: ActivationStats,
+): void
 ```
 
-Resolve connection-specific weight-noise standard deviation, including per-hidden overrides.
+Apply training-time drop-connect masks to each connection.
 
 Parameters:
 - `network` - Network being activated.
 - `runtimeNetwork` - Runtime activation internals.
-- `connection` - Current connection.
-- `fallbackStandardDeviation` - Global fallback deviation.
+- `stats` - Activation stats accumulator.
 
-Returns: Effective standard deviation for this connection.
+Returns: Nothing.
 
-### findSourceLayerIndex
+### applyTrainingWeightNoise
 
 ```ts
-findSourceLayerIndex(
+applyTrainingWeightNoise(
   network: default,
-  connection: default,
-): number
+  runtimeNetwork: ActivateRuntimeNetworkProps,
+  isTraining: boolean,
+): WeightNoiseApplyResult
 ```
 
-Find the layer index containing a connection source node.
+Apply per-connection training noise for the main activation flow.
 
 Parameters:
 - `network` - Network being activated.
-- `connection` - Connection to inspect.
+- `runtimeNetwork` - Runtime activation internals.
+- `isTraining` - Training-time flag.
 
-Returns: Layer index for source node, or -1 when not found.
+Returns: Applied-state information for downstream restore logic.
 
-### updateStochasticDepthFromSchedule
+### collectHiddenNodes
 
 ```ts
-updateStochasticDepthFromSchedule(
-  runtimeNetwork: ActivateRuntimeNetworkProps,
-  isTraining: boolean,
-): void
+collectHiddenNodes(
+  nodes: default[],
+): default[]
 ```
 
-Update stochastic depth probabilities using a training schedule when valid.
+Collect hidden nodes from a raw node list.
 
 Parameters:
-- `runtimeNetwork` - Runtime activation internals.
-- `isTraining` - Training-time flag.
+- `nodes` - Network node collection.
 
-Returns: Nothing.
+Returns: Hidden-only node list.
 
 ### containsInvalidProbability
 
@@ -539,67 +585,60 @@ Parameters:
 
 Returns: True when one or more probabilities are invalid.
 
-### executeActivationPath
+### createActivationStats
 
 ```ts
-executeActivationPath(
-  network: default,
-  runtimeNetwork: ActivateRuntimeNetworkProps,
-  inputVector: number[],
-  isTraining: boolean,
-  outputBuffer: ActivationArray,
-  stats: ActivationStats,
-): void
+createActivationStats(
+  totalConnections: number,
+): ActivationStats
 ```
 
-Execute one of the three activation branches: stochastic layers, standard layers, or raw nodes.
+Create activation statistics container for the current pass.
 
 Parameters:
-- `network` - Network being activated.
-- `runtimeNetwork` - Runtime activation internals.
-- `inputVector` - Input vector.
-- `isTraining` - Training-time flag.
-- `outputBuffer` - Mutable output buffer.
-- `stats` - Activation stats accumulator.
+- `totalConnections` - Number of network connections.
 
-Returns: Nothing.
+Returns: Initialized activation stats object.
 
-### hasLayeredNetworkWithStochasticDepth
+### createWeightNoiseStats
 
 ```ts
-hasLayeredNetworkWithStochasticDepth(
-  network: default,
-  runtimeNetwork: ActivateRuntimeNetworkProps,
-): boolean
+createWeightNoiseStats(): WeightNoiseStats
 ```
 
-Check whether the network has layers and stochastic-depth configuration for layer skipping path.
+Create the weight-noise statistics record with zeroed aggregates.
 
-Parameters:
-- `network` - Network being activated.
-- `runtimeNetwork` - Runtime activation internals.
-
-Returns: True when stochastic-depth layer path should run.
+Returns: Zero-initialized weight-noise stats.
 
-### hasLayeredNetwork
+### decideLayerSkip
 
 ```ts
-hasLayeredNetwork(
+decideLayerSkip(
   network: default,
-): boolean
+  runtimeNetwork: ActivateRuntimeNetworkProps,
+  currentLayerNodeCount: number,
+  layerIndex: number,
+  isTraining: boolean,
+  previousLayerActivations: number[] | undefined,
+): { shouldSkipLayer: boolean; surviveProbability: number; }
 ```
 
-Check whether the network has at least one explicit layer.
+Decide whether a hidden layer should be skipped in stochastic-depth mode.
 
 Parameters:
 - `network` - Network being activated.
+- `runtimeNetwork` - Runtime activation internals.
+- `currentLayerNodeCount` - Number of nodes in current layer.
+- `layerIndex` - Current layer index.
+- `isTraining` - Training-time flag.
+- `previousLayerActivations` - Last computed layer activations.
 
-Returns: True when layered activation path should run.
+Returns: Skip decision and survival probability for the layer.
 
-### activateLayeredNetworkWithStochasticDepth
+### executeActivationPath
 
 ```ts
-activateLayeredNetworkWithStochasticDepth(
+executeActivationPath(
   network: default,
   runtimeNetwork: ActivateRuntimeNetworkProps,
   inputVector: number[],
@@ -609,7 +648,7 @@ activateLayeredNetworkWithStochasticDepth(
 ): void
 ```
 
-Run layered activation with stochastic-depth skipping and inverse-survival scaling.
+Execute one of the three activation branches: stochastic layers, standard layers, or raw nodes.
 
 Parameters:
 - `network` - Network being activated.
@@ -621,457 +660,363 @@ Parameters:
 
 Returns: Nothing.
 
-### decideLayerSkip
+### finalizeNodePathWeightNoiseRestore
 
 ```ts
-decideLayerSkip(
+finalizeNodePathWeightNoiseRestore(
   network: default,
-  runtimeNetwork: ActivateRuntimeNetworkProps,
-  currentLayerNodeCount: number,
-  layerIndex: number,
   isTraining: boolean,
-  previousLayerActivations: number[] | undefined,
-): { shouldSkipLayer: boolean; surviveProbability: number; }
+  appliedWeightNoise: boolean,
+): void
 ```
 
-Decide whether a hidden layer should be skipped in stochastic-depth mode.
+Restore temporary weight-noise values for fallback node path only.
 
 Parameters:
 - `network` - Network being activated.
-- `runtimeNetwork` - Runtime activation internals.
-- `currentLayerNodeCount` - Number of nodes in current layer.
-- `layerIndex` - Current layer index.
 - `isTraining` - Training-time flag.
-- `previousLayerActivations` - Last computed layer activations.
-
-Returns: Skip decision and survival probability for the layer.
-
-### isHiddenLayer
-
-```ts
-isHiddenLayer(
-  layerIndex: number,
-  totalLayerCount: number,
-): boolean
-```
-
-Check whether a layer index refers to a hidden layer in a layered network.
-
-Parameters:
-- `layerIndex` - Current layer index.
-- `totalLayerCount` - Number of layers in the network.
-
-Returns: True when the layer is hidden.
-
-### hasCompatibleSkipState
-
-```ts
-hasCompatibleSkipState(
-  previousLayerActivations: number[] | undefined,
-  currentLayerNodeCount: number,
-): boolean
-```
-
-Validate whether previous activations can be reused as skip pass-through output.
-
-Parameters:
-- `previousLayerActivations` - Last computed layer activations.
-- `currentLayerNodeCount` - Current layer node count.
+- `appliedWeightNoise` - Whether weight noise was applied during this pass.
 
-Returns: True when pass-through activations are compatible.
+Returns: Nothing.
 
-### activateLayer
+### finalizeTrainingStepAndStats
 
 ```ts
-activateLayer(
-  currentLayer: default,
-  layerIndex: number,
-  inputVector: number[],
+finalizeTrainingStepAndStats(
+  runtimeNetwork: ActivateRuntimeNetworkProps,
+  stats: ActivationStats,
   isTraining: boolean,
-): number[]
+): void
 ```
 
-Activate one layer, routing input only for the first layer.
+Finalize training counters and attach activation statistics to runtime state.
 
 Parameters:
-- `currentLayer` - Layer instance to activate.
-- `layerIndex` - Layer index.
-- `inputVector` - Network input vector.
+- `runtimeNetwork` - Runtime activation internals.
+- `stats` - Activation stats.
 - `isTraining` - Training-time flag.
 
-Returns: Layer activations.
+Returns: Nothing.
 
-### recordSkippedLayer
+### findSourceLayerIndex
 
 ```ts
-recordSkippedLayer(
+findSourceLayerIndex(
   network: default,
-  stats: ActivationStats,
-  layerIndex: number,
-): void
+  connection: default,
+): number
 ```
 
-Record a skipped layer in runtime and stats trackers.
+Find the layer index containing a connection source node.
 
 Parameters:
 - `network` - Network being activated.
-- `stats` - Activation stats accumulator.
-- `layerIndex` - Skipped layer index.
+- `connection` - Connection to inspect.
 
-Returns: Nothing.
+Returns: Layer index for source node, or -1 when not found.
 
-### scaleActivations
+### gaussianRand
 
 ```ts
-scaleActivations(
-  activations: number[],
-  scaleFactor: number,
-): number[]
+gaussianRand(
+  rng: () => number,
+): number
 ```
 
-Create a new activation vector by multiplying each activation by a scale factor.
+Produce a normally distributed random sample using the Box-Muller transform.
 
 Parameters:
-- `activations` - Source activation vector.
-- `scaleFactor` - Multiplicative scale factor.
+- `rng` - Pseudo-random source in the interval [0, 1).
 
-Returns: Scaled activation vector.
+Returns: Standard normal sample with mean 0 and variance 1.
 
-### writeLayerActivationsToOutput
+### hasCompatibleSkipState
 
 ```ts
-writeLayerActivationsToOutput(
-  layerActivations: number[] | undefined,
-  outputBuffer: ActivationArray,
-  outputSize: number,
-): void
+hasCompatibleSkipState(
+  previousLayerActivations: number[] | undefined,
+  currentLayerNodeCount: number,
+): boolean
 ```
 
-Copy final layer activations into the pooled network output buffer.
+Validate whether previous activations can be reused as skip pass-through output.
 
 Parameters:
-- `layerActivations` - Final layer activations.
-- `outputBuffer` - Mutable output buffer.
-- `outputSize` - Maximum output width.
+- `previousLayerActivations` - Last computed layer activations.
+- `currentLayerNodeCount` - Current layer node count.
 
-Returns: Nothing.
+Returns: True when pass-through activations are compatible.
 
-### activateLayeredNetworkWithDropout
+### hasLayeredNetwork
 
 ```ts
-activateLayeredNetworkWithDropout(
+hasLayeredNetwork(
   network: default,
-  runtimeNetwork: ActivateRuntimeNetworkProps,
-  inputVector: number[],
-  isTraining: boolean,
-  outputBuffer: ActivationArray,
-  stats: ActivationStats,
-): void
+): boolean
 ```
 
-Run layered activation with dropout masks and no stochastic-depth skips.
+Check whether the network has at least one explicit layer.
 
 Parameters:
 - `network` - Network being activated.
-- `runtimeNetwork` - Runtime activation internals.
-- `inputVector` - Input vector.
-- `isTraining` - Training-time flag.
-- `outputBuffer` - Mutable output buffer.
-- `stats` - Activation stats accumulator.
 
-Returns: Nothing.
+Returns: True when layered activation path should run.
 
-### applyHiddenLayerDropout
+### hasLayeredNetworkWithStochasticDepth
 
 ```ts
-applyHiddenLayerDropout(
-  layer: default,
-  rawActivations: number[],
+hasLayeredNetworkWithStochasticDepth(
+  network: default,
   runtimeNetwork: ActivateRuntimeNetworkProps,
-  dropoutProbability: number,
-  isTraining: boolean,
-  stats: ActivationStats,
-): void
+): boolean
 ```
 
-Apply dropout masks to hidden layer nodes and enforce at least one active node.
+Check whether the network has layers and stochastic-depth configuration for layer skipping path.
 
 Parameters:
-- `layer` - Hidden layer instance.
-- `rawActivations` - Raw layer activations.
+- `network` - Network being activated.
 - `runtimeNetwork` - Runtime activation internals.
-- `dropoutProbability` - Layer dropout probability.
-- `isTraining` - Training-time flag.
-- `stats` - Activation stats accumulator.
 
-Returns: Nothing.
+Returns: True when stochastic-depth layer path should run.
 
-### setAllMasksToOne
+### hasOriginalWeightNoise
 
 ```ts
-setAllMasksToOne(
-  nodes: default[],
-): void
+hasOriginalWeightNoise(
+  connection: default,
+): boolean
 ```
 
-Set mask value to one for every node in a layer.
+Check whether a connection already has an original weight-noise snapshot.
 
 Parameters:
-- `nodes` - Layer nodes to normalize.
+- `connection` - Connection to inspect.
 
-Returns: Nothing.
+Returns: True when snapshot exists.
 
-### activateNodeNetworkFallback
+### isHiddenLayer
 
 ```ts
-activateNodeNetworkFallback(
-  network: default,
-  runtimeNetwork: ActivateRuntimeNetworkProps,
-  inputVector: number[],
-  isTraining: boolean,
-  outputBuffer: ActivationArray,
-  stats: ActivationStats,
-): void
+isHiddenLayer(
+  layerIndex: number,
+  totalLayerCount: number,
+): boolean
 ```
 
-Run fallback node-by-node activation for networks without explicit layer definitions.
+Check whether a layer index refers to a hidden layer in a layered network.
 
 Parameters:
-- `network` - Network being activated.
-- `runtimeNetwork` - Runtime activation internals.
-- `inputVector` - Input vector.
-- `isTraining` - Training-time flag.
-- `outputBuffer` - Mutable output buffer.
-- `stats` - Activation stats accumulator.
+- `layerIndex` - Current layer index.
+- `totalLayerCount` - Number of layers in the network.
 
-Returns: Nothing.
+Returns: True when the layer is hidden.
 
-### collectHiddenNodes
+### persistOriginalWeightNoise
 
 ```ts
-collectHiddenNodes(
-  nodes: default[],
-): default[]
+persistOriginalWeightNoise(
+  connection: default,
+): void
 ```
 
-Collect hidden nodes from a raw node list.
+Store current connection weight before applying temporary weight-noise modifications.
 
 Parameters:
-- `nodes` - Network node collection.
+- `connection` - Connection to persist.
 
-Returns: Hidden-only node list.
+Returns: Nothing.
 
-### applyFallbackHiddenDropout
+### prepareTopologyForActivation
 
 ```ts
-applyFallbackHiddenDropout(
-  hiddenNodes: default[],
+prepareTopologyForActivation(
   runtimeNetwork: ActivateRuntimeNetworkProps,
-  dropoutProbability: number,
-  isTraining: boolean,
-  stats: ActivationStats,
 ): void
 ```
 
-Apply fallback dropout for hidden nodes in raw node traversal mode.
+Ensure topological order is refreshed before activation when acyclic mode requires it.
 
 Parameters:
-- `hiddenNodes` - Hidden nodes.
 - `runtimeNetwork` - Runtime activation internals.
-- `dropoutProbability` - Dropout probability.
-- `isTraining` - Training-time flag.
-- `stats` - Activation stats accumulator.
 
 Returns: Nothing.
 
-### applyFallbackWeightNoise
+### recordSkippedLayer
 
 ```ts
-applyFallbackWeightNoise(
+recordSkippedLayer(
   network: default,
-  runtimeNetwork: ActivateRuntimeNetworkProps,
-  isTraining: boolean,
+  stats: ActivationStats,
+  layerIndex: number,
 ): void
 ```
 
-Apply raw fallback weight noise to all connections using global standard deviation.
+Record a skipped layer in runtime and stats trackers.
 
 Parameters:
 - `network` - Network being activated.
-- `runtimeNetwork` - Runtime activation internals.
-- `isTraining` - Training-time flag.
+- `stats` - Activation stats accumulator.
+- `layerIndex` - Skipped layer index.
 
 Returns: Nothing.
 
-### activateNodesAndCollectOutputs
+### releaseBufferAndCreateResult
 
 ```ts
-activateNodesAndCollectOutputs(
-  nodes: default[],
-  inputVector: number[],
+releaseBufferAndCreateResult(
   outputBuffer: ActivationArray,
-): void
+): number[]
 ```
 
-Activate raw nodes in order and collect output-node activations into output buffer.
+Release pooled output buffer and return a detached plain array copy.
 
 Parameters:
-- `nodes` - Network nodes in activation order.
-- `inputVector` - Input vector.
-- `outputBuffer` - Mutable output buffer.
+- `outputBuffer` - Mutable pooled output buffer.
 
-Returns: Nothing.
+Returns: Plain array of output values.
 
-### applyDropConnect
+### resetSkippedLayers
 
 ```ts
-applyDropConnect(
+resetSkippedLayers(
   network: default,
-  runtimeNetwork: ActivateRuntimeNetworkProps,
-  isTraining: boolean,
-  stats: ActivationStats,
 ): void
 ```
 
-Apply drop-connect masking and restore original weights where required.
+Clear the runtime list of skipped layers before current activation pass.
 
 Parameters:
-- `network` - Network being activated.
-- `runtimeNetwork` - Runtime activation internals.
-- `isTraining` - Training-time flag.
-- `stats` - Activation stats accumulator.
+- `network` - Network runtime owner.
 
 Returns: Nothing.
 
-### applyTrainingDropConnect
+### resolveConnectionNoiseStd
 
 ```ts
-applyTrainingDropConnect(
+resolveConnectionNoiseStd(
   network: default,
   runtimeNetwork: ActivateRuntimeNetworkProps,
-  stats: ActivationStats,
-): void
+  connection: default,
+  fallbackStandardDeviation: number,
+): number
 ```
 
-Apply training-time drop-connect masks to each connection.
+Resolve connection-specific weight-noise standard deviation, including per-hidden overrides.
 
 Parameters:
 - `network` - Network being activated.
 - `runtimeNetwork` - Runtime activation internals.
-- `stats` - Activation stats accumulator.
+- `connection` - Current connection.
+- `fallbackStandardDeviation` - Global fallback deviation.
 
-Returns: Nothing.
+Returns: Effective standard deviation for this connection.
 
-### restoreDropConnectWeights
+### resolveDynamicWeightNoiseStd
 
 ```ts
-restoreDropConnectWeights(
-  network: default,
-): void
+resolveDynamicWeightNoiseStd(
+  runtimeNetwork: ActivateRuntimeNetworkProps,
+): number
 ```
 
-Restore drop-connect modified weights and normalize all masks back to one.
+Resolve the training-step adjusted global weight-noise standard deviation.
 
 Parameters:
-- `network` - Network being activated.
+- `runtimeNetwork` - Runtime activation internals.
 
-Returns: Nothing.
+Returns: Effective weight-noise standard deviation for current training step.
 
-### finalizeNodePathWeightNoiseRestore
+### restoreDropConnectWeights
 
 ```ts
-finalizeNodePathWeightNoiseRestore(
+restoreDropConnectWeights(
   network: default,
-  isTraining: boolean,
-  appliedWeightNoise: boolean,
 ): void
 ```
 
-Restore temporary weight-noise values for fallback node path only.
+Restore drop-connect modified weights and normalize all masks back to one.
 
 Parameters:
 - `network` - Network being activated.
-- `isTraining` - Training-time flag.
-- `appliedWeightNoise` - Whether weight noise was applied during this pass.
 
 Returns: Nothing.
 
-### finalizeTrainingStepAndStats
+### restoreOriginalDropConnectWeight
 
 ```ts
-finalizeTrainingStepAndStats(
-  runtimeNetwork: ActivateRuntimeNetworkProps,
-  stats: ActivationStats,
-  isTraining: boolean,
+restoreOriginalDropConnectWeight(
+  connection: default,
 ): void
 ```
 
-Finalize training counters and attach activation statistics to runtime state.
-
-Parameters:
-- `runtimeNetwork` - Runtime activation internals.
-- `stats` - Activation stats.
-- `isTraining` - Training-time flag.
+Restore and clear original connection weight after drop-connect.
+
+Parameters:
+- `connection` - Connection to restore.
 
 Returns: Nothing.
 
-### releaseBufferAndCreateResult
+### restoreOriginalWeightNoise
 
 ```ts
-releaseBufferAndCreateResult(
-  outputBuffer: ActivationArray,
-): number[]
+restoreOriginalWeightNoise(
+  connection: default,
+): void
 ```
 
-Release pooled output buffer and return a detached plain array copy.
+Restore and clear the original weight-noise snapshot for a connection.
 
 Parameters:
-- `outputBuffer` - Mutable pooled output buffer.
+- `connection` - Connection to restore.
 
-Returns: Plain array of output values.
+Returns: Nothing.
 
-### hasOriginalWeightNoise
+### scaleActivations
 
 ```ts
-hasOriginalWeightNoise(
-  connection: default,
-): boolean
+scaleActivations(
+  activations: number[],
+  scaleFactor: number,
+): number[]
 ```
 
-Check whether a connection already has an original weight-noise snapshot.
+Create a new activation vector by multiplying each activation by a scale factor.
 
 Parameters:
-- `connection` - Connection to inspect.
+- `activations` - Source activation vector.
+- `scaleFactor` - Multiplicative scale factor.
 
-Returns: True when snapshot exists.
+Returns: Scaled activation vector.
 
-### persistOriginalWeightNoise
+### setAllMasksToOne
 
 ```ts
-persistOriginalWeightNoise(
-  connection: default,
+setAllMasksToOne(
+  nodes: default[],
 ): void
 ```
 
-Store current connection weight before applying temporary weight-noise modifications.
+Set mask value to one for every node in a layer.
 
 Parameters:
-- `connection` - Connection to persist.
+- `nodes` - Layer nodes to normalize.
 
 Returns: Nothing.
 
-### restoreOriginalWeightNoise
+### setDropConnectMask
 
 ```ts
-restoreOriginalWeightNoise(
+setDropConnectMask(
   connection: default,
+  dropConnectMask: number,
 ): void
 ```
 
-Restore and clear the original weight-noise snapshot for a connection.
+Set drop-connect mask value for a connection.
 
 Parameters:
-- `connection` - Connection to restore.
+- `connection` - Connection to annotate.
+- `dropConnectMask` - Drop-connect mask value.
 
 Returns: Nothing.
 
@@ -1092,102 +1037,109 @@ Parameters:
 
 Returns: Nothing.
 
-### setDropConnectMask
+### stashOriginalDropConnectWeight
 
 ```ts
-setDropConnectMask(
+stashOriginalDropConnectWeight(
   connection: default,
-  dropConnectMask: number,
 ): void
 ```
 
-Set drop-connect mask value for a connection.
+Store original connection weight before drop-connect zeroing.
 
 Parameters:
-- `connection` - Connection to annotate.
-- `dropConnectMask` - Drop-connect mask value.
+- `connection` - Connection to persist.
 
 Returns: Nothing.
 
-### stashOriginalDropConnectWeight
+### tryFastSlabActivation
 
 ```ts
-stashOriginalDropConnectWeight(
-  connection: default,
-): void
+tryFastSlabActivation(
+  runtimeNetwork: ActivateRuntimeNetworkProps,
+  inputVector: number[],
+  isTraining: boolean,
+): number[] | undefined
 ```
 
-Store original connection weight before drop-connect zeroing.
+Attempt fast slab activation and safely fall back to regular activation on failure.
 
 Parameters:
-- `connection` - Connection to persist.
+- `runtimeNetwork` - Runtime activation internals.
+- `inputVector` - Input vector.
+- `isTraining` - Training-time flag.
 
-Returns: Nothing.
+Returns: Fast slab output when available, otherwise undefined.
 
-### restoreOriginalDropConnectWeight
+### updateStochasticDepthFromSchedule
 
 ```ts
-restoreOriginalDropConnectWeight(
-  connection: default,
+updateStochasticDepthFromSchedule(
+  runtimeNetwork: ActivateRuntimeNetworkProps,
+  isTraining: boolean,
 ): void
 ```
 
-Restore and clear original connection weight after drop-connect.
+Update stochastic depth probabilities using a training schedule when valid.
 
 Parameters:
-- `connection` - Connection to restore.
+- `runtimeNetwork` - Runtime activation internals.
+- `isTraining` - Training-time flag.
 
 Returns: Nothing.
 
-## architecture/network/activate/network.activate.batch.utils.ts
-
-### executeBatchActivation
+### validateInputVector
 
 ```ts
-executeBatchActivation(
-  activationContext: BatchActivationContext,
-): number[][]
+validateInputVector(
+  network: default,
+  inputVector: number[],
+): void
 ```
 
-Execute mini-batch activation with top-level shape validation and per-row checks.
-
-The orchestration keeps behavior deterministic by validating the container first,
-then validating each row before delegating to the core network activation function.
+Validate that the incoming input vector exists and matches expected input size.
 
 Parameters:
-- `activationContext` - - Shared batch activation state.
+- `network` - Network being activated.
+- `inputVector` - Input vector to validate.
 
-Returns: Matrix of activation outputs.
+Returns: Nothing.
 
-### assertBatchInputCollection
+### validateNetworkNodes
 
 ```ts
-assertBatchInputCollection(
-  batchInputs: number[][],
+validateNetworkNodes(
+  network: default,
 ): void
 ```
 
-Validate that the batch input collection is an array of rows.
+Assert that the network contains nodes before executing activation routines.
 
 Parameters:
-- `batchInputs` - - Candidate batch input collection.
+- `network` - Network being activated.
 
 Returns: Nothing.
 
-### activateValidatedBatchRows
+### writeLayerActivationsToOutput
 
 ```ts
-activateValidatedBatchRows(
-  activationContext: BatchActivationContext,
-): number[][]
+writeLayerActivationsToOutput(
+  layerActivations: number[] | undefined,
+  outputBuffer: ActivationArray,
+  outputSize: number,
+): void
 ```
 
-Activate each row in a validated batch matrix.
+Copy final layer activations into the pooled network output buffer.
 
 Parameters:
-- `activationContext` - - Shared batch activation state.
+- `layerActivations` - Final layer activations.
+- `outputBuffer` - Mutable output buffer.
+- `outputSize` - Maximum output width.
 
-Returns: Matrix of activation outputs.
+Returns: Nothing.
+
+## architecture/network/activate/network.activate.batch.utils.ts
 
 ### activateSingleBatchRow
 
@@ -1204,35 +1156,50 @@ Parameters:
 
 Returns: Activation output vector for the row.
 
-### assertBatchRowInputSize
+### activateValidatedBatchRows
 
 ```ts
-assertBatchRowInputSize(
-  rowActivationContext: BatchRowActivationContext,
+activateValidatedBatchRows(
+  activationContext: BatchActivationContext,
+): number[][]
+```
+
+Activate each row in a validated batch matrix.
+
+Parameters:
+- `activationContext` - - Shared batch activation state.
+
+Returns: Matrix of activation outputs.
+
+### assertBatchInputCollection
+
+```ts
+assertBatchInputCollection(
+  batchInputs: number[][],
 ): void
 ```
 
-Validate one batch row dimensionality.
+Validate that the batch input collection is an array of rows.
 
 Parameters:
-- `rowActivationContext` - - Shared state for one batch-row activation.
+- `batchInputs` - - Candidate batch input collection.
 
 Returns: Nothing.
 
-### isBatchRowInputSizeValid
+### assertBatchRowInputSize
 
 ```ts
-isBatchRowInputSizeValid(
+assertBatchRowInputSize(
   rowActivationContext: BatchRowActivationContext,
-): boolean
+): void
 ```
 
-Determine whether one batch row matches the expected input dimensionality.
+Validate one batch row dimensionality.
 
 Parameters:
 - `rowActivationContext` - - Shared state for one batch-row activation.
 
-Returns: True when row size is valid.
+Returns: Nothing.
 
 ### buildBatchRowInputSizeMismatchMessage
 
@@ -1249,76 +1216,74 @@ Parameters:
 
 Returns: Formatted error message for invalid row dimensionality.
 
-### formatInputLengthForMessage
+### executeBatchActivation
 
 ```ts
-formatInputLengthForMessage(
-  inputVector: number[],
-): string
+executeBatchActivation(
+  activationContext: BatchActivationContext,
+): number[][]
 ```
 
-Convert input length into a display-safe string for error messaging.
+Execute mini-batch activation with top-level shape validation and per-row checks.
 
-Parameters:
-- `inputVector` - - Candidate batch row input vector.
+The orchestration keeps behavior deterministic by validating the container first,
+then validating each row before delegating to the core network activation function.
 
-Returns: Numeric length as string or predefined undefined text.
+Parameters:
+- `activationContext` - - Shared batch activation state.
 
-## architecture/network/activate/network.activate.helpers.utils.ts
+Returns: Matrix of activation outputs.
 
-### executeNoTraceActivation
+### formatInputLengthForMessage
 
 ```ts
-executeNoTraceActivation(
-  activationContext: NoTraceActivationContext,
-): number[]
+formatInputLengthForMessage(
+  inputVector: number[],
+): string
 ```
 
-Execute no-trace activation with a fast-path attempt and deterministic fallback traversal.
-
-The orchestration follows a strict sequence: refresh order guarantees, validate input shape,
-try fast slab inference, then compute outputs through node traversal when needed.
+Convert input length into a display-safe string for error messaging.
 
 Parameters:
-- `activationContext` - - Shared no-trace activation state.
+- `inputVector` - - Candidate batch row input vector.
 
-Returns: Output activation vector detached from pooled storage.
+Returns: Numeric length as string or predefined undefined text.
 
-### executeRawActivation
+### isBatchRowInputSizeValid
 
 ```ts
-executeRawActivation(
-  activationContext: RawActivationContext,
-): number[]
+isBatchRowInputSizeValid(
+  rowActivationContext: BatchRowActivationContext,
+): boolean
 ```
 
-Execute raw activation through the network delegate using a compact orchestration flow.
-
-This helper keeps the exported activation method focused on context creation while this
-module owns the execution path and future branching behavior.
+Determine whether one batch row matches the expected input dimensionality.
 
 Parameters:
-- `activationContext` - - Shared raw activation state.
+- `rowActivationContext` - - Shared state for one batch-row activation.
 
-Returns: Activation output vector from the network delegate.
+Returns: True when row size is valid.
 
-### executeBatchActivation
+## architecture/network/activate/network.activate.helpers.utils.ts
+
+### createBatchActivationContext
 
 ```ts
-executeBatchActivation(
-  activationContext: BatchActivationContext,
-): number[][]
+createBatchActivationContext(
+  network: default,
+  batchInputs: number[][],
+  isTraining: boolean,
+): BatchActivationContext
 ```
 
-Execute mini-batch activation with top-level shape validation and per-row checks.
-
-The orchestration keeps behavior deterministic by validating the container first,
-then validating each row before delegating to the core network activation function.
+Build shared batch activation context for helper orchestration.
 
 Parameters:
-- `activationContext` - - Shared batch activation state.
+- `network` - - Network instance bound to the activation call.
+- `batchInputs` - - Input matrix supplied by the caller.
+- `isTraining` - - Whether activation should retain training traces.
 
-Returns: Matrix of activation outputs.
+Returns: Fully populated batch activation context.
 
 ### createNoTraceActivationContext
 
@@ -1358,26 +1323,23 @@ Parameters:
 
 Returns: Fully populated raw activation context.
 
-### createBatchActivationContext
+### executeBatchActivation
 
 ```ts
-createBatchActivationContext(
-  network: default,
-  batchInputs: number[][],
-  isTraining: boolean,
-): BatchActivationContext
+executeBatchActivation(
+  activationContext: BatchActivationContext,
+): number[][]
 ```
 
-Build shared batch activation context for helper orchestration.
+Execute mini-batch activation with top-level shape validation and per-row checks.
 
-Parameters:
-- `network` - - Network instance bound to the activation call.
-- `batchInputs` - - Input matrix supplied by the caller.
-- `isTraining` - - Whether activation should retain training traces.
+The orchestration keeps behavior deterministic by validating the container first,
+then validating each row before delegating to the core network activation function.
 
-Returns: Fully populated batch activation context.
+Parameters:
+- `activationContext` - - Shared batch activation state.
 
-## architecture/network/activate/network.activate.notrace.utils.ts
+Returns: Matrix of activation outputs.
 
 ### executeNoTraceActivation
 
@@ -1397,20 +1359,40 @@ Parameters:
 
 Returns: Output activation vector detached from pooled storage.
 
-### refreshTopologicalOrderWhenRequired
+### executeRawActivation
 
 ```ts
-refreshTopologicalOrderWhenRequired(
+executeRawActivation(
+  activationContext: RawActivationContext,
+): number[]
+```
+
+Execute raw activation through the network delegate using a compact orchestration flow.
+
+This helper keeps the exported activation method focused on context creation while this
+module owns the execution path and future branching behavior.
+
+Parameters:
+- `activationContext` - - Shared raw activation state.
+
+Returns: Activation output vector from the network delegate.
+
+## architecture/network/activate/network.activate.notrace.utils.ts
+
+### activateWithoutTraceUsingNodeIteration
+
+```ts
+activateWithoutTraceUsingNodeIteration(
   activationContext: NoTraceActivationContext,
-): void
+): number[]
 ```
 
-Refresh cached topological order when acyclic mode is active and marked dirty.
+Execute no-trace activation through node traversal and pooled output collection.
 
 Parameters:
 - `activationContext` - - Shared no-trace activation state.
 
-Returns: Nothing.
+Returns: Detached output activation vector.
 
 ### assertInputMatchesNetworkInputSize
 
@@ -1427,35 +1409,68 @@ Parameters:
 
 Returns: Nothing.
 
-### isInputVectorLengthValid
+### buildInputSizeMismatchMessage
 
 ```ts
-isInputVectorLengthValid(
+buildInputSizeMismatchMessage(
+  activationContext: NoTraceActivationContext,
+): string
+```
+
+Build a descriptive input mismatch message for activation validation errors.
+
+Parameters:
+- `activationContext` - - Shared no-trace activation state.
+
+Returns: Formatted mismatch error message.
+
+### canUseNoTraceFastSlab
+
+```ts
+canUseNoTraceFastSlab(
   activationContext: NoTraceActivationContext,
 ): boolean
 ```
 
-Check whether the input vector has a valid length for activation.
+Determine whether fast slab activation is available for no-trace execution mode.
 
 Parameters:
 - `activationContext` - - Shared no-trace activation state.
 
-Returns: True when the input vector is an array with expected length.
+Returns: True when slab execution is available for inference mode.
 
-### buildInputSizeMismatchMessage
+### detachPooledOutputBuffer
 
 ```ts
-buildInputSizeMismatchMessage(
+detachPooledOutputBuffer(
+  pooledOutputBuffer: ActivationArray,
+): number[]
+```
+
+Clone pooled output storage into a detached plain array.
+
+Parameters:
+- `pooledOutputBuffer` - - Pooled activation output storage.
+
+Returns: Detached output activation vector.
+
+### executeNoTraceActivation
+
+```ts
+executeNoTraceActivation(
   activationContext: NoTraceActivationContext,
-): string
+): number[]
 ```
 
-Build a descriptive input mismatch message for activation validation errors.
+Execute no-trace activation with a fast-path attempt and deterministic fallback traversal.
+
+The orchestration follows a strict sequence: refresh order guarantees, validate input shape,
+try fast slab inference, then compute outputs through node traversal when needed.
 
 Parameters:
 - `activationContext` - - Shared no-trace activation state.
 
-Returns: Formatted mismatch error message.
+Returns: Output activation vector detached from pooled storage.
 
 ### formatInputLengthForMessage
 
@@ -1472,67 +1487,71 @@ Parameters:
 
 Returns: Numeric length as string or predefined undefined text.
 
-### tryActivateWithFastSlab
+### isInputVectorLengthValid
 
 ```ts
-tryActivateWithFastSlab(
+isInputVectorLengthValid(
   activationContext: NoTraceActivationContext,
-): number[] | null
+): boolean
 ```
 
-Attempt fast slab activation and return null when slab execution is unavailable or fails.
+Check whether the input vector has a valid length for activation.
 
 Parameters:
 - `activationContext` - - Shared no-trace activation state.
 
-Returns: Fast slab output when successful, otherwise null.
+Returns: True when the input vector is an array with expected length.
 
-### canUseNoTraceFastSlab
+### refreshTopologicalOrderWhenRequired
 
 ```ts
-canUseNoTraceFastSlab(
+refreshTopologicalOrderWhenRequired(
   activationContext: NoTraceActivationContext,
-): boolean
+): void
 ```
 
-Determine whether fast slab activation is available for no-trace execution mode.
+Refresh cached topological order when acyclic mode is active and marked dirty.
 
 Parameters:
 - `activationContext` - - Shared no-trace activation state.
 
-Returns: True when slab execution is available for inference mode.
+Returns: Nothing.
 
-### activateWithoutTraceUsingNodeIteration
+### tryActivateWithFastSlab
 
 ```ts
-activateWithoutTraceUsingNodeIteration(
+tryActivateWithFastSlab(
   activationContext: NoTraceActivationContext,
-): number[]
+): number[] | null
 ```
 
-Execute no-trace activation through node traversal and pooled output collection.
+Attempt fast slab activation and return null when slab execution is unavailable or fails.
 
 Parameters:
 - `activationContext` - - Shared no-trace activation state.
 
-Returns: Detached output activation vector.
+Returns: Fast slab output when successful, otherwise null.
 
-### detachPooledOutputBuffer
+## architecture/network/activate/network.activate.contexts.utils.ts
+
+### createBatchActivationContext
 
 ```ts
-detachPooledOutputBuffer(
-  pooledOutputBuffer: ActivationArray,
-): number[]
+createBatchActivationContext(
+  network: default,
+  batchInputs: number[][],
+  isTraining: boolean,
+): BatchActivationContext
 ```
 
-Clone pooled output storage into a detached plain array.
+Build shared batch activation context for helper orchestration.
 
 Parameters:
-- `pooledOutputBuffer` - - Pooled activation output storage.
-
-Returns: Detached output activation vector.
+- `network` - - Network instance bound to the activation call.
+- `batchInputs` - - Input matrix supplied by the caller.
+- `isTraining` - - Whether activation should retain training traces.
 
-## architecture/network/activate/network.activate.contexts.utils.ts
+Returns: Fully populated batch activation context.
 
 ### createNoTraceActivationContext
 
@@ -1572,25 +1591,6 @@ Parameters:
 
 Returns: Fully populated raw activation context.
 
-### createBatchActivationContext
-
-```ts
-createBatchActivationContext(
-  network: default,
-  batchInputs: number[][],
-  isTraining: boolean,
-): BatchActivationContext
-```
-
-Build shared batch activation context for helper orchestration.
-
-Parameters:
-- `network` - - Network instance bound to the activation call.
-- `batchInputs` - - Input matrix supplied by the caller.
-- `isTraining` - - Whether activation should retain training traces.
-
-Returns: Fully populated batch activation context.
-
 ### toNetworkInternals
 
 ```ts
@@ -1608,24 +1608,51 @@ Returns: Network internals view used by activation helper modules.
 
 ## architecture/network/activate/network.activate.notrace.traversal.utils.ts
 
-### populatePooledOutputBufferFromNodes
+### activateHiddenNode
 
 ```ts
-populatePooledOutputBufferFromNodes(
-  traversalContext: NoTraceNodeTraversalContext,
+activateHiddenNode(
+  networkNode: default,
 ): void
 ```
 
-Traverse nodes in activation order and write output activations into pooled storage.
+Activate a hidden node without trace bookkeeping.
 
-This helper isolates traversal concerns from no-trace orchestration so the main flow
-can remain focused on high-level activation phases.
+Parameters:
+- `networkNode` - - Hidden-role node to activate.
+
+Returns: Nothing.
+
+### activateInputNode
+
+```ts
+activateInputNode(
+  activationContext: SingleNodeNoTraceActivationContext,
+): void
+```
+
+Activate an input node using the matching input vector value.
 
 Parameters:
-- `traversalContext` - - Inputs required to process each node and collect outputs.
+- `activationContext` - - Node-specific activation state.
 
 Returns: Nothing.
 
+### activateOutputNodeAndAdvanceIndex
+
+```ts
+activateOutputNodeAndAdvanceIndex(
+  activationContext: SingleNodeNoTraceActivationContext,
+): number
+```
+
+Activate an output node, write the activation value, and advance the output index.
+
+Parameters:
+- `activationContext` - - Node-specific activation state.
+
+Returns: Next output write index.
+
 ### activateSingleNodeWithoutTrace
 
 ```ts
@@ -1671,47 +1698,20 @@ Parameters:
 
 Returns: True when node role is output.
 
-### activateInputNode
+### populatePooledOutputBufferFromNodes
 
 ```ts
-activateInputNode(
-  activationContext: SingleNodeNoTraceActivationContext,
+populatePooledOutputBufferFromNodes(
+  traversalContext: NoTraceNodeTraversalContext,
 ): void
 ```
 
-Activate an input node using the matching input vector value.
-
-Parameters:
-- `activationContext` - - Node-specific activation state.
-
-Returns: Nothing.
-
-### activateOutputNodeAndAdvanceIndex
-
-```ts
-activateOutputNodeAndAdvanceIndex(
-  activationContext: SingleNodeNoTraceActivationContext,
-): number
-```
-
-Activate an output node, write the activation value, and advance the output index.
-
-Parameters:
-- `activationContext` - - Node-specific activation state.
-
-Returns: Next output write index.
-
-### activateHiddenNode
-
-```ts
-activateHiddenNode(
-  networkNode: default,
-): void
-```
+Traverse nodes in activation order and write output activations into pooled storage.
 
-Activate a hidden node without trace bookkeeping.
+This helper isolates traversal concerns from no-trace orchestration so the main flow
+can remain focused on high-level activation phases.
 
 Parameters:
-- `networkNode` - - Hidden-role node to activate.
+- `traversalContext` - - Inputs required to process each node and collect outputs.
 
 Returns: Nothing.