@reicek/neataptic-ts 0.1.25 → 0.1.26

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

@@ -12,89 +12,89 @@ high-level control surface for mutation flow.
 
 ## architecture/network/mutate/network.mutate.utils.types.ts
 
-### NODE_TYPE_INPUT
-
-Canonical node-type literal for input nodes.
-
-### NODE_TYPE_OUTPUT
+### BATCH_NORM_FLAG_KEY
 
-Canonical node-type literal for output nodes.
+Internal node field used to enable batch normalization.
 
-### NODE_TYPE_HIDDEN
+### DEFAULT_MUTATION_MAX
 
-Canonical node-type literal for hidden nodes.
+Default maximum mutation value when no method override is provided.
 
-### RECURRENT_BLOCK_LSTM
+### DEFAULT_MUTATION_MIN
 
-Canonical recurrent block literal for LSTM expansion.
+Default minimum mutation value when no method override is provided.
 
-### RECURRENT_BLOCK_GRU
+### ERROR_NO_MUTATE_METHOD
 
-Canonical recurrent block literal for GRU expansion.
+Error emitted when mutate is called without a valid method.
 
-### SINGLE_UNIT_RECURRENT_BLOCK_WIDTH
+### GATE_REASSIGN_THRESHOLD
 
-Width used when creating a minimal recurrent block.
+Threshold used for random 50/50 gating decisions.
 
-### SUB_NODE_STABILITY_WEIGHT_DELTA
+### MIN_REDUNDANT_CONNECTION_COUNT
 
-Weight delta used to keep mutation side effects numerically observable.
+Minimum redundant in/out degree required before removing a connection.
 
-### GATE_REASSIGN_THRESHOLD
+### MIN_SWAPPABLE_NODE_COUNT
 
-Threshold used for random 50/50 gating decisions.
+Minimum node count required to perform swap-node mutation.
 
-### DEFAULT_MUTATION_MIN
+### NODE_TYPE_HIDDEN
 
-Default minimum mutation value when no method override is provided.
+Canonical node-type literal for hidden nodes.
 
-### DEFAULT_MUTATION_MAX
+### NODE_TYPE_INPUT
 
-Default maximum mutation value when no method override is provided.
+Canonical node-type literal for input nodes.
 
-### MIN_REDUNDANT_CONNECTION_COUNT
+### NODE_TYPE_OUTPUT
 
-Minimum redundant in/out degree required before removing a connection.
+Canonical node-type literal for output nodes.
 
-### MIN_SWAPPABLE_NODE_COUNT
+### RECURRENT_BLOCK_GRU
 
-Minimum node count required to perform swap-node mutation.
+Canonical recurrent block literal for GRU expansion.
 
-### WARNING_NO_HIDDEN_NODES_TO_REMOVE
+### RECURRENT_BLOCK_LSTM
 
-Message emitted when no hidden node can be removed.
+Canonical recurrent block literal for LSTM expansion.
 
-### WARNING_NO_ACTIVATION_MUTATION_TARGETS
+### SINGLE_UNIT_RECURRENT_BLOCK_WIDTH
 
-Message emitted when activation mutation has no eligible nodes.
+Width used when creating a minimal recurrent block.
 
-### WARNING_SELF_CONNECTIONS_ALREADY_PRESENT
+### SUB_NODE_STABILITY_WEIGHT_DELTA
 
-Message emitted when all self-connection candidates are already occupied.
+Weight delta used to keep mutation side effects numerically observable.
 
-### WARNING_NO_SELF_CONNECTIONS_TO_REMOVE
+### UNKNOWN_MUTATION_WARNING_PREFIX
 
-Message emitted when no self-connections are available to remove.
+Prefix for unknown-mutation warning logs.
 
 ### WARNING_ALL_CONNECTIONS_GATED
 
 Message emitted when gating cannot be added because all are already gated.
 
+### WARNING_NO_ACTIVATION_MUTATION_TARGETS
+
+Message emitted when activation mutation has no eligible nodes.
+
 ### WARNING_NO_GATED_CONNECTIONS_TO_REMOVE
 
 Message emitted when no gate exists to remove.
 
-### UNKNOWN_MUTATION_WARNING_PREFIX
+### WARNING_NO_HIDDEN_NODES_TO_REMOVE
 
-Prefix for unknown-mutation warning logs.
+Message emitted when no hidden node can be removed.
 
-### ERROR_NO_MUTATE_METHOD
+### WARNING_NO_SELF_CONNECTIONS_TO_REMOVE
 
-Error emitted when mutate is called without a valid method.
+Message emitted when no self-connections are available to remove.
 
-### BATCH_NORM_FLAG_KEY
+### WARNING_SELF_CONNECTIONS_ALREADY_PRESENT
 
-Internal node field used to enable batch normalization.
+Message emitted when all self-connection candidates are already occupied.
 
 ## architecture/network/mutate/network.mutate.utils.ts
 
@@ -172,49 +172,20 @@ Responsibilities:
 The helpers in this module are intentionally side-effect-light, except for optional
 warning emission, so orchestration code can remain deterministic and easy to inspect.
 
-### resolveMutationKey
+### findMutationKeyByIdentityReference
 
 ```ts
-resolveMutationKey(
+findMutationKeyByIdentityReference(
   method: MutationMethod,
 ): string | undefined
 ```
 
-Resolves a mutation dispatch key from user-provided method input.
-
-Resolution order:
-1. Use string input directly.
-2. Use direct object identity fields (`name`, `type`, `identity`).
-3. Fall back to identity-reference comparison against known mutation objects.
-
-Parameters:
-- `method` - - Mutation method input.
-
-Returns: Dispatch key or undefined.
-
-Example:
-
-```ts
-const key = resolveMutationKey('ADD_NODE');
-```
-
-### warnUnknownMutation
-
-```ts
-warnUnknownMutation(
-  mutationKey: string | undefined,
-): void
-```
-
-Emits unknown-mutation warning when configured.
-
-This helper intentionally no-ops when warnings are disabled so callers can invoke it
-without repeating feature-flag checks.
+Resolves a mutation key by direct identity-reference comparison.
 
 Parameters:
-- `mutationKey` - - Resolved mutation key.
+- `method` - - Mutation object reference.
 
-Returns: Nothing.
+Returns: Matching mutation key or undefined.
 
 ### isMutationMethodKeyString
 
@@ -231,50 +202,79 @@ Parameters:
 
 Returns: True when method is a key string.
 
-### resolveMutationKeyFromObject
+### resolveDirectMutationKey
 
 ```ts
-resolveMutationKeyFromObject(
+resolveDirectMutationKey(
   methodObject: { [key: string]: unknown; name?: string | undefined; type?: string | undefined; identity?: string | undefined; max?: number | undefined; min?: number | undefined; mutateOutput?: boolean | undefined; },
 ): string | undefined
 ```
 
-Resolves mutation key from object-form descriptor.
+Resolves direct object fields that can represent a mutation key.
 
 Parameters:
 - `methodObject` - - Mutation method object.
 
+Returns: Direct key or undefined.
+
+### resolveMutationKey
+
+```ts
+resolveMutationKey(
+  method: MutationMethod,
+): string | undefined
+```
+
+Resolves a mutation dispatch key from user-provided method input.
+
+Resolution order:
+1. Use string input directly.
+2. Use direct object identity fields (`name`, `type`, `identity`).
+3. Fall back to identity-reference comparison against known mutation objects.
+
+Parameters:
+- `method` - - Mutation method input.
+
 Returns: Dispatch key or undefined.
 
-### resolveDirectMutationKey
+Example:
 
 ```ts
-resolveDirectMutationKey(
+const key = resolveMutationKey('ADD_NODE');
+```
+
+### resolveMutationKeyFromObject
+
+```ts
+resolveMutationKeyFromObject(
   methodObject: { [key: string]: unknown; name?: string | undefined; type?: string | undefined; identity?: string | undefined; max?: number | undefined; min?: number | undefined; mutateOutput?: boolean | undefined; },
 ): string | undefined
 ```
 
-Resolves direct object fields that can represent a mutation key.
+Resolves mutation key from object-form descriptor.
 
 Parameters:
 - `methodObject` - - Mutation method object.
 
-Returns: Direct key or undefined.
+Returns: Dispatch key or undefined.
 
-### findMutationKeyByIdentityReference
+### warnUnknownMutation
 
 ```ts
-findMutationKeyByIdentityReference(
-  method: MutationMethod,
-): string | undefined
+warnUnknownMutation(
+  mutationKey: string | undefined,
+): void
 ```
 
-Resolves a mutation key by direct identity-reference comparison.
+Emits unknown-mutation warning when configured.
+
+This helper intentionally no-ops when warnings are disabled so callers can invoke it
+without repeating feature-flag checks.
 
 Parameters:
-- `method` - - Mutation object reference.
+- `mutationKey` - - Resolved mutation key.
 
-Returns: Matching mutation key or undefined.
+Returns: Nothing.
 
 ## architecture/network/mutate/network.mutate.handlers.utils.ts
 
@@ -291,911 +291,894 @@ Behavioral notes:
 - Acyclic mode checks are enforced in handlers that could introduce recurrence.
 - Randomness is sourced from network mutation internals for reproducible deterministic flows.
 
-### addNode
+### addBackConn
 
 ```ts
-addNode(): void
+addBackConn(): void
 ```
 
-Adds one hidden node by splitting an existing connection.
+Adds one backward (recurrent) connection between eligible node pairs.
 
-Execution modes:
-- Deterministic chain mode grows a linear input→...→output chain.
-- Standard mode splits a randomly selected forward connection.
+This operation is skipped in acyclic mode.
 
 Parameters:
 - `this` - - Bound network.
 
 Returns: Nothing.
 
-### subNode
+### addConn
 
 ```ts
-subNode(): void
+addConn(): void
 ```
 
-Removes one hidden node and applies a tiny weight nudge for numerical continuity.
+Adds one forward connection between currently unconnected eligible node pairs.
 
-The stability nudge helps keep downstream mutation effects observable in edge cases
-where node removal substantially changes effective signal flow.
+Candidate generation respects node ordering so the added edge is feed-forward.
 
 Parameters:
 - `this` - - Bound network.
 
 Returns: Nothing.
 
-### addConn
+### addGate
 
 ```ts
-addConn(): void
+addGate(): void
 ```
 
-Adds one forward connection between currently unconnected eligible node pairs.
+Assigns a random eligible node as gater for a random ungated connection.
 
-Candidate generation respects node ordering so the added edge is feed-forward.
+Candidate pool includes normal and self-connections.
 
 Parameters:
 - `this` - - Bound network.
 
 Returns: Nothing.
 
-### subConn
+### addGRUNode
 
 ```ts
-subConn(): void
+addGRUNode(): void
 ```
 
-Removes one forward connection when structural redundancy constraints are satisfied.
-
-Constraints require endpoint redundancy and avoid disconnecting peer-layer groups.
+Replaces one connection by inserting a minimal GRU recurrent block.
 
 Parameters:
 - `this` - - Bound network.
 
 Returns: Nothing.
 
-### modWeight
+### addLSTMNode
 
 ```ts
-modWeight(
-  method: MutationMethod | undefined,
-): void
+addLSTMNode(): void
 ```
 
-Perturbs one connection weight using a uniform delta sampled from configured bounds.
-
-The candidate pool includes standard and self-connections.
+Replaces one connection by inserting a minimal LSTM recurrent block.
 
 Parameters:
 - `this` - - Bound network.
-- `method` - - Optional method descriptor.
 
 Returns: Nothing.
 
-### modBias
+### addNode
 
 ```ts
-modBias(
-  method: MutationMethod | undefined,
-): void
+addNode(): void
 ```
 
-Mutates bias parameters on one random non-input node.
+Adds one hidden node by splitting an existing connection.
 
-Output nodes remain eligible for this operator.
+Execution modes:
+- Deterministic chain mode grows a linear input→...→output chain.
+- Standard mode splits a randomly selected forward connection.
 
 Parameters:
 - `this` - - Bound network.
-- `method` - - Optional method descriptor.
 
 Returns: Nothing.
 
-### modActivation
+### addNodeDeterministicChain
 
 ```ts
-modActivation(
-  method: MutationMethod | undefined,
+addNodeDeterministicChain(
+  network: default,
+  mutationProps: NetworkMutationProps,
 ): void
 ```
 
-Mutates activation function on one random non-input node.
-
-Output-node eligibility is controlled by `method.mutateOutput` when provided.
+Applies deterministic chain-growth ADD_NODE mutation.
 
 Parameters:
-- `this` - - Bound network.
-- `method` - - Optional method descriptor.
+- `network` - - Target network.
+- `mutationProps` - - Runtime mutation props.
 
 Returns: Nothing.
 
-### addSelfConn
+### addNodeRandomSplit
 
 ```ts
-addSelfConn(): void
-```
-
-Adds one self-connection on an eligible node that does not already have one.
+addNodeRandomSplit(
+  network: default,
+  mutationProps: NetworkMutationProps,
+): void
+```
 
-This operation is skipped in acyclic mode.
+Applies non-deterministic ADD_NODE by splitting a random connection.
 
 Parameters:
-- `this` - - Bound network.
+- `network` - - Target network.
+- `mutationProps` - - Runtime mutation props.
 
 Returns: Nothing.
 
-### subSelfConn
+### addRecurrentNode
 
 ```ts
-subSelfConn(): void
+addRecurrentNode(
+  network: default,
+  blockType: "lstm" | "gru",
+): void
 ```
 
-Removes one existing self-connection chosen at random.
+Shared orchestrator for recurrent-node mutation variants.
 
 Parameters:
-- `this` - - Bound network.
+- `network` - - Target network.
+- `blockType` - - Recurrent block type.
 
 Returns: Nothing.
 
-### addGate
+### addSelfConn
 
 ```ts
-addGate(): void
+addSelfConn(): void
 ```
 
-Assigns a random eligible node as gater for a random ungated connection.
+Adds one self-connection on an eligible node that does not already have one.
 
-Candidate pool includes normal and self-connections.
+This operation is skipped in acyclic mode.
 
 Parameters:
 - `this` - - Bound network.
 
 Returns: Nothing.
 
-### subGate
+### appendRecurrentLayerNodes
 
 ```ts
-subGate(): void
+appendRecurrentLayerNodes(
+  network: default,
+  layerNodes: default[],
+): void
 ```
 
-Removes gating from one randomly selected gated connection.
+Appends recurrent layer nodes as hidden nodes.
 
 Parameters:
-- `this` - - Bound network.
+- `network` - - Target network.
+- `layerNodes` - - Layer nodes.
 
 Returns: Nothing.
 
-### addBackConn
+### applyFirstConnectionStabilityNudge
 
 ```ts
-addBackConn(): void
+applyFirstConnectionStabilityNudge(
+  network: default,
+): void
 ```
 
-Adds one backward (recurrent) connection between eligible node pairs.
-
-This operation is skipped in acyclic mode.
+Applies tiny stability nudge to the first remaining connection.
 
 Parameters:
-- `this` - - Bound network.
+- `network` - - Target network.
 
 Returns: Nothing.
 
-### subBackConn
+### asMutationProps
 
 ```ts
-subBackConn(): void
+asMutationProps(
+  network: default,
+): NetworkMutationProps
 ```
 
-Removes one backward connection that satisfies redundancy constraints.
+Converts a network to its internal mutation runtime shape.
 
 Parameters:
-- `this` - - Bound network.
+- `network` - - Network to convert.
 
-Returns: Nothing.
+Returns: Runtime mutation props.
 
-### swapNodes
+### batchNorm
 
 ```ts
-swapNodes(
-  method: MutationMethod | undefined,
-): void
+batchNorm(): void
 ```
 
-Swaps bias and activation squash functions between two distinct mutable nodes.
-
-This provides a lightweight structural-parameter recombination without changing
-graph connectivity.
+Enables the internal batch-normalization flag on one random hidden node.
 
 Parameters:
 - `this` - - Bound network.
-- `method` - - Optional method descriptor.
 
 Returns: Nothing.
 
-### addLSTMNode
+### collectAllConnections
 
 ```ts
-addLSTMNode(): void
+collectAllConnections(
+  network: default,
+): default[]
 ```
 
-Replaces one connection by inserting a minimal LSTM recurrent block.
+Collects normal and self connections.
 
 Parameters:
-- `this` - - Bound network.
+- `network` - - Target network.
 
-Returns: Nothing.
+Returns: Combined connections.
 
-### addGRUNode
+### collectBackwardCandidatesForLaterNode
 
 ```ts
-addGRUNode(): void
+collectBackwardCandidatesForLaterNode(
+  traversalContext: BackwardCandidateTraversalContext,
+): NodePair[]
 ```
 
-Replaces one connection by inserting a minimal GRU recurrent block.
+Collects all backward candidates for one later-node traversal context.
 
 Parameters:
-- `this` - - Bound network.
+- `traversalContext` - - Later-node traversal context.
 
-Returns: Nothing.
+Returns: Candidate source/target pairs.
 
-### reinitWeight
+### collectBackwardCandidatesFromContext
 
 ```ts
-reinitWeight(
-  method: MutationMethod | undefined,
-): void
+collectBackwardCandidatesFromContext(
+  backwardConnectionCandidates: NodePair[],
+  traversalContext: BackwardCandidateTraversalContext,
+): NodePair[]
 ```
 
-Reinitializes incoming, outgoing, and self-connection weights for one target node.
-
-Weight sampling bounds come from method overrides or default mutation bounds.
+Reduces one backward traversal context into candidate connection pairs.
 
 Parameters:
-- `this` - - Bound network.
-- `method` - - Optional method descriptor.
+- `backwardConnectionCandidates` - - Existing candidate pairs.
+- `traversalContext` - - Later-node traversal context.
 
-Returns: Nothing.
+Returns: Updated candidate pairs.
 
-### batchNorm
+### collectBackwardConnectionCandidates
 
 ```ts
-batchNorm(): void
+collectBackwardConnectionCandidates(
+  network: default,
+): NodePair[]
 ```
 
-Enables the internal batch-normalization flag on one random hidden node.
+Collects backward (recurrent) connection candidates.
 
 Parameters:
-- `this` - - Bound network.
+- `network` - - Target network.
 
-Returns: Nothing.
+Returns: Candidate source/target pairs.
 
-### asMutationProps
+### collectBackwardTraversalContexts
 
 ```ts
-asMutationProps(
+collectBackwardTraversalContexts(
   network: default,
-): NetworkMutationProps
+): BackwardCandidateTraversalContext[]
 ```
 
-Converts a network to its internal mutation runtime shape.
+Collects backward traversal contexts for all eligible later nodes.
 
 Parameters:
-- `network` - - Network to convert.
+- `network` - - Target network.
 
-Returns: Runtime mutation props.
+Returns: Backward traversal contexts.
 
-### markTopoDirtyIfAcyclic
+### collectConnectionGroupsForReinit
 
 ```ts
-markTopoDirtyIfAcyclic(
-  mutationProps: NetworkMutationProps,
-): void
+collectConnectionGroupsForReinit(
+  targetNode: default,
+): default[][]
 ```
 
-Marks topology caches dirty when acyclic mode is enforced.
+Collects all connection groups affected by REINIT_WEIGHT.
 
 Parameters:
-- `mutationProps` - - Runtime mutation props.
+- `targetNode` - - Node receiving the reinitialization.
 
-Returns: Nothing.
+Returns: Mutable connection groups.
 
-### findFirstNodeByType
+### collectDistinctNodeCandidates
 
 ```ts
-findFirstNodeByType(
-  network: default,
-  nodeType: string,
-): default | undefined
+collectDistinctNodeCandidates(
+  nodeCandidates: default[],
+  excludedNode: default,
+): default[]
 ```
 
-Returns the first node by type.
+Collects candidates that are distinct from an excluded node.
 
 Parameters:
-- `network` - - Target network.
-- `nodeType` - - Node type to match.
+- `nodeCandidates` - - Candidate nodes.
+- `excludedNode` - - Node to exclude.
 
-Returns: Matching node or undefined.
+Returns: Distinct candidates.
 
-### pickRandomEntry
+### collectForwardCandidatesForSource
 
 ```ts
-pickRandomEntry(
-  entries: T[],
-  randomValue: () => number,
-): T | undefined
+collectForwardCandidatesForSource(
+  traversalContext: ForwardCandidateTraversalContext,
+): NodePair[]
 ```
 
-Selects a random array element.
+Collects all forward candidates for one source traversal context.
 
 Parameters:
-- `entries` - - Source entries.
-- `randomValue` - - Random generator.
+- `traversalContext` - - Source traversal context.
 
-Returns: Random entry or undefined when empty.
+Returns: Candidate source/target pairs.
 
-### createHiddenNode
+### collectForwardCandidatesFromContext
 
 ```ts
-createHiddenNode(
-  randomValue: () => number,
-): default
+collectForwardCandidatesFromContext(
+  forwardConnectionCandidates: NodePair[],
+  traversalContext: ForwardCandidateTraversalContext,
+): NodePair[]
 ```
 
-Creates a hidden node with random activation mutation.
+Reduces one forward traversal context into candidate connection pairs.
 
 Parameters:
-- `randomValue` - - Random generator.
+- `forwardConnectionCandidates` - - Existing candidate pairs.
+- `traversalContext` - - Source traversal context.
 
-Returns: Hidden node.
+Returns: Updated candidate pairs.
 
-### insertNodeBeforeOutputTail
+### collectForwardConnectionCandidates
 
 ```ts
-insertNodeBeforeOutputTail(
+collectForwardConnectionCandidates(
   network: default,
-  nodeToInsert: default,
-  targetNode: default,
-  mutationProps: NetworkMutationProps,
-): void
+): NodePair[]
 ```
 
-Inserts a node before output tail while preserving output block ordering.
+Collects forward connection candidates.
 
 Parameters:
 - `network` - - Target network.
-- `nodeToInsert` - - Node to insert.
-- `targetNode` - - Target node for insertion alignment.
-- `mutationProps` - - Runtime mutation props.
 
-Returns: Nothing.
+Returns: Candidate source/target pairs.
 
-### findConnection
+### collectForwardTraversalContexts
 
 ```ts
-findConnection(
+collectForwardTraversalContexts(
   network: default,
-  fromNode: default,
-  toNode: default,
-): default | undefined
+): ForwardCandidateTraversalContext[]
 ```
 
-Gets a connection between two nodes when it exists.
+Collects forward traversal contexts for all eligible source nodes.
 
 Parameters:
 - `network` - - Target network.
-- `fromNode` - - Source node.
-- `toNode` - - Target node.
 
-Returns: Matching connection or undefined.
+Returns: Forward traversal contexts.
 
-### ensureConnection
+### collectMutableNonInputNodes
 
 ```ts
-ensureConnection(
+collectMutableNonInputNodes(
   network: default,
-  fromNode: default,
-  toNode: default,
-): default | undefined
+  excludeOutputNodes: boolean,
+): default[]
 ```
 
-Ensures a connection exists and returns it.
+Collects mutable non-input nodes.
 
 Parameters:
 - `network` - - Target network.
-- `fromNode` - - Source node.
-- `toNode` - - Target node.
+- `excludeOutputNodes` - - True to exclude output nodes.
 
-Returns: Existing or created connection.
+Returns: Mutable nodes.
 
-### tryDisconnectConnection
+### collectNodesByType
 
 ```ts
-tryDisconnectConnection(
+collectNodesByType(
   network: default,
-  connection: default,
-): void
+  nodeType: string,
+): default[]
 ```
 
-Disconnects a connection pair while suppressing errors.
+Collects nodes by type.
 
 Parameters:
-- `network` - - Target network.
-- `connection` - - Connection to remove.
+- `network` - - Source network.
+- `nodeType` - - Desired node type.
 
-Returns: Nothing.
+Returns: Matching nodes.
 
-### addNodeDeterministicChain
+### collectNodesWithoutSelfLoop
 
 ```ts
-addNodeDeterministicChain(
+collectNodesWithoutSelfLoop(
   network: default,
-  mutationProps: NetworkMutationProps,
-): void
+): default[]
 ```
 
-Applies deterministic chain-growth ADD_NODE mutation.
+Collects non-input nodes that do not have self loops.
 
 Parameters:
 - `network` - - Target network.
-- `mutationProps` - - Runtime mutation props.
 
-Returns: Nothing.
+Returns: Eligible nodes.
 
-### resolveDeterministicChainMutationContext
+### collectRemovableBackwardConnections
 
 ```ts
-resolveDeterministicChainMutationContext(
+collectRemovableBackwardConnections(
   network: default,
-  mutationProps: NetworkMutationProps,
-): DeterministicChainMutationContext | undefined
+): default[]
 ```
 
-Resolves all deterministic add-node prerequisites into one context object.
+Collects removable backward connections using redundancy constraints.
 
 Parameters:
 - `network` - - Target network.
-- `mutationProps` - - Runtime mutation props.
 
-Returns: Deterministic context or undefined when one or more prerequisites fail.
+Returns: Removable backward connections.
 
-### resolveInputOutputEndpoints
+### collectRemovableForwardConnections
 
 ```ts
-resolveInputOutputEndpoints(
+collectRemovableForwardConnections(
   network: default,
-): InputOutputEndpoints | undefined
+): default[]
 ```
 
-Resolves input/output endpoints required for seed and deterministic flows.
+Collects removable forward connections using redundancy constraints.
 
 Parameters:
 - `network` - - Target network.
 
-Returns: Endpoint nodes or undefined when missing.
+Returns: Removable forward connections.
 
-### initializeDeterministicChain
+### collectSwappableNodesForMutation
 
 ```ts
-initializeDeterministicChain(
+collectSwappableNodesForMutation(
   network: default,
-  mutationProps: NetworkMutationProps,
-  inputNode: default,
-  outputNode: default,
-): void
+  method: MutationMethod | undefined,
+): default[]
 ```
 
-Initializes deterministic chain storage and seed edge.
+Collects swap-eligible nodes based on mutation configuration.
 
 Parameters:
 - `network` - - Target network.
-- `mutationProps` - - Runtime mutation props.
-- `inputNode` - - Input node.
-- `outputNode` - - Output node.
+- `method` - - Optional method descriptor.
 
-Returns: Nothing.
+Returns: Swap-eligible nodes.
 
-### pruneDeterministicChainExtraEdges
+### collectTargetLayerPeers
 
 ```ts
-pruneDeterministicChainExtraEdges(
+collectTargetLayerPeers(
   network: default,
-  deterministicChain: default[],
-  outputNode: default,
-): void
+  targetNode: default,
+): default[]
 ```
 
-Prunes side edges from chain nodes to preserve linear deterministic depth.
+Collects peers around a target node in the same type/layer neighborhood.
 
 Parameters:
 - `network` - - Target network.
-- `deterministicChain` - - Chain node list.
-- `outputNode` - - Output node.
+- `targetNode` - - Node whose peers are collected.
 
-Returns: Nothing.
+Returns: Peer nodes.
 
-### resolveExpectedChainTarget
+### collectUngatedConnections
 
 ```ts
-resolveExpectedChainTarget(
-  deterministicChain: default[],
-  chainNodeIndex: number,
-  outputNode: default,
-): default
+collectUngatedConnections(
+  network: default,
+): default[]
 ```
 
-Resolves the expected outgoing target for a chain node position.
+Collects ungated connections including self-connections.
 
 Parameters:
-- `deterministicChain` - - Chain node list.
-- `chainNodeIndex` - - Current chain index.
-- `outputNode` - - Terminal output node.
+- `network` - - Target network.
 
-Returns: Expected successor target.
+Returns: Ungated connections.
 
-### disconnectUnexpectedOutgoingConnections
+### connectPair
 
 ```ts
-disconnectUnexpectedOutgoingConnections(
+connectPair(
   network: default,
-  chainNode: default,
-  expectedTargetNode: default,
+  selectedConnectionPair: NodePair,
 ): void
 ```
 
-Removes outgoing connections that do not match the expected chain target.
+Connects source/target node pair.
 
 Parameters:
 - `network` - - Target network.
-- `chainNode` - - Node whose outgoing edges are validated.
-- `expectedTargetNode` - - Allowed outgoing target.
+- `selectedConnectionPair` - - Source/target pair.
 
 Returns: Nothing.
 
-### addNodeRandomSplit
+### containsNode
 
 ```ts
-addNodeRandomSplit(
-  network: default,
-  mutationProps: NetworkMutationProps,
-): void
+containsNode(
+  nodes: default[],
+  node: default,
+): boolean
 ```
 
-Applies non-deterministic ADD_NODE by splitting a random connection.
+Checks whether a node list contains a node reference.
 
 Parameters:
-- `network` - - Target network.
-- `mutationProps` - - Runtime mutation props.
+- `nodes` - - Node list.
+- `node` - - Node reference.
 
-Returns: Nothing.
+Returns: True when contained.
 
-### splitConnectionThroughHiddenNode
+### countConnectionWhenSourceTargetsPeer
 
 ```ts
-splitConnectionThroughHiddenNode(
-  network: default,
-  mutationProps: NetworkMutationProps,
-  connectionToSplit: default,
-): ConnectionSplitResult
+countConnectionWhenSourceTargetsPeer(
+  peerConnectionsFromSource: number,
+  existingConnection: default,
+  countContext: SourcePeerConnectionCountContext,
+): number
 ```
 
-Replaces one connection by inserting a hidden node and reconnecting edges.
+Counts one connection when it originates from source and targets a peer.
 
 Parameters:
-- `network` - - Target network.
-- `mutationProps` - - Runtime mutation props.
-- `connectionToSplit` - - Connection to split.
+- `peerConnectionsFromSource` - - Current count.
+- `existingConnection` - - Existing network connection.
+- `countContext` - - Count context.
 
-Returns: Split result values.
+Returns: Updated count.
 
-### tryReassignGateAfterSplit
+### countSourceConnectionsIntoPeerSet
 
 ```ts
-tryReassignGateAfterSplit(
+countSourceConnectionsIntoPeerSet(
   network: default,
-  randomValue: () => number,
-  splitResult: ConnectionSplitResult,
-): void
+  candidateConnection: default,
+  targetLayerPeers: default[],
+): number
 ```
 
-Reassigns prior gater to one of the new split connections when possible.
+Counts source-originated connections that end inside the target peer set.
 
 Parameters:
 - `network` - - Target network.
-- `randomValue` - - Random generator.
-- `splitResult` - - Split result values.
+- `candidateConnection` - - Candidate connection.
+- `targetLayerPeers` - - Peer-set nodes.
 
-Returns: Nothing.
+Returns: Number of source-to-peer connections.
 
-### ensureSeedForwardConnectionWhenEmpty
+### createBackwardCandidateTraversalContext
 
 ```ts
-ensureSeedForwardConnectionWhenEmpty(
+createBackwardCandidateTraversalContext(
   network: default,
-): boolean
+  laterNodeIndex: number,
+): BackwardCandidateTraversalContext
 ```
 
-Ensures a seed input->output connection exists when connection list is empty.
+Creates context for one backward-candidate traversal pass.
 
 Parameters:
 - `network` - - Target network.
+- `laterNodeIndex` - - Current later-node index.
 
-Returns: True when mutation may continue.
+Returns: Immutable traversal context.
 
-### selectHiddenNodeForRemoval
+### createConnectionGroupReinitContext
 
 ```ts
-selectHiddenNodeForRemoval(
-  network: default,
-  hiddenNodes: default[],
-): default | undefined
+createConnectionGroupReinitContext(
+  randomValue: () => number,
+  methodObject: { [key: string]: unknown; name?: string | undefined; type?: string | undefined; identity?: string | undefined; max?: number | undefined; min?: number | undefined; mutateOutput?: boolean | undefined; },
+): ConnectionGroupReinitContext
 ```
 
-Selects a hidden node candidate for SUB_NODE mutation.
+Creates immutable context for connection-group reinitialization.
 
 Parameters:
-- `network` - - Target network.
-- `hiddenNodes` - - Hidden nodes.
+- `randomValue` - - Random generator.
+- `methodObject` - - Method override object.
 
-Returns: Selected hidden node.
+Returns: Reinitialization context.
 
-### removeHiddenNodeAndApplyStabilityNudge
+### createDirectionalConnectionContext
 
 ```ts
-removeHiddenNodeAndApplyStabilityNudge(
+createDirectionalConnectionContext(
   network: default,
-  hiddenNode: default,
-): void
+  candidateConnection: default,
+): DirectionalConnectionContext
 ```
 
-Removes selected hidden node and applies stability nudge.
+Creates indexed directional context for a connection candidate.
 
 Parameters:
 - `network` - - Target network.
-- `hiddenNode` - - Hidden node to remove.
+- `candidateConnection` - - Candidate connection.
 
-Returns: Nothing.
+Returns: Directional context.
 
-### applyFirstConnectionStabilityNudge
+### createForwardCandidateTraversalContext
 
 ```ts
-applyFirstConnectionStabilityNudge(
+createForwardCandidateTraversalContext(
   network: default,
-): void
+  sourceNodeIndex: number,
+): ForwardCandidateTraversalContext
 ```
 
-Applies tiny stability nudge to the first remaining connection.
+Creates context for one forward-candidate source traversal pass.
 
 Parameters:
 - `network` - - Target network.
+- `sourceNodeIndex` - - Current source index.
 
-Returns: Nothing.
+Returns: Immutable traversal context.
 
-### collectNodesByType
+### createHiddenNode
 
 ```ts
-collectNodesByType(
-  network: default,
-  nodeType: string,
-): default[]
+createHiddenNode(
+  randomValue: () => number,
+): default
 ```
 
-Collects nodes by type.
+Creates a hidden node with random activation mutation.
 
 Parameters:
-- `network` - - Source network.
-- `nodeType` - - Desired node type.
+- `randomValue` - - Random generator.
 
-Returns: Matching nodes.
+Returns: Hidden node.
 
-### warnWhenEnabled
+### createRecurrentLayer
 
 ```ts
-warnWhenEnabled(
-  message: string,
-): void
+createRecurrentLayer(
+  blockType: "lstm" | "gru",
+): RecurrentLayerShape
 ```
 
-Emits a warning when warning mode is enabled.
+Creates recurrent layer by type.
 
 Parameters:
-- `message` - - Warning message.
+- `blockType` - - Recurrent block type.
 
-Returns: Nothing.
+Returns: Created recurrent layer.
 
-### resolveSelectedForwardConnectionPair
+### createSourcePeerConnectionCountContext
 
 ```ts
-resolveSelectedForwardConnectionPair(
-  network: default,
-  randomValue: () => number,
-): NodePair | undefined
+createSourcePeerConnectionCountContext(
+  candidateConnection: default,
+  targetLayerPeers: default[],
+): SourcePeerConnectionCountContext
 ```
 
-Resolves random selected forward connection pair.
+Creates immutable context for source-to-peer connection counting.
 
 Parameters:
-- `network` - - Target network.
-- `randomValue` - - Random generator.
+- `candidateConnection` - - Candidate connection.
+- `targetLayerPeers` - - Peer-set nodes.
 
-Returns: Selected source/target pair.
+Returns: Count context.
 
-### collectForwardConnectionCandidates
+### createTargetLayerPeerContext
 
 ```ts
-collectForwardConnectionCandidates(
+createTargetLayerPeerContext(
   network: default,
-): NodePair[]
+  targetNode: default,
+): TargetLayerPeerContext
 ```
 
-Collects forward connection candidates.
+Creates immutable context for peer-layer collection.
 
 Parameters:
 - `network` - - Target network.
+- `targetNode` - - Peer anchor node.
 
-Returns: Candidate source/target pairs.
+Returns: Peer traversal context.
 
-### collectForwardTraversalContexts
+### createWeightSamplingRangeContext
 
 ```ts
-collectForwardTraversalContexts(
-  network: default,
-): ForwardCandidateTraversalContext[]
+createWeightSamplingRangeContext(
+  reinitContext: ConnectionGroupReinitContext,
+): WeightSamplingRangeContext
 ```
 
-Collects forward traversal contexts for all eligible source nodes.
+Creates immutable sampling range context.
 
 Parameters:
-- `network` - - Target network.
+- `reinitContext` - - Reinitialization context.
 
-Returns: Forward traversal contexts.
+Returns: Sampling range context.
 
-### collectForwardCandidatesFromContext
+### disconnectConnectionAndGetGater
 
 ```ts
-collectForwardCandidatesFromContext(
-  forwardConnectionCandidates: NodePair[],
-  traversalContext: ForwardCandidateTraversalContext,
-): NodePair[]
+disconnectConnectionAndGetGater(
+  network: default,
+  connectionToExpand: default,
+): default | null
 ```
 
-Reduces one forward traversal context into candidate connection pairs.
+Disconnects a connection and returns its previous gater.
 
 Parameters:
-- `forwardConnectionCandidates` - - Existing candidate pairs.
-- `traversalContext` - - Source traversal context.
+- `network` - - Target network.
+- `connectionToExpand` - - Connection being expanded.
 
-Returns: Updated candidate pairs.
+Returns: Previous gater reference.
 
-### createForwardCandidateTraversalContext
+### disconnectConnectionPair
 
 ```ts
-createForwardCandidateTraversalContext(
+disconnectConnectionPair(
   network: default,
-  sourceNodeIndex: number,
-): ForwardCandidateTraversalContext
+  selectedConnection: default,
+): void
 ```
 
-Creates context for one forward-candidate source traversal pass.
+Disconnects selected connection by endpoints.
 
 Parameters:
 - `network` - - Target network.
-- `sourceNodeIndex` - - Current source index.
+- `selectedConnection` - - Connection to disconnect.
 
-Returns: Immutable traversal context.
+Returns: Nothing.
 
-### collectForwardCandidatesForSource
+### disconnectUnexpectedOutgoingConnections
 
 ```ts
-collectForwardCandidatesForSource(
-  traversalContext: ForwardCandidateTraversalContext,
-): NodePair[]
+disconnectUnexpectedOutgoingConnections(
+  network: default,
+  chainNode: default,
+  expectedTargetNode: default,
+): void
 ```
 
-Collects all forward candidates for one source traversal context.
+Removes outgoing connections that do not match the expected chain target.
 
 Parameters:
-- `traversalContext` - - Source traversal context.
+- `network` - - Target network.
+- `chainNode` - - Node whose outgoing edges are validated.
+- `expectedTargetNode` - - Allowed outgoing target.
 
-Returns: Candidate source/target pairs.
+Returns: Nothing.
 
-### isForwardCandidateTargetAvailable
+### enableNodeBatchNorm
 
 ```ts
-isForwardCandidateTargetAvailable(
-  sourceNode: default,
-  targetNode: default,
-): boolean
+enableNodeBatchNorm(
+  node: default,
+): void
 ```
 
-Checks whether a forward candidate target is not already projected.
+Enables internal batch-norm flag on a node.
 
 Parameters:
-- `sourceNode` - - Candidate source node.
-- `targetNode` - - Candidate target node.
+- `node` - - Node to flag.
 
-Returns: True when connection may be added.
+Returns: Nothing.
 
-### disconnectConnectionPair
+### ensureConnection
 
 ```ts
-disconnectConnectionPair(
+ensureConnection(
   network: default,
-  selectedConnection: default,
-): void
+  fromNode: default,
+  toNode: default,
+): default | undefined
 ```
 
-Disconnects selected connection by endpoints.
+Ensures a connection exists and returns it.
 
 Parameters:
 - `network` - - Target network.
-- `selectedConnection` - - Connection to disconnect.
+- `fromNode` - - Source node.
+- `toNode` - - Target node.
 
-Returns: Nothing.
+Returns: Existing or created connection.
 
-### collectRemovableForwardConnections
+### ensureSeedForwardConnectionWhenEmpty
 
 ```ts
-collectRemovableForwardConnections(
+ensureSeedForwardConnectionWhenEmpty(
   network: default,
-): default[]
+): boolean
 ```
 
-Collects removable forward connections using redundancy constraints.
+Ensures a seed input->output connection exists when connection list is empty.
 
 Parameters:
 - `network` - - Target network.
 
-Returns: Removable forward connections.
+Returns: True when mutation may continue.
 
-### isRemovableForwardConnection
+### expandConnectionWithRecurrentBlock
 
 ```ts
-isRemovableForwardConnection(
+expandConnectionWithRecurrentBlock(
   network: default,
-  candidateConnection: default,
-): boolean
+  connectionToExpand: default,
+  blockType: "lstm" | "gru",
+): void
 ```
 
-Evaluates whether a forward connection is safe to remove.
+Replaces one connection with a minimal recurrent block.
 
 Parameters:
 - `network` - - Target network.
-- `candidateConnection` - - Connection under evaluation.
+- `connectionToExpand` - - Connection to replace.
+- `blockType` - - Recurrent block type.
 
-Returns: True when removable.
+Returns: Nothing.
 
-### isForwardConnectionStructurallyRemovable
+### findConnection
 
 ```ts
-isForwardConnectionStructurallyRemovable(
+findConnection(
   network: default,
-  candidateConnection: default,
-): boolean
+  fromNode: default,
+  toNode: default,
+): default | undefined
 ```
 
-Checks structural preconditions for removable forward connections.
+Gets a connection between two nodes when it exists.
 
 Parameters:
 - `network` - - Target network.
-- `candidateConnection` - - Candidate connection.
+- `fromNode` - - Source node.
+- `toNode` - - Target node.
 
-Returns: True when the connection is a forward edge with redundant endpoints.
+Returns: Matching connection or undefined.
 
-### createDirectionalConnectionContext
+### findFirstNodeByType
 
 ```ts
-createDirectionalConnectionContext(
+findFirstNodeByType(
   network: default,
-  candidateConnection: default,
-): DirectionalConnectionContext
+  nodeType: string,
+): default | undefined
 ```
 
-Creates indexed directional context for a connection candidate.
+Returns the first node by type.
 
 Parameters:
 - `network` - - Target network.
-- `candidateConnection` - - Candidate connection.
+- `nodeType` - - Node type to match.
 
-Returns: Directional context.
+Returns: Matching node or undefined.
 
 ### hasRedundantEndpoints
 
@@ -1212,145 +1195,196 @@ Parameters:
 
 Returns: True when endpoint redundancy exists.
 
-### isForwardDirectionalContext
+### initializeDeterministicChain
 
 ```ts
-isForwardDirectionalContext(
-  directionContext: DirectionalConnectionContext,
-): boolean
+initializeDeterministicChain(
+  network: default,
+  mutationProps: NetworkMutationProps,
+  inputNode: default,
+  outputNode: default,
+): void
 ```
 
-Checks whether a directional context represents a forward edge.
+Initializes deterministic chain storage and seed edge.
 
 Parameters:
-- `directionContext` - - Directional context.
+- `network` - - Target network.
+- `mutationProps` - - Runtime mutation props.
+- `inputNode` - - Input node.
+- `outputNode` - - Output node.
 
-Returns: True when forward.
+Returns: Nothing.
 
-### wouldDisconnectTargetPeerLayerGroup
+### insertNodeBeforeOutputTail
 
 ```ts
-wouldDisconnectTargetPeerLayerGroup(
+insertNodeBeforeOutputTail(
   network: default,
-  candidateConnection: default,
-): boolean
+  nodeToInsert: default,
+  targetNode: default,
+  mutationProps: NetworkMutationProps,
+): void
 ```
 
-Determines whether removal would disconnect a target peer-layer group.
+Inserts a node before output tail while preserving output block ordering.
 
 Parameters:
 - `network` - - Target network.
-- `candidateConnection` - - Connection under evaluation.
+- `nodeToInsert` - - Node to insert.
+- `targetNode` - - Target node for insertion alignment.
+- `mutationProps` - - Runtime mutation props.
 
-Returns: True when peer group would be disconnected.
+Returns: Nothing.
 
-### countSourceConnectionsIntoPeerSet
+### isBackwardCandidateTargetAvailable
 
 ```ts
-countSourceConnectionsIntoPeerSet(
-  network: default,
-  candidateConnection: default,
-  targetLayerPeers: default[],
-): number
+isBackwardCandidateTargetAvailable(
+  laterNode: default,
+  earlierNode: default,
+): boolean
 ```
 
-Counts source-originated connections that end inside the target peer set.
+Checks whether a backward candidate target is not already projected.
 
 Parameters:
-- `network` - - Target network.
-- `candidateConnection` - - Candidate connection.
-- `targetLayerPeers` - - Peer-set nodes.
+- `laterNode` - - Candidate source node.
+- `earlierNode` - - Candidate target node.
 
-Returns: Number of source-to-peer connections.
+Returns: True when connection may be added.
 
-### createSourcePeerConnectionCountContext
+### isBackwardDirectionalContext
 
 ```ts
-createSourcePeerConnectionCountContext(
-  candidateConnection: default,
-  targetLayerPeers: default[],
-): SourcePeerConnectionCountContext
+isBackwardDirectionalContext(
+  directionContext: DirectionalConnectionContext,
+): boolean
 ```
 
-Creates immutable context for source-to-peer connection counting.
+Checks whether a directional context represents a backward edge.
 
 Parameters:
-- `candidateConnection` - - Candidate connection.
-- `targetLayerPeers` - - Peer-set nodes.
+- `directionContext` - - Directional context.
 
-Returns: Count context.
+Returns: True when backward.
 
-### countConnectionWhenSourceTargetsPeer
+### isForwardCandidateTargetAvailable
 
 ```ts
-countConnectionWhenSourceTargetsPeer(
-  peerConnectionsFromSource: number,
-  existingConnection: default,
-  countContext: SourcePeerConnectionCountContext,
-): number
+isForwardCandidateTargetAvailable(
+  sourceNode: default,
+  targetNode: default,
+): boolean
 ```
 
-Counts one connection when it originates from source and targets a peer.
+Checks whether a forward candidate target is not already projected.
 
 Parameters:
-- `peerConnectionsFromSource` - - Current count.
-- `existingConnection` - - Existing network connection.
-- `countContext` - - Count context.
+- `sourceNode` - - Candidate source node.
+- `targetNode` - - Candidate target node.
 
-Returns: Updated count.
+Returns: True when connection may be added.
 
-### collectTargetLayerPeers
+### isForwardConnectionStructurallyRemovable
 
 ```ts
-collectTargetLayerPeers(
+isForwardConnectionStructurallyRemovable(
   network: default,
-  targetNode: default,
-): default[]
+  candidateConnection: default,
+): boolean
 ```
 
-Collects peers around a target node in the same type/layer neighborhood.
+Checks structural preconditions for removable forward connections.
 
 Parameters:
 - `network` - - Target network.
-- `targetNode` - - Node whose peers are collected.
+- `candidateConnection` - - Candidate connection.
 
-Returns: Peer nodes.
+Returns: True when the connection is a forward edge with redundant endpoints.
 
-### isTargetLayerPeer
+### isForwardDirectionalContext
 
 ```ts
-isTargetLayerPeer(
+isForwardDirectionalContext(
+  directionContext: DirectionalConnectionContext,
+): boolean
+```
+
+Checks whether a directional context represents a forward edge.
+
+Parameters:
+- `directionContext` - - Directional context.
+
+Returns: True when forward.
+
+### isNodeWithoutSelfLoop
+
+```ts
+isNodeWithoutSelfLoop(
   candidateNode: default,
-  candidateNodeIndex: number,
-  peerContext: TargetLayerPeerContext,
 ): boolean
 ```
 
-Checks whether candidate node belongs to the target peer-layer set.
+Checks whether a node currently has no self-loop connections.
 
 Parameters:
-- `candidateNode` - - Candidate node.
-- `candidateNodeIndex` - - Candidate node index.
-- `peerContext` - - Peer traversal context.
+- `candidateNode` - - Node under evaluation.
 
-Returns: True when candidate is an eligible peer.
+Returns: True when the node has no self-loop.
 
-### createTargetLayerPeerContext
+### isRemovableBackwardConnection
 
 ```ts
-createTargetLayerPeerContext(
+isRemovableBackwardConnection(
   network: default,
-  targetNode: default,
-): TargetLayerPeerContext
+  candidateConnection: default,
+): boolean
 ```
 
-Creates immutable context for peer-layer collection.
+Evaluates whether a backward connection is safe to remove.
 
 Parameters:
 - `network` - - Target network.
-- `targetNode` - - Peer anchor node.
+- `candidateConnection` - - Connection under evaluation.
 
-Returns: Peer traversal context.
+Returns: True when removable.
+
+### isRemovableForwardConnection
+
+```ts
+isRemovableForwardConnection(
+  network: default,
+  candidateConnection: default,
+): boolean
+```
+
+Evaluates whether a forward connection is safe to remove.
+
+Parameters:
+- `network` - - Target network.
+- `candidateConnection` - - Connection under evaluation.
+
+Returns: True when removable.
+
+### isTargetLayerPeer
+
+```ts
+isTargetLayerPeer(
+  candidateNode: default,
+  candidateNodeIndex: number,
+  peerContext: TargetLayerPeerContext,
+): boolean
+```
+
+Checks whether candidate node belongs to the target peer-layer set.
+
+Parameters:
+- `candidateNode` - - Candidate node.
+- `candidateNodeIndex` - - Candidate node index.
+- `peerContext` - - Peer traversal context.
+
+Returns: True when candidate is an eligible peer.
 
 ### isTargetLayerPeerTypeMatch
 
@@ -1386,683 +1420,649 @@ Parameters:
 
 Returns: True when within distance.
 
-### containsNode
+### isUngatedConnection
 
 ```ts
-containsNode(
-  nodes: default[],
-  node: default,
+isUngatedConnection(
+  candidateConnection: default,
 ): boolean
 ```
 
-Checks whether a node list contains a node reference.
+Checks whether a connection has no gater attached.
 
 Parameters:
-- `nodes` - - Node list.
-- `node` - - Node reference.
+- `candidateConnection` - - Connection under evaluation.
 
-Returns: True when contained.
+Returns: True when ungated.
 
-### collectAllConnections
+### markTopoDirtyIfAcyclic
 
 ```ts
-collectAllConnections(
-  network: default,
-): default[]
+markTopoDirtyIfAcyclic(
+  mutationProps: NetworkMutationProps,
+): void
 ```
 
-Collects normal and self connections.
+Marks topology caches dirty when acyclic mode is enforced.
 
 Parameters:
-- `network` - - Target network.
+- `mutationProps` - - Runtime mutation props.
 
-Returns: Combined connections.
+Returns: Nothing.
 
-### resolveMethodObject
+### modActivation
 
 ```ts
-resolveMethodObject(
+modActivation(
   method: MutationMethod | undefined,
-): { [key: string]: unknown; name?: string | undefined; type?: string | undefined; identity?: string | undefined; max?: number | undefined; min?: number | undefined; mutateOutput?: boolean | undefined; }
+): void
 ```
 
-Extracts method-object form when provided.
+Mutates activation function on one random non-input node.
+
+Output-node eligibility is controlled by `method.mutateOutput` when provided.
 
 Parameters:
-- `method` - - Optional mutation method.
+- `this` - - Bound network.
+- `method` - - Optional method descriptor.
 
-Returns: Method object view.
+Returns: Nothing.
 
-### sampleUniform
+### modBias
 
 ```ts
-sampleUniform(
-  randomValue: () => number,
-  minValue: number,
-  maxValue: number,
-): number
+modBias(
+  method: MutationMethod | undefined,
+): void
 ```
 
-Samples a uniform value from [minValue, maxValue].
+Mutates bias parameters on one random non-input node.
+
+Output nodes remain eligible for this operator.
 
 Parameters:
-- `randomValue` - - Random generator.
-- `minValue` - - Minimum value.
-- `maxValue` - - Maximum value.
+- `this` - - Bound network.
+- `method` - - Optional method descriptor.
 
-Returns: Sampled value.
+Returns: Nothing.
 
-### pickRandomNonInputNode
+### modWeight
 
 ```ts
-pickRandomNonInputNode(
-  network: default,
-  excludeOutputNodes: boolean,
-  randomValue: () => number,
-): default | undefined
+modWeight(
+  method: MutationMethod | undefined,
+): void
 ```
 
-Selects a random mutable non-input node.
+Perturbs one connection weight using a uniform delta sampled from configured bounds.
+
+The candidate pool includes standard and self-connections.
 
 Parameters:
-- `network` - - Target network.
-- `excludeOutputNodes` - - True to exclude outputs.
-- `randomValue` - - Random generator.
+- `this` - - Bound network.
+- `method` - - Optional method descriptor.
 
-Returns: Selected mutable node.
+Returns: Nothing.
 
-### collectMutableNonInputNodes
+### pickDistinctNodePair
 
 ```ts
-collectMutableNonInputNodes(
-  network: default,
-  excludeOutputNodes: boolean,
-): default[]
+pickDistinctNodePair(
+  swappableNodes: default[],
+  randomValue: () => number,
+): DistinctNodePair | undefined
 ```
 
-Collects mutable non-input nodes.
+Picks two distinct nodes from a candidate set.
 
 Parameters:
-- `network` - - Target network.
-- `excludeOutputNodes` - - True to exclude output nodes.
+- `swappableNodes` - - Swap candidate nodes.
+- `randomValue` - - Random generator.
 
-Returns: Mutable nodes.
+Returns: Distinct pair or undefined.
 
-### resolveSelfConnectionTargetNode
+### pickDistinctRandomNode
 
 ```ts
-resolveSelfConnectionTargetNode(
-  network: default,
+pickDistinctRandomNode(
+  nodeCandidates: default[],
+  excludedNode: default,
   randomValue: () => number,
 ): default | undefined
 ```
 
-Resolves random node eligible for self-connection creation.
+Picks a random node distinct from a given reference.
 
 Parameters:
-- `network` - - Target network.
+- `nodeCandidates` - - Candidate nodes.
+- `excludedNode` - - Node to exclude.
 - `randomValue` - - Random generator.
 
-Returns: Selected node.
+Returns: Distinct node or undefined.
 
-### collectNodesWithoutSelfLoop
+### pickRandomEntry
 
 ```ts
-collectNodesWithoutSelfLoop(
-  network: default,
-): default[]
+pickRandomEntry(
+  entries: T[],
+  randomValue: () => number,
+): T | undefined
 ```
 
-Collects non-input nodes that do not have self loops.
+Selects a random array element.
 
 Parameters:
-- `network` - - Target network.
+- `entries` - - Source entries.
+- `randomValue` - - Random generator.
 
-Returns: Eligible nodes.
+Returns: Random entry or undefined when empty.
 
-### isNodeWithoutSelfLoop
+### pickRandomNonInputNode
 
 ```ts
-isNodeWithoutSelfLoop(
-  candidateNode: default,
-): boolean
-```
-
-Checks whether a node currently has no self-loop connections.
-
-Parameters:
-- `candidateNode` - - Node under evaluation.
-
-Returns: True when the node has no self-loop.
-
-### collectUngatedConnections
-
-```ts
-collectUngatedConnections(
+pickRandomNonInputNode(
   network: default,
-): default[]
+  excludeOutputNodes: boolean,
+  randomValue: () => number,
+): default | undefined
 ```
 
-Collects ungated connections including self-connections.
+Selects a random mutable non-input node.
 
 Parameters:
 - `network` - - Target network.
+- `excludeOutputNodes` - - True to exclude outputs.
+- `randomValue` - - Random generator.
 
-Returns: Ungated connections.
+Returns: Selected mutable node.
 
-### isUngatedConnection
+### pruneDeterministicChainExtraEdges
 
 ```ts
-isUngatedConnection(
-  candidateConnection: default,
-): boolean
+pruneDeterministicChainExtraEdges(
+  network: default,
+  deterministicChain: default[],
+  outputNode: default,
+): void
 ```
 
-Checks whether a connection has no gater attached.
+Prunes side edges from chain nodes to preserve linear deterministic depth.
 
 Parameters:
-- `candidateConnection` - - Connection under evaluation.
+- `network` - - Target network.
+- `deterministicChain` - - Chain node list.
+- `outputNode` - - Output node.
 
-Returns: True when ungated.
+Returns: Nothing.
 
-### resolveSelectedBackwardConnectionPair
+### reconnectThroughRecurrentLayer
 
 ```ts
-resolveSelectedBackwardConnectionPair(
+reconnectThroughRecurrentLayer(
   network: default,
-  randomValue: () => number,
-): NodePair | undefined
+  connectionToExpand: default,
+  recurrentLayer: RecurrentLayerShape,
+): default | undefined
 ```
 
-Resolves random selected backward connection pair.
+Reconnects a source/target pair through a recurrent layer.
 
 Parameters:
 - `network` - - Target network.
-- `randomValue` - - Random generator.
+- `connectionToExpand` - - Original connection.
+- `recurrentLayer` - - Recurrent-layer shape.
 
-Returns: Selected source/target pair.
+Returns: Latest newly created connection or undefined.
 
-### collectBackwardConnectionCandidates
+### reinitializeConnectionGroupWeights
 
 ```ts
-collectBackwardConnectionCandidates(
-  network: default,
-): NodePair[]
+reinitializeConnectionGroupWeights(
+  connections: default[],
+  reinitContext: ConnectionGroupReinitContext,
+): void
 ```
 
-Collects backward (recurrent) connection candidates.
+Reinitializes all weights in a connection group.
 
 Parameters:
-- `network` - - Target network.
+- `connections` - - Connection group.
+- `randomValue` - - Random generator.
+- `minWeight` - - Minimum sampled weight.
+- `maxWeight` - - Maximum sampled weight.
 
-Returns: Candidate source/target pairs.
+Returns: Nothing.
 
-### collectBackwardTraversalContexts
+### reinitWeight
 
 ```ts
-collectBackwardTraversalContexts(
-  network: default,
-): BackwardCandidateTraversalContext[]
+reinitWeight(
+  method: MutationMethod | undefined,
+): void
 ```
 
-Collects backward traversal contexts for all eligible later nodes.
+Reinitializes incoming, outgoing, and self-connection weights for one target node.
+
+Weight sampling bounds come from method overrides or default mutation bounds.
 
 Parameters:
-- `network` - - Target network.
+- `this` - - Bound network.
+- `method` - - Optional method descriptor.
 
-Returns: Backward traversal contexts.
+Returns: Nothing.
 
-### collectBackwardCandidatesFromContext
+### removeHiddenNodeAndApplyStabilityNudge
 
 ```ts
-collectBackwardCandidatesFromContext(
-  backwardConnectionCandidates: NodePair[],
-  traversalContext: BackwardCandidateTraversalContext,
-): NodePair[]
+removeHiddenNodeAndApplyStabilityNudge(
+  network: default,
+  hiddenNode: default,
+): void
 ```
 
-Reduces one backward traversal context into candidate connection pairs.
+Removes selected hidden node and applies stability nudge.
 
 Parameters:
-- `backwardConnectionCandidates` - - Existing candidate pairs.
-- `traversalContext` - - Later-node traversal context.
+- `network` - - Target network.
+- `hiddenNode` - - Hidden node to remove.
 
-Returns: Updated candidate pairs.
+Returns: Nothing.
 
-### createBackwardCandidateTraversalContext
+### resolveDeterministicChainMutationContext
 
 ```ts
-createBackwardCandidateTraversalContext(
+resolveDeterministicChainMutationContext(
   network: default,
-  laterNodeIndex: number,
-): BackwardCandidateTraversalContext
+  mutationProps: NetworkMutationProps,
+): DeterministicChainMutationContext | undefined
 ```
 
-Creates context for one backward-candidate traversal pass.
+Resolves all deterministic add-node prerequisites into one context object.
 
 Parameters:
 - `network` - - Target network.
-- `laterNodeIndex` - - Current later-node index.
+- `mutationProps` - - Runtime mutation props.
 
-Returns: Immutable traversal context.
+Returns: Deterministic context or undefined when one or more prerequisites fail.
 
-### collectBackwardCandidatesForLaterNode
+### resolveDistinctPairWithKnownFirstNode
 
 ```ts
-collectBackwardCandidatesForLaterNode(
-  traversalContext: BackwardCandidateTraversalContext,
-): NodePair[]
+resolveDistinctPairWithKnownFirstNode(
+  swappableNodes: default[],
+  firstNode: default,
+  randomValue: () => number,
+): DistinctNodePair | undefined
 ```
 
-Collects all backward candidates for one later-node traversal context.
+Resolves a distinct pair when first node is already known.
 
 Parameters:
-- `traversalContext` - - Later-node traversal context.
+- `swappableNodes` - - Swap candidate nodes.
+- `firstNode` - - Chosen first node.
+- `randomValue` - - Random generator.
 
-Returns: Candidate source/target pairs.
+Returns: Distinct pair or undefined.
 
-### isBackwardCandidateTargetAvailable
+### resolveExpectedChainTarget
 
 ```ts
-isBackwardCandidateTargetAvailable(
-  laterNode: default,
-  earlierNode: default,
-): boolean
+resolveExpectedChainTarget(
+  deterministicChain: default[],
+  chainNodeIndex: number,
+  outputNode: default,
+): default
 ```
 
-Checks whether a backward candidate target is not already projected.
+Resolves the expected outgoing target for a chain node position.
 
 Parameters:
-- `laterNode` - - Candidate source node.
-- `earlierNode` - - Candidate target node.
+- `deterministicChain` - - Chain node list.
+- `chainNodeIndex` - - Current chain index.
+- `outputNode` - - Terminal output node.
 
-Returns: True when connection may be added.
+Returns: Expected successor target.
 
-### connectPair
+### resolveInputOutputEndpoints
 
 ```ts
-connectPair(
+resolveInputOutputEndpoints(
   network: default,
-  selectedConnectionPair: NodePair,
-): void
+): InputOutputEndpoints | undefined
 ```
 
-Connects source/target node pair.
+Resolves input/output endpoints required for seed and deterministic flows.
 
 Parameters:
 - `network` - - Target network.
-- `selectedConnectionPair` - - Source/target pair.
 
-Returns: Nothing.
+Returns: Endpoint nodes or undefined when missing.
 
-### collectRemovableBackwardConnections
+### resolveMethodObject
 
 ```ts
-collectRemovableBackwardConnections(
-  network: default,
-): default[]
+resolveMethodObject(
+  method: MutationMethod | undefined,
+): { [key: string]: unknown; name?: string | undefined; type?: string | undefined; identity?: string | undefined; max?: number | undefined; min?: number | undefined; mutateOutput?: boolean | undefined; }
 ```
 
-Collects removable backward connections using redundancy constraints.
+Extracts method-object form when provided.
 
 Parameters:
-- `network` - - Target network.
+- `method` - - Optional mutation method.
 
-Returns: Removable backward connections.
+Returns: Method object view.
 
-### isRemovableBackwardConnection
+### resolveSelectedBackwardConnectionPair
 
 ```ts
-isRemovableBackwardConnection(
+resolveSelectedBackwardConnectionPair(
   network: default,
-  candidateConnection: default,
-): boolean
+  randomValue: () => number,
+): NodePair | undefined
 ```
 
-Evaluates whether a backward connection is safe to remove.
+Resolves random selected backward connection pair.
 
 Parameters:
 - `network` - - Target network.
-- `candidateConnection` - - Connection under evaluation.
+- `randomValue` - - Random generator.
 
-Returns: True when removable.
+Returns: Selected source/target pair.
 
-### isBackwardDirectionalContext
+### resolveSelectedForwardConnectionPair
 
 ```ts
-isBackwardDirectionalContext(
-  directionContext: DirectionalConnectionContext,
-): boolean
+resolveSelectedForwardConnectionPair(
+  network: default,
+  randomValue: () => number,
+): NodePair | undefined
 ```
 
-Checks whether a directional context represents a backward edge.
+Resolves random selected forward connection pair.
 
 Parameters:
-- `directionContext` - - Directional context.
+- `network` - - Target network.
+- `randomValue` - - Random generator.
 
-Returns: True when backward.
+Returns: Selected source/target pair.
 
-### collectSwappableNodesForMutation
+### resolveSelfConnectionTargetNode
 
 ```ts
-collectSwappableNodesForMutation(
+resolveSelfConnectionTargetNode(
   network: default,
-  method: MutationMethod | undefined,
-): default[]
+  randomValue: () => number,
+): default | undefined
 ```
 
-Collects swap-eligible nodes based on mutation configuration.
+Resolves random node eligible for self-connection creation.
 
 Parameters:
 - `network` - - Target network.
-- `method` - - Optional method descriptor.
+- `randomValue` - - Random generator.
 
-Returns: Swap-eligible nodes.
+Returns: Selected node.
 
-### pickDistinctNodePair
+### sampleUniform
 
 ```ts
-pickDistinctNodePair(
-  swappableNodes: default[],
+sampleUniform(
   randomValue: () => number,
-): DistinctNodePair | undefined
+  minValue: number,
+  maxValue: number,
+): number
 ```
 
-Picks two distinct nodes from a candidate set.
+Samples a uniform value from [minValue, maxValue].
 
 Parameters:
-- `swappableNodes` - - Swap candidate nodes.
 - `randomValue` - - Random generator.
+- `minValue` - - Minimum value.
+- `maxValue` - - Maximum value.
 
-Returns: Distinct pair or undefined.
+Returns: Sampled value.
 
-### resolveDistinctPairWithKnownFirstNode
+### sampleUniformFromContext
 
 ```ts
-resolveDistinctPairWithKnownFirstNode(
-  swappableNodes: default[],
-  firstNode: default,
-  randomValue: () => number,
-): DistinctNodePair | undefined
+sampleUniformFromContext(
+  samplingContext: WeightSamplingRangeContext,
+): number
 ```
 
-Resolves a distinct pair when first node is already known.
+Samples one weight using a prebuilt range context.
 
 Parameters:
-- `swappableNodes` - - Swap candidate nodes.
-- `firstNode` - - Chosen first node.
-- `randomValue` - - Random generator.
+- `samplingContext` - - Sampling range context.
 
-Returns: Distinct pair or undefined.
+Returns: Sampled weight.
 
-### pickDistinctRandomNode
+### selectHiddenNodeForRemoval
 
 ```ts
-pickDistinctRandomNode(
-  nodeCandidates: default[],
-  excludedNode: default,
-  randomValue: () => number,
+selectHiddenNodeForRemoval(
+  network: default,
+  hiddenNodes: default[],
 ): default | undefined
 ```
 
-Picks a random node distinct from a given reference.
+Selects a hidden node candidate for SUB_NODE mutation.
 
 Parameters:
-- `nodeCandidates` - - Candidate nodes.
-- `excludedNode` - - Node to exclude.
-- `randomValue` - - Random generator.
+- `network` - - Target network.
+- `hiddenNodes` - - Hidden nodes.
 
-Returns: Distinct node or undefined.
+Returns: Selected hidden node.
 
-### collectDistinctNodeCandidates
+### splitConnectionThroughHiddenNode
 
 ```ts
-collectDistinctNodeCandidates(
-  nodeCandidates: default[],
-  excludedNode: default,
-): default[]
+splitConnectionThroughHiddenNode(
+  network: default,
+  mutationProps: NetworkMutationProps,
+  connectionToSplit: default,
+): ConnectionSplitResult
 ```
 
-Collects candidates that are distinct from an excluded node.
+Replaces one connection by inserting a hidden node and reconnecting edges.
 
 Parameters:
-- `nodeCandidates` - - Candidate nodes.
-- `excludedNode` - - Node to exclude.
+- `network` - - Target network.
+- `mutationProps` - - Runtime mutation props.
+- `connectionToSplit` - - Connection to split.
 
-Returns: Distinct candidates.
+Returns: Split result values.
 
-### swapNodeBiasAndSquash
+### subBackConn
 
 ```ts
-swapNodeBiasAndSquash(
-  firstNode: default,
-  secondNode: default,
-): void
+subBackConn(): void
 ```
 
-Swaps bias and squash values between two nodes.
+Removes one backward connection that satisfies redundancy constraints.
 
 Parameters:
-- `firstNode` - - First node.
-- `secondNode` - - Second node.
+- `this` - - Bound network.
 
 Returns: Nothing.
 
-### addRecurrentNode
+### subConn
 
 ```ts
-addRecurrentNode(
-  network: default,
-  blockType: "lstm" | "gru",
-): void
+subConn(): void
 ```
 
-Shared orchestrator for recurrent-node mutation variants.
+Removes one forward connection when structural redundancy constraints are satisfied.
+
+Constraints require endpoint redundancy and avoid disconnecting peer-layer groups.
 
 Parameters:
-- `network` - - Target network.
-- `blockType` - - Recurrent block type.
+- `this` - - Bound network.
 
 Returns: Nothing.
 
-### expandConnectionWithRecurrentBlock
+### subGate
 
 ```ts
-expandConnectionWithRecurrentBlock(
-  network: default,
-  connectionToExpand: default,
-  blockType: "lstm" | "gru",
-): void
+subGate(): void
 ```
 
-Replaces one connection with a minimal recurrent block.
+Removes gating from one randomly selected gated connection.
 
 Parameters:
-- `network` - - Target network.
-- `connectionToExpand` - - Connection to replace.
-- `blockType` - - Recurrent block type.
+- `this` - - Bound network.
 
 Returns: Nothing.
 
-### disconnectConnectionAndGetGater
+### subNode
 
 ```ts
-disconnectConnectionAndGetGater(
-  network: default,
-  connectionToExpand: default,
-): default | null
+subNode(): void
 ```
 
-Disconnects a connection and returns its previous gater.
+Removes one hidden node and applies a tiny weight nudge for numerical continuity.
+
+The stability nudge helps keep downstream mutation effects observable in edge cases
+where node removal substantially changes effective signal flow.
 
 Parameters:
-- `network` - - Target network.
-- `connectionToExpand` - - Connection being expanded.
+- `this` - - Bound network.
 
-Returns: Previous gater reference.
+Returns: Nothing.
 
-### reconnectThroughRecurrentLayer
+### subSelfConn
 
 ```ts
-reconnectThroughRecurrentLayer(
-  network: default,
-  connectionToExpand: default,
-  recurrentLayer: RecurrentLayerShape,
-): default | undefined
+subSelfConn(): void
 ```
 
-Reconnects a source/target pair through a recurrent layer.
+Removes one existing self-connection chosen at random.
 
 Parameters:
-- `network` - - Target network.
-- `connectionToExpand` - - Original connection.
-- `recurrentLayer` - - Recurrent-layer shape.
+- `this` - - Bound network.
 
-Returns: Latest newly created connection or undefined.
+Returns: Nothing.
 
-### tryGateLatestConnection
+### swapNodeBiasAndSquash
 
 ```ts
-tryGateLatestConnection(
-  network: default,
-  previousGater: default | null,
-  latestConnection: default | undefined,
+swapNodeBiasAndSquash(
+  firstNode: default,
+  secondNode: default,
 ): void
 ```
 
-Gates the latest connection when both previous gater and target exist.
+Swaps bias and squash values between two nodes.
 
 Parameters:
-- `network` - - Target network.
-- `previousGater` - - Previously assigned gater.
-- `latestConnection` - - Connection to receive the gater.
+- `firstNode` - - First node.
+- `secondNode` - - Second node.
 
 Returns: Nothing.
 
-### createRecurrentLayer
+### swapNodes
 
 ```ts
-createRecurrentLayer(
-  blockType: "lstm" | "gru",
-): RecurrentLayerShape
+swapNodes(
+  method: MutationMethod | undefined,
+): void
 ```
 
-Creates recurrent layer by type.
+Swaps bias and activation squash functions between two distinct mutable nodes.
+
+This provides a lightweight structural-parameter recombination without changing
+graph connectivity.
 
 Parameters:
-- `blockType` - - Recurrent block type.
+- `this` - - Bound network.
+- `method` - - Optional method descriptor.
 
-Returns: Created recurrent layer.
+Returns: Nothing.
 
-### appendRecurrentLayerNodes
+### tryDisconnectConnection
 
 ```ts
-appendRecurrentLayerNodes(
+tryDisconnectConnection(
   network: default,
-  layerNodes: default[],
+  connection: default,
 ): void
 ```
 
-Appends recurrent layer nodes as hidden nodes.
+Disconnects a connection pair while suppressing errors.
 
 Parameters:
 - `network` - - Target network.
-- `layerNodes` - - Layer nodes.
+- `connection` - - Connection to remove.
 
 Returns: Nothing.
 
-### createConnectionGroupReinitContext
-
-```ts
-createConnectionGroupReinitContext(
-  randomValue: () => number,
-  methodObject: { [key: string]: unknown; name?: string | undefined; type?: string | undefined; identity?: string | undefined; max?: number | undefined; min?: number | undefined; mutateOutput?: boolean | undefined; },
-): ConnectionGroupReinitContext
-```
-
-Creates immutable context for connection-group reinitialization.
-
-Parameters:
-- `randomValue` - - Random generator.
-- `methodObject` - - Method override object.
-
-Returns: Reinitialization context.
-
-### collectConnectionGroupsForReinit
+### tryGateLatestConnection
 
 ```ts
-collectConnectionGroupsForReinit(
-  targetNode: default,
-): default[][]
+tryGateLatestConnection(
+  network: default,
+  previousGater: default | null,
+  latestConnection: default | undefined,
+): void
 ```
 
-Collects all connection groups affected by REINIT_WEIGHT.
+Gates the latest connection when both previous gater and target exist.
 
 Parameters:
-- `targetNode` - - Node receiving the reinitialization.
+- `network` - - Target network.
+- `previousGater` - - Previously assigned gater.
+- `latestConnection` - - Connection to receive the gater.
 
-Returns: Mutable connection groups.
+Returns: Nothing.
 
-### reinitializeConnectionGroupWeights
+### tryReassignGateAfterSplit
 
 ```ts
-reinitializeConnectionGroupWeights(
-  connections: default[],
-  reinitContext: ConnectionGroupReinitContext,
+tryReassignGateAfterSplit(
+  network: default,
+  randomValue: () => number,
+  splitResult: ConnectionSplitResult,
 ): void
 ```
 
-Reinitializes all weights in a connection group.
+Reassigns prior gater to one of the new split connections when possible.
 
 Parameters:
-- `connections` - - Connection group.
+- `network` - - Target network.
 - `randomValue` - - Random generator.
-- `minWeight` - - Minimum sampled weight.
-- `maxWeight` - - Maximum sampled weight.
+- `splitResult` - - Split result values.
 
 Returns: Nothing.
 
-### createWeightSamplingRangeContext
-
-```ts
-createWeightSamplingRangeContext(
-  reinitContext: ConnectionGroupReinitContext,
-): WeightSamplingRangeContext
-```
-
-Creates immutable sampling range context.
-
-Parameters:
-- `reinitContext` - - Reinitialization context.
-
-Returns: Sampling range context.
-
-### sampleUniformFromContext
+### warnWhenEnabled
 
 ```ts
-sampleUniformFromContext(
-  samplingContext: WeightSamplingRangeContext,
-): number
+warnWhenEnabled(
+  message: string,
+): void
 ```
 
-Samples one weight using a prebuilt range context.
+Emits a warning when warning mode is enabled.
 
 Parameters:
-- `samplingContext` - - Sampling range context.
+- `message` - - Warning message.
 
-Returns: Sampled weight.
+Returns: Nothing.
 
-### enableNodeBatchNorm
+### wouldDisconnectTargetPeerLayerGroup
 
 ```ts
-enableNodeBatchNorm(
-  node: default,
-): void
+wouldDisconnectTargetPeerLayerGroup(
+  network: default,
+  candidateConnection: default,
+): boolean
 ```
 
-Enables internal batch-norm flag on a node.
+Determines whether removal would disconnect a target peer-layer group.
 
 Parameters:
-- `node` - - Node to flag.
+- `network` - - Target network.
+- `candidateConnection` - - Connection under evaluation.
 
-Returns: Nothing.
+Returns: True when peer group would be disconnected.