@reicek/neataptic-ts 0.1.24 → 0.1.26

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

@@ -52,6 +52,28 @@ Connection view with optional enabled flag.
 Some serialized formats preserve per-edge enablement, while others treat missing values
 as implicitly enabled.
 
+### DEFAULT_NUMERIC_VALUE
+
+Default numeric fallback for absent scalar values.
+
+This keeps import logic deterministic when optional numeric fields are missing.
+
+### ERROR_INVALID_NETWORK_JSON
+
+Error text emitted for invalid verbose JSON payload roots.
+
+### FALLBACK_ACTIVATION_KEY
+
+Fallback activation key used when no mapping is found.
+
+Identity is selected as the safest non-disruptive activation fallback.
+
+### FIRST_CONNECTION_INDEX
+
+Index of the first created connection returned by `connect()`.
+
+The runtime API returns an array, and serializer logic consistently reads index `0`.
+
 ### JsonConnectionRebuildContext
 
 Context for JSON-connection reconstruction.
@@ -64,12 +86,11 @@ Context for JSON-node reconstruction.
 
 Node entries are rebuilt in order and pushed into mutable runtime internals.
 
-### SerializeNetworkInternals
+### NETWORK_JSON_FORMAT_VERSION
 
-Runtime interface for accessing network internals during serialization.
+Default format version for verbose serialization payloads.
 
-This is an internal bridge type used by serializer helpers to read and rebuild
-topology without exposing private implementation details in public APIs.
+Consumers can use this value to identify the JSON schema revision.
 
 ### NetworkInternalsWithDropout
 
@@ -108,11 +129,17 @@ Verbose JSON node representation.
 
 Node entries are self-describing and intended for readable, versioned snapshots.
 
-### SerializeNodeInternals
+### NODE_TYPE_HIDDEN
 
-Runtime node internals needed for serialization workflows.
+Node type literal used for hidden layer nodes.
 
-These fields are the minimal node state required to round-trip compact and JSON payloads.
+### NODE_TYPE_INPUT
+
+Node type literal used for input layer nodes.
+
+### NODE_TYPE_OUTPUT
+
+Node type literal used for output layer nodes.
 
 ### ResolvedNetworkSizeContext
 
@@ -126,53 +153,18 @@ Serialized connection representation used by compact and JSON formats.
 
 Endpoints are canonical node indices, which keeps payloads deterministic and language-agnostic.
 
-### NETWORK_JSON_FORMAT_VERSION
-
-Default format version for verbose serialization payloads.
-
-Consumers can use this value to identify the JSON schema revision.
-
-### DEFAULT_NUMERIC_VALUE
-
-Default numeric fallback for absent scalar values.
-
-This keeps import logic deterministic when optional numeric fields are missing.
-
-### FIRST_CONNECTION_INDEX
-
-Index of the first created connection returned by `connect()`.
-
-The runtime API returns an array, and serializer logic consistently reads index `0`.
-
-### NODE_TYPE_INPUT
-
-Node type literal used for input layer nodes.
-
-### NODE_TYPE_HIDDEN
-
-Node type literal used for hidden layer nodes.
-
-### NODE_TYPE_OUTPUT
-
-Node type literal used for output layer nodes.
-
-### FALLBACK_ACTIVATION_KEY
-
-Fallback activation key used when no mapping is found.
-
-Identity is selected as the safest non-disruptive activation fallback.
-
-### ERROR_INVALID_NETWORK_JSON
+### SerializeNetworkInternals
 
-Error text emitted for invalid verbose JSON payload roots.
+Runtime interface for accessing network internals during serialization.
 
-### WARNING_UNKNOWN_FORMAT_VERSION
+This is an internal bridge type used by serializer helpers to read and rebuild
+topology without exposing private implementation details in public APIs.
 
-Warning emitted for unknown verbose format versions.
+### SerializeNodeInternals
 
-### WARNING_INVALID_GATER_DURING_DESERIALIZE
+Runtime node internals needed for serialization workflows.
 
-Warning emitted when compact deserialize sees an invalid gater index.
+These fields are the minimal node state required to round-trip compact and JSON payloads.
 
 ### WARNING_INVALID_CONNECTION_DURING_DESERIALIZE
 
@@ -182,10 +174,18 @@ Warning emitted when compact deserialize sees invalid edge endpoints.
 
 Warning emitted when JSON deserialize sees invalid edge endpoints.
 
+### WARNING_INVALID_GATER_DURING_DESERIALIZE
+
+Warning emitted when compact deserialize sees an invalid gater index.
+
 ### WARNING_INVALID_GATER_DURING_FROM_JSON
 
 Warning emitted when JSON deserialize sees an invalid gater index.
 
+### WARNING_UNKNOWN_FORMAT_VERSION
+
+Warning emitted for unknown verbose format versions.
+
 ### WARNING_UNKNOWN_SQUASH_PREFIX
 
 Prefix used when warning about unknown activation keys.
@@ -196,65 +196,49 @@ Suffix used when warning about unknown activation keys.
 
 ## architecture/network/serialize/network.serialize.utils.ts
 
-### serialize
-
-```ts
-serialize(): CompactSerializedNetworkTuple
-```
-
-Serializes a network instance into the compact tuple format.
+### network.serialize.utils
 
-Use this format when payload size and serialization speed matter more than readability.
-The tuple layout is positional and optimized for transport/storage efficiency.
+Connection (Synapse / Edge)
+===========================
+Directed weighted link between two nodes. The connection keeps the everyday
+graph fields (`from`, `to`, `weight`, `innovation`) directly on the instance,
+then pushes rarer capabilities behind symbol-backed accessors so large
+populations do not pay object-shape costs for features they are not using.
 
-Parameters:
-- `this` - - Bound network instance.
+This makes the boundary useful in three different modes:
 
-Returns: Compact tuple payload containing activations, states, squash keys, connections, and input/output sizes.
+- ordinary feed-forward links that only need endpoints and weight,
+- gated or plastic links that gradually opt into extra runtime state,
+- optimizer-heavy training paths that need moment buffers without turning
+  every connection into a bloated record.
 
 Example:
 
 ```ts
-import Network from '../../network';
-import { deserialize, serialize } from './network.serialize.utils';
+const source = new Node('input');
+const target = new Node('output');
+const edge = new Connection(source, target, 0.42);
 
-const sourceNetwork = new Network(2, 1);
-const compactTuple = serialize.call(sourceNetwork);
-const rebuiltNetwork = deserialize(compactTuple);
+edge.gain = 1.5;
+edge.enabled = true;
 ```
 
-### toJSONImpl
+### applyHydratedArchitectureDescriptor
 
 ```ts
-toJSONImpl(): NetworkJSON
+applyHydratedArchitectureDescriptor(
+  network: default,
+  architectureDescriptor: NetworkArchitectureDescriptor | undefined,
+): void
 ```
 
-Serializes a network instance into the verbose JSON format.
-
-Use this format when you need human-readable snapshots, explicit schema versioning,
-and better forward/backward compatibility handling.
+Applies hydrated architecture metadata to runtime network when shape is valid.
 
 Parameters:
-- `this` - - Bound network instance.
-
-Returns: Versioned JSON payload with shape metadata, nodes, and connections.
-
-Example:
-
-```ts
-import Network from '../../network';
-import { fromJSONImpl, toJSONImpl } from './network.serialize.utils';
-
-const sourceNetwork = new Network(3, 1);
-const snapshotJson = toJSONImpl.call(sourceNetwork);
-const rebuiltNetwork = fromJSONImpl(snapshotJson);
-```
-
-### SerializedConnection
-
-Serialized connection representation used by compact and JSON formats.
+- `network` - - Rebuilt network instance.
+- `architectureDescriptor` - - Optional serialized descriptor.
 
-Endpoints are canonical node indices, which keeps payloads deterministic and language-agnostic.
+Returns: Nothing.
 
 ### deserialize
 
@@ -312,62 +296,78 @@ import { fromJSONImpl } from './network.serialize.utils';
 const rebuiltNetwork = fromJSONImpl(snapshotJson);
 ```
 
-### network.serialize.utils
+### isArchitectureDescriptorShapeValid
 
-Connection (Synapse / Edge)
-===========================
-Directed weighted link between two nodes. The connection keeps the everyday
-graph fields (`from`, `to`, `weight`, `innovation`) directly on the instance,
-then pushes rarer capabilities behind symbol-backed accessors so large
-populations do not pay object-shape costs for features they are not using.
+```ts
+isArchitectureDescriptorShapeValid(
+  architectureDescriptor: NetworkArchitectureDescriptor | undefined,
+): boolean
+```
 
-This makes the boundary useful in three different modes:
+Parameters:
+- `architectureDescriptor` - - Optional descriptor candidate.
 
-- ordinary feed-forward links that only need endpoints and weight,
-- gated or plastic links that gradually opt into extra runtime state,
-- optimizer-heavy training paths that need moment buffers without turning
-  every connection into a bloated record.
+Returns: True when minimal descriptor shape is valid.
 
-Example:
+### serialize
 
 ```ts
-const source = new Node('input');
-const target = new Node('output');
-const edge = new Connection(source, target, 0.42);
-
-edge.gain = 1.5;
-edge.enabled = true;
+serialize(): CompactSerializedNetworkTuple
 ```
 
-### applyHydratedArchitectureDescriptor
+Serializes a network instance into the compact tuple format.
+
+Use this format when payload size and serialization speed matter more than readability.
+The tuple layout is positional and optimized for transport/storage efficiency.
+
+Parameters:
+- `this` - - Bound network instance.
+
+Returns: Compact tuple payload containing activations, states, squash keys, connections, and input/output sizes.
+
+Example:
 
 ```ts
-applyHydratedArchitectureDescriptor(
-  network: default,
-  architectureDescriptor: NetworkArchitectureDescriptor | undefined,
-): void
+import Network from '../../network';
+import { deserialize, serialize } from './network.serialize.utils';
+
+const sourceNetwork = new Network(2, 1);
+const compactTuple = serialize.call(sourceNetwork);
+const rebuiltNetwork = deserialize(compactTuple);
 ```
 
-Applies hydrated architecture metadata to runtime network when shape is valid.
+### SerializedConnection
 
-Parameters:
-- `network` - - Rebuilt network instance.
-- `architectureDescriptor` - - Optional serialized descriptor.
+Serialized connection representation used by compact and JSON formats.
 
-Returns: Nothing.
+Endpoints are canonical node indices, which keeps payloads deterministic and language-agnostic.
 
-### isArchitectureDescriptorShapeValid
+### toJSONImpl
 
 ```ts
-isArchitectureDescriptorShapeValid(
-  architectureDescriptor: NetworkArchitectureDescriptor | undefined,
-): boolean
+toJSONImpl(): NetworkJSON
 ```
 
+Serializes a network instance into the verbose JSON format.
+
+Use this format when you need human-readable snapshots, explicit schema versioning,
+and better forward/backward compatibility handling.
+
 Parameters:
-- `architectureDescriptor` - - Optional descriptor candidate.
+- `this` - - Bound network instance.
 
-Returns: True when minimal descriptor shape is valid.
+Returns: Versioned JSON payload with shape metadata, nodes, and connections.
+
+Example:
+
+```ts
+import Network from '../../network';
+import { fromJSONImpl, toJSONImpl } from './network.serialize.utils';
+
+const sourceNetwork = new Network(3, 1);
+const snapshotJson = toJSONImpl.call(sourceNetwork);
+const rebuiltNetwork = fromJSONImpl(snapshotJson);
+```
 
 ### default
 
@@ -569,44 +569,24 @@ Extended trace structure for modulatory / eligibility propagation algorithms. Pa
 
 ## architecture/network/serialize/network.serialize.json.utils.ts
 
-### createEmptyNetworkJson
+### appendJsonForwardConnections
 
 ```ts
-createEmptyNetworkJson(
-  networkInternals: NetworkInternalsWithDropout,
-): NetworkJSON
-```
-
-Creates an empty verbose JSON shell from runtime internals.
-
-The shell includes format and shape metadata and is filled in by subsequent
-node and connection append steps.
-
-Parameters:
-- `networkInternals` - - Runtime internals with optional dropout.
-
-Returns: Empty JSON shell with `formatVersion` and scalar metadata initialized.
-
-Example:
-
-```ts
-const networkJson = createEmptyNetworkJson(networkInternals);
+appendJsonForwardConnections(
+  networkInternals: SerializeNetworkInternals,
+  networkJson: NetworkJSON,
+): void
 ```
 
-### resolveDropout
-
-```ts
-resolveDropout(
-  dropout: number | undefined,
-): number
-```
+Appends JSON entries for forward connections.
 
-Resolves dropout with a numeric fallback when the value is absent.
+Non-finite endpoint indices are ignored to prevent malformed output records.
 
 Parameters:
-- `dropout` - - Optional dropout value.
+- `networkInternals` - - Runtime internals.
+- `networkJson` - - JSON accumulator.
 
-Returns: Effective dropout.
+Returns: Nothing.
 
 ### appendJsonNodesAndSelfConnections
 
@@ -628,140 +608,106 @@ Parameters:
 
 Returns: Nothing.
 
-### appendJsonForwardConnections
+### appendJsonSelfConnectionWhenPresent
 
 ```ts
-appendJsonForwardConnections(
-  networkInternals: SerializeNetworkInternals,
+appendJsonSelfConnectionWhenPresent(
+  nodeInternals: SerializeNodeInternals,
+  nodeIndex: number,
   networkJson: NetworkJSON,
 ): void
 ```
 
-Appends JSON entries for forward connections.
-
-Non-finite endpoint indices are ignored to prevent malformed output records.
+Appends JSON self-connection when node has one.
 
 Parameters:
-- `networkInternals` - - Runtime internals.
+- `nodeInternals` - - Node internals.
+- `nodeIndex` - - Node index.
 - `networkJson` - - JSON accumulator.
 
 Returns: Nothing.
 
-### validateNetworkJsonOrThrow
+### assignJsonEnabledFlagWhenProvided
 
 ```ts
-validateNetworkJsonOrThrow(
-  json: NetworkJSON,
+assignJsonEnabledFlagWhenProvided(
+  createdConnection: default | undefined,
+  enabled: boolean,
 ): void
 ```
 
-Validates the verbose JSON payload root shape.
+Assigns enabled flag when value is provided.
 
 Parameters:
-- `json` - - Payload candidate.
+- `createdConnection` - - Created connection.
+- `enabled` - - Optional enabled value.
 
 Returns: Nothing.
 
-### warnWhenJsonFormatVersionIsUnknown
+### assignJsonGaterWhenValid
 
 ```ts
-warnWhenJsonFormatVersionIsUnknown(
-  formatVersion: number,
+assignJsonGaterWhenValid(
+  networkInternals: SerializeNetworkInternals,
+  gaterIndex: number | null,
+  createdConnection: default | undefined,
 ): void
 ```
 
-Warns when incoming verbose format version differs from the expected one.
+Assigns JSON gater when connection and gater index are valid.
 
 Parameters:
-- `formatVersion` - - Incoming format version.
+- `networkInternals` - - Runtime internals.
+- `gaterIndex` - - Optional gater index.
+- `createdConnection` - - Created connection.
 
 Returns: Nothing.
 
-### rebuildNodesFromJsonPayload
+### createConnection
 
 ```ts
-rebuildNodesFromJsonPayload(
-  jsonNodeContext: JsonNodeRebuildContext,
-): void
+createConnection(
+  networkInternals: SerializeNetworkInternals,
+  sourceNode: default,
+  targetNode: default,
+  weight: number,
+): default | undefined
 ```
 
-Rebuilds runtime nodes from verbose JSON entries.
+Creates one connection and returns first created instance.
 
 Parameters:
-- `jsonNodeContext` - - JSON node rebuild context.
-
-Returns: Nothing.
-
-Example:
+- `networkInternals` - - Runtime internals.
+- `sourceNode` - - Source node.
+- `targetNode` - - Target node.
+- `weight` - - Connection weight.
 
-```ts
-rebuildNodesFromJsonPayload({ networkInternals, nodeJsonEntries });
-```
+Returns: Created connection or undefined.
 
-### rebuildConnectionsFromJsonPayload
+### createEmptyNetworkJson
 
 ```ts
-rebuildConnectionsFromJsonPayload(
-  jsonConnectionContext: JsonConnectionRebuildContext,
-): void
+createEmptyNetworkJson(
+  networkInternals: NetworkInternalsWithDropout,
+): NetworkJSON
 ```
 
-Rebuilds runtime connections from verbose JSON entries.
+Creates an empty verbose JSON shell from runtime internals.
 
-Invalid entries are skipped with warnings so import continues for valid records.
+The shell includes format and shape metadata and is filled in by subsequent
+node and connection append steps.
 
 Parameters:
-- `jsonConnectionContext` - - JSON connection rebuild context.
+- `networkInternals` - - Runtime internals with optional dropout.
 
-Returns: Nothing.
+Returns: Empty JSON shell with `formatVersion` and scalar metadata initialized.
 
 Example:
 
 ```ts
-rebuildConnectionsFromJsonPayload({
-  networkInternals,
-  connectionJsonEntries,
-});
-```
-
-### createJsonNode
-
-```ts
-createJsonNode(
-  node: default,
-  nodeInternals: SerializeNodeInternals,
-  nodeIndex: number,
-): NetworkJSONNode
-```
-
-Creates one JSON node entry.
-
-Parameters:
-- `node` - - Runtime node.
-- `nodeInternals` - - Node internals.
-- `nodeIndex` - - Canonical index.
-
-Returns: JSON node entry.
-
-### appendJsonSelfConnectionWhenPresent
-
-```ts
-appendJsonSelfConnectionWhenPresent(
-  nodeInternals: SerializeNodeInternals,
-  nodeIndex: number,
-  networkJson: NetworkJSON,
-): void
+const networkJson = createEmptyNetworkJson(networkInternals);
 ```
 
-Appends JSON self-connection when node has one.
-
-Parameters:
-- `nodeInternals` - - Node internals.
-- `nodeIndex` - - Node index.
-- `networkJson` - - JSON accumulator.
-
-Returns: Nothing.
-
 ### createJsonConnection
 
 ```ts
@@ -785,35 +731,39 @@ Parameters:
 
 Returns: JSON connection entry.
 
-### resolveGaterIndex
+### createJsonNode
 
 ```ts
-resolveGaterIndex(
-  gaterNode: default | null,
-): number | null
+createJsonNode(
+  node: default,
+  nodeInternals: SerializeNodeInternals,
+  nodeIndex: number,
+): NetworkJSONNode
 ```
 
-Resolves gater node index from gater reference.
+Creates one JSON node entry.
 
 Parameters:
-- `gaterNode` - - Optional gater node.
+- `node` - - Runtime node.
+- `nodeInternals` - - Node internals.
+- `nodeIndex` - - Canonical index.
 
-Returns: Gater index or null.
+Returns: JSON node entry.
 
-### isConnectionEnabled
+### createNodeWithType
 
 ```ts
-isConnectionEnabled(
-  connectionInstance: default,
-): boolean
+createNodeWithType(
+  nodeType: string,
+): default
 ```
 
-Resolves enabled status from optional connection flag.
+Creates one node with provided type.
 
 Parameters:
-- `connectionInstance` - - Connection instance.
+- `nodeType` - - Node type.
 
-Returns: True when connection is enabled.
+Returns: New node.
 
 ### hydrateNodeFromJsonEntry
 
@@ -834,37 +784,20 @@ Parameters:
 
 Returns: Nothing.
 
-### rebuildOneJsonConnection
-
-```ts
-rebuildOneJsonConnection(
-  networkInternals: SerializeNetworkInternals,
-  connectionJsonEntry: NetworkJSONConnection,
-): void
-```
-
-Rebuilds one verbose JSON connection entry.
-
-Parameters:
-- `networkInternals` - - Runtime internals.
-- `connectionJsonEntry` - - JSON connection entry.
-
-Returns: Nothing.
-
-### isJsonConnectionShapeValid
+### isConnectionEnabled
 
 ```ts
-isJsonConnectionShapeValid(
-  connectionJsonEntry: NetworkJSONConnection,
+isConnectionEnabled(
+  connectionInstance: default,
 ): boolean
 ```
 
-Checks that JSON connection has numeric endpoint fields.
+Resolves enabled status from optional connection flag.
 
 Parameters:
-- `connectionJsonEntry` - - JSON connection entry.
+- `connectionInstance` - - Connection instance.
 
-Returns: True when endpoint fields are numbers.
+Returns: True when connection is enabled.
 
 ### isJsonConnectionInNodeBounds
 
@@ -883,77 +816,144 @@ Parameters:
 
 Returns: True when both indices are valid.
 
-### createConnection
+### isJsonConnectionShapeValid
 
 ```ts
-createConnection(
-  networkInternals: SerializeNetworkInternals,
-  sourceNode: default,
-  targetNode: default,
-  weight: number,
-): default | undefined
+isJsonConnectionShapeValid(
+  connectionJsonEntry: NetworkJSONConnection,
+): boolean
 ```
 
-Creates one connection and returns first created instance.
+Checks that JSON connection has numeric endpoint fields.
 
 Parameters:
-- `networkInternals` - - Runtime internals.
-- `sourceNode` - - Source node.
-- `targetNode` - - Target node.
-- `weight` - - Connection weight.
+- `connectionJsonEntry` - - JSON connection entry.
 
-Returns: Created connection or undefined.
+Returns: True when endpoint fields are numbers.
 
-### assignJsonGaterWhenValid
+### rebuildConnectionsFromJsonPayload
 
 ```ts
-assignJsonGaterWhenValid(
-  networkInternals: SerializeNetworkInternals,
-  gaterIndex: number | null,
-  createdConnection: default | undefined,
+rebuildConnectionsFromJsonPayload(
+  jsonConnectionContext: JsonConnectionRebuildContext,
 ): void
 ```
 
-Assigns JSON gater when connection and gater index are valid.
+Rebuilds runtime connections from verbose JSON entries.
+
+Invalid entries are skipped with warnings so import continues for valid records.
 
 Parameters:
-- `networkInternals` - - Runtime internals.
-- `gaterIndex` - - Optional gater index.
-- `createdConnection` - - Created connection.
+- `jsonConnectionContext` - - JSON connection rebuild context.
 
 Returns: Nothing.
 
-### assignJsonEnabledFlagWhenProvided
+Example:
 
 ```ts
-assignJsonEnabledFlagWhenProvided(
-  createdConnection: default | undefined,
-  enabled: boolean,
+rebuildConnectionsFromJsonPayload({
+  networkInternals,
+  connectionJsonEntries,
+});
+```
+
+### rebuildNodesFromJsonPayload
+
+```ts
+rebuildNodesFromJsonPayload(
+  jsonNodeContext: JsonNodeRebuildContext,
 ): void
 ```
 
-Assigns enabled flag when value is provided.
+Rebuilds runtime nodes from verbose JSON entries.
 
 Parameters:
-- `createdConnection` - - Created connection.
-- `enabled` - - Optional enabled value.
+- `jsonNodeContext` - - JSON node rebuild context.
 
 Returns: Nothing.
 
-### createNodeWithType
+Example:
 
 ```ts
-createNodeWithType(
-  nodeType: string,
-): default
+rebuildNodesFromJsonPayload({ networkInternals, nodeJsonEntries });
 ```
 
-Creates one node with provided type.
+### rebuildOneJsonConnection
+
+```ts
+rebuildOneJsonConnection(
+  networkInternals: SerializeNetworkInternals,
+  connectionJsonEntry: NetworkJSONConnection,
+): void
+```
+
+Rebuilds one verbose JSON connection entry.
 
 Parameters:
-- `nodeType` - - Node type.
+- `networkInternals` - - Runtime internals.
+- `connectionJsonEntry` - - JSON connection entry.
 
-Returns: New node.
+Returns: Nothing.
+
+### resolveDropout
+
+```ts
+resolveDropout(
+  dropout: number | undefined,
+): number
+```
+
+Resolves dropout with a numeric fallback when the value is absent.
+
+Parameters:
+- `dropout` - - Optional dropout value.
+
+Returns: Effective dropout.
+
+### resolveGaterIndex
+
+```ts
+resolveGaterIndex(
+  gaterNode: default | null,
+): number | null
+```
+
+Resolves gater node index from gater reference.
+
+Parameters:
+- `gaterNode` - - Optional gater node.
+
+Returns: Gater index or null.
+
+### validateNetworkJsonOrThrow
+
+```ts
+validateNetworkJsonOrThrow(
+  json: NetworkJSON,
+): void
+```
+
+Validates the verbose JSON payload root shape.
+
+Parameters:
+- `json` - - Payload candidate.
+
+Returns: Nothing.
+
+### warnWhenJsonFormatVersionIsUnknown
+
+```ts
+warnWhenJsonFormatVersionIsUnknown(
+  formatVersion: number,
+): void
+```
+
+Warns when incoming verbose format version differs from the expected one.
+
+Parameters:
+- `formatVersion` - - Incoming format version.
+
+Returns: Nothing.
 
 ## architecture/network/serialize/network.serialize.public.utils.ts
 
@@ -976,53 +976,54 @@ Returns: Deep-cloned network instance.
 
 ## architecture/network/serialize/network.serialize.compact.utils.ts
 
-### refreshNodeIndices
+### assignCompactGaterWhenValid
 
 ```ts
-refreshNodeIndices(
-  nodes: default[],
+assignCompactGaterWhenValid(
+  networkInternals: SerializeNetworkInternals,
+  gaterIndex: number | null,
+  createdConnection: default | undefined,
 ): void
 ```
 
-Refreshes `node.index` for each node in list order.
-
-Canonical indices are required so compact connection records can store endpoints
-and gaters as stable numeric positions.
+Assigns compact gater when both connection and gater index are valid.
 
 Parameters:
-- `nodes` - - Node list.
+- `networkInternals` - - Runtime internals.
+- `gaterIndex` - - Optional gater index.
+- `createdConnection` - - Created connection.
 
 Returns: Nothing.
 
-### collectNodeActivations
+### collectAllConnections
 
 ```ts
-collectNodeActivations(
-  nodes: default[],
-): number[]
+collectAllConnections(
+  networkInternals: SerializeNetworkInternals,
+): default[]
 ```
 
-Collects node activation values in positional order.
+Collects all runtime connections into a single list.
 
 Parameters:
-- `nodes` - - Node list.
+- `networkInternals` - - Runtime internals.
 
-Returns: Activation list aligned to node indices.
+Returns: Combined connections.
 
-### collectNodeStates
+### collectNodeActivations
 
 ```ts
-collectNodeStates(
+collectNodeActivations(
   nodes: default[],
 ): number[]
 ```
 
-Collects node state values in positional order.
+Collects node activation values in positional order.
 
 Parameters:
 - `nodes` - - Node list.
 
-Returns: State list aligned to node indices.
+Returns: Activation list aligned to node indices.
 
 ### collectNodeSquashKeys
 
@@ -1041,6 +1042,21 @@ Parameters:
 
 Returns: Squash-key list aligned to node indices.
 
+### collectNodeStates
+
+```ts
+collectNodeStates(
+  nodes: default[],
+): number[]
+```
+
+Collects node state values in positional order.
+
+Parameters:
+- `nodes` - - Node list.
+
+Returns: State list aligned to node indices.
+
 ### collectSerializedConnections
 
 ```ts
@@ -1056,149 +1072,136 @@ Parameters:
 
 Returns: Serialized connection list.
 
-### rebuildNodesFromCompactPayload
+### createConnection
 
 ```ts
-rebuildNodesFromCompactPayload(
+createConnection(
   networkInternals: SerializeNetworkInternals,
-  compactNodeContext: CompactNodeRebuildContext,
-): void
+  sourceNode: default,
+  targetNode: default,
+  weight: number,
+): default | undefined
 ```
 
-Rebuilds runtime nodes from compact payload arrays.
-
-Node type is inferred from index position relative to input/output boundaries.
+Creates one connection and returns first created instance.
 
 Parameters:
 - `networkInternals` - - Runtime internals.
-- `compactNodeContext` - - Compact node rebuild context.
+- `sourceNode` - - Source node.
+- `targetNode` - - Target node.
+- `weight` - - Connection weight.
 
-Returns: Nothing.
+Returns: Created connection or undefined.
 
-Example:
+### createNodeWithType
 
 ```ts
-import { rebuildNodesFromCompactPayload } from './network.serialize.compact.utils';
-
-rebuildNodesFromCompactPayload(networkInternals, compactNodeContext);
+createNodeWithType(
+  nodeType: string,
+): default
 ```
 
-### rebuildConnectionsFromCompactPayload
+Creates one node with provided type.
+
+Parameters:
+- `nodeType` - - Node type.
+
+Returns: New node.
+
+### hydrateNodeStateFromCompactPayload
 
 ```ts
-rebuildConnectionsFromCompactPayload(
-  compactConnectionContext: CompactConnectionRebuildContext,
+hydrateNodeStateFromCompactPayload(
+  rebuiltNode: default,
+  activation: number,
+  state: number,
+  squashName: string | undefined,
+  nodeIndex: number,
 ): void
 ```
 
-Rebuilds runtime connections from compact connection records.
-
-Invalid endpoint or gater indices are skipped with warnings to preserve import flow.
+Hydrates node runtime state from compact tuple values.
 
 Parameters:
-- `compactConnectionContext` - - Compact connection rebuild context.
+- `rebuiltNode` - - Node to hydrate.
+- `activation` - - Activation value.
+- `state` - - State value.
+- `squashName` - - Activation key.
+- `nodeIndex` - - Canonical node index.
 
 Returns: Nothing.
 
-Example:
-
-```ts
-import { rebuildConnectionsFromCompactPayload } from './network.serialize.compact.utils';
-
-rebuildConnectionsFromCompactPayload({
-  networkInternals,
-  serializedConnections,
-});
-```
-
-### collectAllConnections
+### isSerializedConnectionInNodeBounds
 
 ```ts
-collectAllConnections(
+isSerializedConnectionInNodeBounds(
   networkInternals: SerializeNetworkInternals,
-): default[]
+  serializedConnection: SerializedConnection,
+): boolean
 ```
 
-Collects all runtime connections into a single list.
+Checks compact connection bounds against current node list.
 
 Parameters:
 - `networkInternals` - - Runtime internals.
+- `serializedConnection` - - Serialized connection record.
 
-Returns: Combined connections.
+Returns: True when endpoints are valid.
 
-### serializeOneConnection
+### rebuildConnectionsFromCompactPayload
 
 ```ts
-serializeOneConnection(
-  connectionInstance: default,
-): SerializedConnection
+rebuildConnectionsFromCompactPayload(
+  compactConnectionContext: CompactConnectionRebuildContext,
+): void
 ```
 
-Serializes one connection into compact indexed form.
+Rebuilds runtime connections from compact connection records.
+
+Invalid endpoint or gater indices are skipped with warnings to preserve import flow.
 
 Parameters:
-- `connectionInstance` - - Runtime connection.
+- `compactConnectionContext` - - Compact connection rebuild context.
 
-Returns: Serialized connection record.
+Returns: Nothing.
 
-### resolveNodeTypeFromCompactIndex
+Example:
 
 ```ts
-resolveNodeTypeFromCompactIndex(
-  nodeIndex: number,
-  totalNodeCount: number,
-  input: number,
-  output: number,
-): string
-```
-
-Resolves node type from compact tuple position.
-
-Parameters:
-- `nodeIndex` - - Node index.
-- `totalNodeCount` - - Total node count.
-- `input` - - Input size.
-- `output` - - Output size.
+import { rebuildConnectionsFromCompactPayload } from './network.serialize.compact.utils';
 
-Returns: Node type string.
+rebuildConnectionsFromCompactPayload({
+  networkInternals,
+  serializedConnections,
+});
+```
 
-### createNodeWithType
+### rebuildNodesFromCompactPayload
 
 ```ts
-createNodeWithType(
-  nodeType: string,
-): default
+rebuildNodesFromCompactPayload(
+  networkInternals: SerializeNetworkInternals,
+  compactNodeContext: CompactNodeRebuildContext,
+): void
 ```
 
-Creates one node with provided type.
+Rebuilds runtime nodes from compact payload arrays.
+
+Node type is inferred from index position relative to input/output boundaries.
 
 Parameters:
-- `nodeType` - - Node type.
+- `networkInternals` - - Runtime internals.
+- `compactNodeContext` - - Compact node rebuild context.
 
-Returns: New node.
+Returns: Nothing.
 
-### hydrateNodeStateFromCompactPayload
+Example:
 
 ```ts
-hydrateNodeStateFromCompactPayload(
-  rebuiltNode: default,
-  activation: number,
-  state: number,
-  squashName: string | undefined,
-  nodeIndex: number,
-): void
-```
-
-Hydrates node runtime state from compact tuple values.
-
-Parameters:
-- `rebuiltNode` - - Node to hydrate.
-- `activation` - - Activation value.
-- `state` - - State value.
-- `squashName` - - Activation key.
-- `nodeIndex` - - Canonical node index.
+import { rebuildNodesFromCompactPayload } from './network.serialize.compact.utils';
 
-Returns: Nothing.
+rebuildNodesFromCompactPayload(networkInternals, compactNodeContext);
+```
 
 ### rebuildOneCompactConnection
 
@@ -1217,62 +1220,59 @@ Parameters:
 
 Returns: Nothing.
 
-### isSerializedConnectionInNodeBounds
+### refreshNodeIndices
 
 ```ts
-isSerializedConnectionInNodeBounds(
-  networkInternals: SerializeNetworkInternals,
-  serializedConnection: SerializedConnection,
-): boolean
+refreshNodeIndices(
+  nodes: default[],
+): void
 ```
 
-Checks compact connection bounds against current node list.
+Refreshes `node.index` for each node in list order.
+
+Canonical indices are required so compact connection records can store endpoints
+and gaters as stable numeric positions.
 
 Parameters:
-- `networkInternals` - - Runtime internals.
-- `serializedConnection` - - Serialized connection record.
+- `nodes` - - Node list.
 
-Returns: True when endpoints are valid.
+Returns: Nothing.
 
-### createConnection
+### resolveNodeTypeFromCompactIndex
 
 ```ts
-createConnection(
-  networkInternals: SerializeNetworkInternals,
-  sourceNode: default,
-  targetNode: default,
-  weight: number,
-): default | undefined
+resolveNodeTypeFromCompactIndex(
+  nodeIndex: number,
+  totalNodeCount: number,
+  input: number,
+  output: number,
+): string
 ```
 
-Creates one connection and returns first created instance.
+Resolves node type from compact tuple position.
 
 Parameters:
-- `networkInternals` - - Runtime internals.
-- `sourceNode` - - Source node.
-- `targetNode` - - Target node.
-- `weight` - - Connection weight.
+- `nodeIndex` - - Node index.
+- `totalNodeCount` - - Total node count.
+- `input` - - Input size.
+- `output` - - Output size.
 
-Returns: Created connection or undefined.
+Returns: Node type string.
 
-### assignCompactGaterWhenValid
+### serializeOneConnection
 
 ```ts
-assignCompactGaterWhenValid(
-  networkInternals: SerializeNetworkInternals,
-  gaterIndex: number | null,
-  createdConnection: default | undefined,
-): void
+serializeOneConnection(
+  connectionInstance: default,
+): SerializedConnection
 ```
 
-Assigns compact gater when both connection and gater index are valid.
+Serializes one connection into compact indexed form.
 
 Parameters:
-- `networkInternals` - - Runtime internals.
-- `gaterIndex` - - Optional gater index.
-- `createdConnection` - - Created connection.
+- `connectionInstance` - - Runtime connection.
 
-Returns: Nothing.
+Returns: Serialized connection record.
 
 ## architecture/network/serialize/network.serialize.runtime.utils.ts
 
@@ -1345,60 +1345,54 @@ Example:
 const compactPayload = createCompactPayloadContext(compactTuple);
 ```
 
-### resolveNetworkSize
+### createNetworkInstance
 
 ```ts
-resolveNetworkSize(
-  compactPayload: CompactPayloadContext,
-  inputSizeOverride: number | undefined,
-  outputSizeOverride: number | undefined,
-): ResolvedNetworkSizeContext
+createNetworkInstance(
+  input: number,
+  output: number,
+): default
 ```
 
-Resolves effective input/output dimensions using optional explicit overrides.
-
-When an override is provided, it takes precedence over serialized values.
+Creates a new network instance for deserialize workflows.
 
 Parameters:
-- `compactPayload` - - Compact payload context.
-- `inputSizeOverride` - - Optional input override.
-- `outputSizeOverride` - - Optional output override.
+- `input` - - Input size.
+- `output` - - Output size.
 
-Returns: Resolved network size context.
+Returns: New network instance.
 
-### resolveSizeOverride
+### isFiniteIndex
 
 ```ts
-resolveSizeOverride(
-  overrideValue: number | undefined,
-  serializedValue: number,
-): number
+isFiniteIndex(
+  index: number,
+): boolean
 ```
 
-Resolves one size value with override-first semantics.
+Checks whether a candidate index value is a finite number.
 
 Parameters:
-- `overrideValue` - - Optional explicit override.
-- `serializedValue` - - Serialized fallback value.
+- `index` - - Candidate index value.
 
-Returns: Effective size.
+Returns: True when finite number.
 
-### createNetworkInstance
+### isNodeIndexInBounds
 
 ```ts
-createNetworkInstance(
-  input: number,
-  output: number,
-): default
+isNodeIndexInBounds(
+  nodes: default[],
+  index: number,
+): boolean
 ```
 
-Creates a new network instance for deserialize workflows.
+Checks whether an index is inside the bounds of a node array.
 
 Parameters:
-- `input` - - Input size.
-- `output` - - Output size.
+- `nodes` - - Node list.
+- `index` - - Candidate index.
 
-Returns: New network instance.
+Returns: True when index is valid.
 
 ### resetMutableRuntimeCollections
 
@@ -1415,66 +1409,91 @@ Parameters:
 
 Returns: Nothing.
 
-### isNodeIndexInBounds
+### resolveNetworkSize
 
 ```ts
-isNodeIndexInBounds(
-  nodes: default[],
-  index: number,
-): boolean
+resolveNetworkSize(
+  compactPayload: CompactPayloadContext,
+  inputSizeOverride: number | undefined,
+  outputSizeOverride: number | undefined,
+): ResolvedNetworkSizeContext
 ```
 
-Checks whether an index is inside the bounds of a node array.
+Resolves effective input/output dimensions using optional explicit overrides.
+
+When an override is provided, it takes precedence over serialized values.
 
 Parameters:
-- `nodes` - - Node list.
-- `index` - - Candidate index.
+- `compactPayload` - - Compact payload context.
+- `inputSizeOverride` - - Optional input override.
+- `outputSizeOverride` - - Optional output override.
 
-Returns: True when index is valid.
+Returns: Resolved network size context.
 
-### isFiniteIndex
+### resolveSizeOverride
 
 ```ts
-isFiniteIndex(
-  index: number,
-): boolean
+resolveSizeOverride(
+  overrideValue: number | undefined,
+  serializedValue: number,
+): number
 ```
 
-Checks whether a candidate index value is a finite number.
+Resolves one size value with override-first semantics.
 
 Parameters:
-- `index` - - Candidate index value.
+- `overrideValue` - - Optional explicit override.
+- `serializedValue` - - Serialized fallback value.
 
-Returns: True when finite number.
+Returns: Effective size.
 
 ## architecture/network/serialize/network.serialize.activation.utils.ts
 
-### resolveActivationKey
+### findActivationByFunctionName
 
 ```ts
-resolveActivationKey(
-  squashFunction: ActivationFunction,
-): string
+findActivationByFunctionName(
+  squashName: string | undefined,
+): ActivationFunction | undefined
 ```
 
-Resolves a canonical activation key from a runtime activation function reference.
-
-Resolution order is: direct registry reference match, then the function name,
-then a stable identity fallback key.
+Resolves activation by matching function.name.
 
 Parameters:
-- `squashFunction` - - Activation function instance.
+- `squashName` - - Activation function name.
 
-Returns: Activation key.
+Returns: Activation function or undefined.
 
-Example:
+### findActivationByKey
 
 ```ts
-import * as methods from '../../../methods/methods';
+findActivationByKey(
+  squashName: string | undefined,
+): ActivationFunction | undefined
+```
 
-const key = resolveActivationKey(methods.Activation.tanh);
+Resolves activation by direct key lookup.
+
+Parameters:
+- `squashName` - - Activation key.
+
+Returns: Activation function or undefined.
+
+### findActivationEntryByReference
+
+```ts
+findActivationEntryByReference(
+  squashFunction: ActivationFunction,
+): [string, ActivationFunction] | undefined
 ```
 
+Finds activation entry by function reference.
+
+Parameters:
+- `squashFunction` - - Activation function instance.
+
+Returns: Activation entry or undefined.
+
 ### resolveActivationFunction
 
 ```ts
@@ -1499,20 +1518,31 @@ Example:
 const squashFunction = resolveActivationFunction('relu');
 ```
 
-### findActivationEntryByReference
+### resolveActivationKey
 
 ```ts
-findActivationEntryByReference(
+resolveActivationKey(
   squashFunction: ActivationFunction,
-): [string, ActivationFunction] | undefined
+): string
 ```
 
-Finds activation entry by function reference.
+Resolves a canonical activation key from a runtime activation function reference.
+
+Resolution order is: direct registry reference match, then the function name,
+then a stable identity fallback key.
 
 Parameters:
 - `squashFunction` - - Activation function instance.
 
-Returns: Activation entry or undefined.
+Returns: Activation key.
+
+Example:
+
+```ts
+import * as methods from '../../../methods/methods';
+
+const key = resolveActivationKey(methods.Activation.tanh);
+```
 
 ### resolveNamedActivationFromFunction
 
@@ -1529,36 +1559,6 @@ Parameters:
 
 Returns: Activation name or undefined.
 
-### findActivationByKey
-
-```ts
-findActivationByKey(
-  squashName: string | undefined,
-): ActivationFunction | undefined
-```
-
-Resolves activation by direct key lookup.
-
-Parameters:
-- `squashName` - - Activation key.
-
-Returns: Activation function or undefined.
-
-### findActivationByFunctionName
-
-```ts
-findActivationByFunctionName(
-  squashName: string | undefined,
-): ActivationFunction | undefined
-```
-
-Resolves activation by matching function.name.
-
-Parameters:
-- `squashName` - - Activation function name.
-
-Returns: Activation function or undefined.
-
 ### warnUnknownSquashName
 
 ```ts