@reicek/neataptic-ts 0.1.25 → 0.1.26

package/src/architecture/network/onnx/import/README.md

@@ -58,15 +58,17 @@ const runtimeFactories: OnnxRuntimeFactories = {
 };
 ```
 
-### OnnxRuntimePerceptronFactory
+### OnnxPerceptronBuildContext
 
-```ts
-OnnxRuntimePerceptronFactory(
-  sizes: number[],
-): default
-```
+Build context for mapping ONNX layer sizes into a Neataptic MLP factory call.
 
-Runtime perceptron factory signature used by ONNX import orchestration.
+### OnnxPerceptronSizeValidationContext
+
+Validation context for perceptron size-list checks during ONNX import.
+
+### OnnxRuntimeFactories
+
+Runtime factories consumed during ONNX import network reconstruction.
 
 ### OnnxRuntimeLayerFactory
 
@@ -82,29 +84,47 @@ Runtime layer-constructor signature used for recurrent layer reconstruction.
 
 Runtime layer module shape consumed by ONNX import orchestration.
 
-### OnnxRuntimeFactories
+### OnnxRuntimePerceptronFactory
 
-Runtime factories consumed during ONNX import network reconstruction.
+```ts
+OnnxRuntimePerceptronFactory(
+  sizes: number[],
+): default
+```
 
-### OnnxPerceptronSizeValidationContext
+Runtime perceptron factory signature used by ONNX import orchestration.
 
-Validation context for perceptron size-list checks during ONNX import.
+## architecture/network/onnx/import/network.onnx.runtime-load.utils.ts
 
-### OnnxPerceptronBuildContext
+### buildPerceptronNetwork
 
-Build context for mapping ONNX layer sizes into a Neataptic MLP factory call.
+```ts
+buildPerceptronNetwork(
+  buildContext: OnnxPerceptronBuildContext,
+): default
+```
 
-## architecture/network/onnx/import/network.onnx.runtime-load.utils.ts
+Build a perceptron network from size-extraction context.
 
-### loadRuntimeFactories
+Parameters:
+- `buildContext` - Perceptron build context.
+
+Returns: Reconstructed network instance.
+
+### createPerceptronBuildContext
 
 ```ts
-loadRuntimeFactories(): OnnxRuntimeFactories
+createPerceptronBuildContext(
+  sizes: number[],
+): OnnxPerceptronBuildContext
 ```
 
-Resolve runtime factories used by ONNX import orchestration.
+Build perceptron-network construction context.
 
-Returns: Perceptron factory and layer module object.
+Parameters:
+- `sizes` - Layer-size payload.
+
+Returns: Build context.
 
 ### createPerceptronFactory
 
@@ -116,6 +136,21 @@ Create an ONNX import network factory from modern static constructors.
 
 Returns: Perceptron-compatible factory function.
 
+### createPerceptronSizeValidationContext
+
+```ts
+createPerceptronSizeValidationContext(
+  sizes: number[],
+): OnnxPerceptronSizeValidationContext
+```
+
+Build perceptron-size validation context.
+
+Parameters:
+- `sizes` - Layer-size payload.
+
+Returns: Validation context.
+
 ### createRuntimeLayerModule
 
 ```ts
@@ -160,6 +195,16 @@ Parameters:
 
 Returns: Runtime layer module.
 
+### loadRuntimeFactories
+
+```ts
+loadRuntimeFactories(): OnnxRuntimeFactories
+```
+
+Resolve runtime factories used by ONNX import orchestration.
+
+Returns: Perceptron factory and layer module object.
+
 ### resolveLayerFactory
 
 ```ts
@@ -175,21 +220,6 @@ Parameters:
 
 Returns: Matching layer factory.
 
-### createPerceptronSizeValidationContext
-
-```ts
-createPerceptronSizeValidationContext(
-  sizes: number[],
-): OnnxPerceptronSizeValidationContext
-```
-
-Build perceptron-size validation context.
-
-Parameters:
-- `sizes` - Layer-size payload.
-
-Returns: Validation context.
-
 ### validatePerceptronSizes
 
 ```ts
@@ -205,36 +235,6 @@ Parameters:
 
 Returns: Nothing. Throws on invalid size-list.
 
-### createPerceptronBuildContext
-
-```ts
-createPerceptronBuildContext(
-  sizes: number[],
-): OnnxPerceptronBuildContext
-```
-
-Build perceptron-network construction context.
-
-Parameters:
-- `sizes` - Layer-size payload.
-
-Returns: Build context.
-
-### buildPerceptronNetwork
-
-```ts
-buildPerceptronNetwork(
-  buildContext: OnnxPerceptronBuildContext,
-): default
-```
-
-Build a perceptron network from size-extraction context.
-
-Parameters:
-- `buildContext` - Perceptron build context.
-
-Returns: Reconstructed network instance.
-
 ## architecture/network/onnx/import/network.onnx.import-weights.types.ts
 
 Import-owned types for ONNX weight restoration and Conv reconstruction.
@@ -262,742 +262,742 @@ const assignmentContext: OnnxImportWeightAssignmentContext = {
 };
 ```
 
-### OnnxImportLayerWeightBucket
+### OnnxImportAggregatedLayerAssignmentContext
 
-Bucketed ONNX dense/per-neuron tensors for one exported layer index.
+Context for assigning aggregated dense tensors for one layer.
 
-### OnnxImportHiddenSizeDerivationContext
+### OnnxImportAggregatedNeuronAssignmentContext
 
-Context for deriving hidden layer sizes from initializer tensors and metadata.
+Context for assigning one aggregated dense target neuron row.
 
-### OnnxImportWeightAssignmentContext
+### OnnxImportConvCoordinateAssignmentContext
 
-Shared weight-assignment context built once per ONNX import.
+Context for applying Conv weights and bias at one output coordinate.
 
-### OnnxImportWeightAssignmentBuildParams
+### OnnxImportConvKernelAssignmentContext
 
-Build params for creating shared ONNX import weight-assignment context.
+Context for assigning one concrete Conv kernel connection weight.
 
-### OnnxImportLayerNodePair
+### OnnxImportConvLayerContext
 
-Node slices for one sequential imported layer assignment pass.
+Context for reconstructing one Conv layer's imported connectivity.
 
-### OnnxImportLayerNodePairBuildParams
+### OnnxImportConvLayerContextBuildParams
 
-Build params for one sequential layer node-pair slice operation.
+Build params for creating one Conv reconstruction layer context.
 
-### OnnxImportLayerTensorNames
+### OnnxImportConvMetadata
 
-Weight tensor names for one imported layer index.
+Parsed Conv metadata payload used for optional reconstruction pass.
 
-### OnnxImportAggregatedLayerAssignmentContext
+### OnnxImportConvNodeSlices
 
-Context for assigning aggregated dense tensors for one layer.
+Layer node slices used while applying Conv reconstruction assignments.
 
-### OnnxImportPerNeuronLayerAssignmentContext
+### OnnxImportConvOutputCoordinate
 
-Context for assigning per-neuron tensors for one layer.
+Coordinate for one Conv output neuron traversal position.
 
-### OnnxImportAggregatedNeuronAssignmentContext
+### OnnxImportConvTensorContext
 
-Context for assigning one aggregated dense target neuron row.
+Resolved Conv initializer tensors and dimensions for one layer.
 
-### OnnxImportPerNeuronAssignmentContext
+### OnnxImportHiddenSizeDerivationContext
 
-Context for assigning one per-neuron imported target node.
+Context for deriving hidden layer sizes from initializer tensors and metadata.
 
-### OnnxImportConvMetadata
+### OnnxImportInboundConnectionMap
 
-Parsed Conv metadata payload used for optional reconstruction pass.
+Inbound connection lookup map keyed by source node for one target neuron.
 
-### OnnxImportConvLayerContext
+### OnnxImportLayerNodePair
 
-Context for reconstructing one Conv layer's imported connectivity.
+Node slices for one sequential imported layer assignment pass.
 
-### OnnxImportConvLayerContextBuildParams
+### OnnxImportLayerNodePairBuildParams
 
-Build params for creating one Conv reconstruction layer context.
+Build params for one sequential layer node-pair slice operation.
 
-### OnnxImportConvTensorContext
+### OnnxImportLayerTensorNames
 
-Resolved Conv initializer tensors and dimensions for one layer.
+Weight tensor names for one imported layer index.
 
-### OnnxImportConvNodeSlices
+### OnnxImportLayerWeightBucket
 
-Layer node slices used while applying Conv reconstruction assignments.
+Bucketed ONNX dense/per-neuron tensors for one exported layer index.
 
-### OnnxImportConvOutputCoordinate
+### OnnxImportPerNeuronAssignmentContext
 
-Coordinate for one Conv output neuron traversal position.
+Context for assigning one per-neuron imported target node.
 
-### OnnxImportConvCoordinateAssignmentContext
+### OnnxImportPerNeuronLayerAssignmentContext
 
-Context for applying Conv weights and bias at one output coordinate.
+Context for assigning per-neuron tensors for one layer.
 
-### OnnxImportInboundConnectionMap
+### OnnxImportWeightAssignmentBuildParams
 
-Inbound connection lookup map keyed by source node for one target neuron.
+Build params for creating shared ONNX import weight-assignment context.
 
-### OnnxImportConvKernelAssignmentContext
+### OnnxImportWeightAssignmentContext
 
-Context for assigning one concrete Conv kernel connection weight.
+Shared weight-assignment context built once per ONNX import.
 
 ## architecture/network/onnx/import/network.onnx.import-weights.utils.ts
 
-### deriveHiddenLayerSizes
+### applyAggregatedLayerWeights
 
 ```ts
-deriveHiddenLayerSizes(
-  initializers: OnnxTensor[],
-  metadataProps: OnnxMetadataProperty[] | undefined,
-): number[]
+applyAggregatedLayerWeights(
+  aggregatedContext: OnnxImportAggregatedLayerAssignmentContext,
+): void
 ```
 
-Extract hidden layer sizes from ONNX initializers (weight tensors).
+Apply aggregated dense tensor assignments for one layer.
 
 Parameters:
-- `initializers` - ONNX initializer tensors.
-- `metadataProps` - Optional ONNX metadata properties.
+- `aggregatedContext` - Aggregated assignment context.
 
-Returns: Hidden layer sizes in order.
+Returns: Nothing.
 
-### assignWeightsAndBiases
+### applyAggregatedNeuronAssignment
 
 ```ts
-assignWeightsAndBiases(
-  network: default,
-  onnx: OnnxModel,
-  hiddenLayerSizes: number[],
-  metadataProps: OnnxMetadataProperty[] | undefined,
+applyAggregatedNeuronAssignment(
+  neuronContext: OnnxImportAggregatedNeuronAssignmentContext,
 ): void
 ```
 
-Assign weights and biases from ONNX initializers to a newly created network.
+Apply aggregated dense row weights and bias for one target neuron.
 
 Parameters:
-- `network` - Target network to mutate.
-- `onnx` - Source ONNX model.
-- `hiddenLayerSizes` - Hidden layer sizes.
-- `metadataProps` - Optional ONNX metadata properties.
+- `neuronContext` - Aggregated neuron assignment context.
 
 Returns: Nothing.
 
-### parseMetadataLayerSizes
+### applyConvCoordinateAssignment
 
 ```ts
-parseMetadataLayerSizes(
-  metadataProps: OnnxMetadataProperty[],
-): number[] | null
+applyConvCoordinateAssignment(
+  coordinateContext: OnnxImportConvCoordinateAssignmentContext,
+): void
 ```
 
-Parse explicit metadata-driven hidden layer sizes.
+Apply Conv bias and kernel weights for one output coordinate.
 
 Parameters:
-- `metadataProps` - ONNX metadata properties.
+- `coordinateContext` - Conv coordinate assignment context.
 
-Returns: Parsed hidden layer sizes when available.
+Returns: Nothing.
 
-### collectLayerWeightBuckets
+### applyConvLayerReconstruction
 
 ```ts
-collectLayerWeightBuckets(
-  initializers: OnnxTensor[],
-): Record<string, OnnxImportLayerWeightBucket>
+applyConvLayerReconstruction(
+  layerContext: OnnxImportConvLayerContext,
+): void
 ```
 
-Collect ONNX weight tensor buckets grouped by export layer index.
+Apply Conv reconstruction for one validated Conv layer context.
 
 Parameters:
-- `initializers` - ONNX initializer tensors.
+- `layerContext` - Conv layer context.
 
-Returns: Layer-weight buckets keyed by export layer index.
+Returns: Nothing.
 
-### collectSortedLayerIndices
+### applyDenseWeightAssignments
 
 ```ts
-collectSortedLayerIndices(
-  layerWeightBuckets: Record<string, OnnxImportLayerWeightBucket>,
-): number[]
+applyDenseWeightAssignments(
+  assignmentContext: OnnxImportWeightAssignmentContext,
+): void
 ```
 
-Collect sorted layer indices from weight buckets.
+Apply dense/per-neuron assignments for all sorted layer indices.
 
 Parameters:
-- `layerWeightBuckets` - Layer-weight buckets.
+- `assignmentContext` - Shared assignment context.
 
-Returns: Ascending export layer indices.
+Returns: Nothing.
 
-### buildHiddenLayerSizesFromBuckets
+### applyOptionalConvReconstruction
 
 ```ts
-buildHiddenLayerSizesFromBuckets(
-  layerWeightBuckets: Record<string, OnnxImportLayerWeightBucket>,
-  sortedLayerIndices: number[],
-): number[]
+applyOptionalConvReconstruction(
+  assignmentContext: OnnxImportWeightAssignmentContext,
+): void
 ```
 
-Build hidden-layer sizes from weight buckets while excluding output layer.
+Apply optional Conv2D reconstruction pass from metadata payloads.
 
 Parameters:
-- `layerWeightBuckets` - Layer-weight buckets.
-- `sortedLayerIndices` - Ascending layer indices.
+- `assignmentContext` - Shared assignment context.
 
-Returns: Hidden-layer sizes.
+Returns: Nothing.
 
-### resolveLayerHiddenSize
+### applyPerNeuronAssignment
 
 ```ts
-resolveLayerHiddenSize(
-  layerWeightBuckets: Record<string, OnnxImportLayerWeightBucket>,
-  layerIndex: number,
-): number
+applyPerNeuronAssignment(
+  perNeuronAssignmentContext: OnnxImportPerNeuronAssignmentContext,
+): void
 ```
 
-Resolve one hidden-layer size from its weight bucket.
+Apply one per-neuron weight vector and bias assignment.
 
 Parameters:
-- `layerWeightBuckets` - Layer-weight buckets.
-- `layerIndex` - Export layer index.
+- `perNeuronAssignmentContext` - Per-neuron assignment context.
 
-Returns: Hidden-layer size.
+Returns: Nothing.
 
-### buildWeightAssignmentContext
+### applyPerNeuronLayerWeights
 
 ```ts
-buildWeightAssignmentContext(
-  params: OnnxImportWeightAssignmentBuildParams,
-): OnnxImportWeightAssignmentContext
+applyPerNeuronLayerWeights(
+  perNeuronContext: OnnxImportPerNeuronLayerAssignmentContext,
+): void
 ```
 
-Build the shared assignment context for import weight restoration.
+Apply per-neuron tensor assignments for one layer.
 
 Parameters:
-- `params` - Assignment context input params.
+- `perNeuronContext` - Per-neuron layer assignment context.
 
-Returns: Shared assignment context.
+Returns: Nothing.
 
-### parseLayerIndexFromWeightTensor
+### assignConvKernelWeight
 
 ```ts
-parseLayerIndexFromWeightTensor(
-  tensorName: string,
-): number | null
+assignConvKernelWeight(
+  kernelAssignmentContext: OnnxImportConvKernelAssignmentContext,
+): void
 ```
 
-Parse layer index from dense/per-neuron weight tensor name.
+Assign one Conv kernel weight to the matching inbound neuron connection.
 
 Parameters:
-- `tensorName` - Tensor name.
+- `kernelAssignmentContext` - Conv kernel assignment context.
 
-Returns: Parsed layer index or null.
+Returns: Nothing.
 
-### parseWeightTensorName
+### assignLayerWeights
 
 ```ts
-parseWeightTensorName(
-  tensorName: string,
-): { layerIndex: string; neuronIndex: number | null; } | null
+assignLayerWeights(
+  initializerMap: Record<string, OnnxTensor>,
+  nodePair: OnnxImportLayerNodePair,
+): void
 ```
 
-Parse layer/neuron components from a weight tensor name.
+Assign one layer's weights using aggregated or per-neuron tensors.
 
 Parameters:
-- `tensorName` - Tensor name.
+- `initializerMap` - ONNX initializer map.
+- `nodePair` - Current/previous node slices.
 
-Returns: Parsed layer+neuron components when matched.
+Returns: Nothing.
 
-### buildInitializerMap
+### assignWeightsAndBiases
 
 ```ts
-buildInitializerMap(
-  initializers: OnnxTensor[],
-): Record<string, OnnxTensor>
+assignWeightsAndBiases(
+  network: default,
+  onnx: OnnxModel,
+  hiddenLayerSizes: number[],
+  metadataProps: OnnxMetadataProperty[] | undefined,
+): void
 ```
 
-Build ONNX initializer map keyed by tensor name.
+Assign weights and biases from ONNX initializers to a newly created network.
 
 Parameters:
-- `initializers` - ONNX initializer list.
+- `network` - Target network to mutate.
+- `onnx` - Source ONNX model.
+- `hiddenLayerSizes` - Hidden layer sizes.
+- `metadataProps` - Optional ONNX metadata properties.
 
-Returns: Tensor map by name.
+Returns: Nothing.
 
-### collectSortedUniqueLayerIndices
+### buildConvLayerContext
 
 ```ts
-collectSortedUniqueLayerIndices(
-  initializerMap: Record<string, OnnxTensor>,
-): number[]
+buildConvLayerContext(
+  params: OnnxImportConvLayerContextBuildParams,
+): OnnxImportConvLayerContext | null
 ```
 
-Collect unique sorted layer indices from initializer weight tensors.
+Build one Conv layer reconstruction context.
 
 Parameters:
-- `initializerMap` - Initializer map keyed by tensor name.
+- `params` - Conv context input params.
 
-Returns: Unique sorted layer indices.
+Returns: Conv layer context when valid.
 
-### collectNodesByType
+### buildConvNeuronLinearIndex
 
 ```ts
-collectNodesByType(
-  nodes: default[],
-  nodeType: "input" | "output" | "hidden",
-): default[]
+buildConvNeuronLinearIndex(
+  coordinate: OnnxImportConvOutputCoordinate,
+  convSpec: Conv2DMapping,
+): number
 ```
 
-Collect nodes by runtime node type discriminator.
+Build flattened linear index for one Conv output coordinate.
 
 Parameters:
-- `nodes` - Network nodes.
-- `nodeType` - Runtime node type.
+- `coordinate` - Conv output coordinate.
+- `convSpec` - Conv mapping spec.
 
-Returns: Filtered nodes.
+Returns: Linear neuron index.
 
-### applyDenseWeightAssignments
+### buildConvNodeSlices
 
 ```ts
-applyDenseWeightAssignments(
-  assignmentContext: OnnxImportWeightAssignmentContext,
-): void
+buildConvNodeSlices(
+  layerContext: OnnxImportConvLayerContext,
+): OnnxImportConvNodeSlices
 ```
 
-Apply dense/per-neuron assignments for all sorted layer indices.
+Build Conv current/previous node slices for one layer context.
 
 Parameters:
-- `assignmentContext` - Shared assignment context.
+- `layerContext` - Conv layer context.
 
-Returns: Nothing.
+Returns: Node slice payload.
 
-### buildLayerNodePair
+### buildConvTensorContext
 
 ```ts
-buildLayerNodePair(
-  assignmentContext: OnnxImportWeightAssignmentContext,
-  params: OnnxImportLayerNodePairBuildParams,
-): OnnxImportLayerNodePair
+buildConvTensorContext(
+  layerContext: OnnxImportConvLayerContext,
+): OnnxImportConvTensorContext | null
 ```
 
-Build current/previous node slices for one sequential import layer pass.
+Build validated Conv tensor context for one layer.
 
 Parameters:
-- `assignmentContext` - Shared assignment context.
-- `params` - Sequential traversal params.
+- `layerContext` - Conv layer context.
 
-Returns: Layer node pair.
+Returns: Conv tensor context when valid.
 
-### resolveCurrentLayerNodes
+### buildHiddenLayerSizesFromBuckets
 
 ```ts
-resolveCurrentLayerNodes(
-  assignmentContext: OnnxImportWeightAssignmentContext,
-  params: { sequentialIndex: number; },
-): default[]
+buildHiddenLayerSizesFromBuckets(
+  layerWeightBuckets: Record<string, OnnxImportLayerWeightBucket>,
+  sortedLayerIndices: number[],
+): number[]
 ```
 
-Resolve current layer nodes for one sequential layer assignment pass.
+Build hidden-layer sizes from weight buckets while excluding output layer.
 
 Parameters:
-- `assignmentContext` - Shared assignment context.
-- `params` - Sequential traversal params.
+- `layerWeightBuckets` - Layer-weight buckets.
+- `sortedLayerIndices` - Ascending layer indices.
 
-Returns: Current layer nodes.
+Returns: Hidden-layer sizes.
 
-### resolvePreviousLayerNodes
+### buildInboundConnectionMap
 
 ```ts
-resolvePreviousLayerNodes(
-  assignmentContext: OnnxImportWeightAssignmentContext,
-  params: { sequentialIndex: number; },
-): default[]
+buildInboundConnectionMap(
+  neuronInternal: NodeInternals,
+): OnnxImportInboundConnectionMap
 ```
 
-Resolve previous layer nodes for one sequential layer assignment pass.
+Build inbound connection lookup map for one neuron.
 
 Parameters:
-- `assignmentContext` - Shared assignment context.
-- `params` - Sequential traversal params.
+- `neuronInternal` - Neuron internals.
 
-Returns: Previous layer nodes.
+Returns: Inbound connection map keyed by source node.
 
-### sumHiddenSizesToIndex
+### buildInitializerMap
 
 ```ts
-sumHiddenSizesToIndex(
-  hiddenLayerSizes: number[],
-  exclusiveEndIndex: number,
-): number
+buildInitializerMap(
+  initializers: OnnxTensor[],
+): Record<string, OnnxTensor>
 ```
 
-Sum hidden-layer sizes from index `0` to `exclusiveEndIndex`.
+Build ONNX initializer map keyed by tensor name.
 
 Parameters:
-- `hiddenLayerSizes` - Hidden-layer size list.
-- `exclusiveEndIndex` - Exclusive end index.
+- `initializers` - ONNX initializer list.
 
-Returns: Prefix sum.
+Returns: Tensor map by name.
 
-### assignLayerWeights
+### buildInputCoordinate
 
 ```ts
-assignLayerWeights(
-  initializerMap: Record<string, OnnxTensor>,
-  nodePair: OnnxImportLayerNodePair,
-): void
+buildInputCoordinate(
+  kernelAssignmentContext: OnnxImportConvKernelAssignmentContext,
+): { inputRow: number; inputColumn: number; } | null
 ```
 
-Assign one layer's weights using aggregated or per-neuron tensors.
+Build input-space coordinate for one Conv kernel element.
 
 Parameters:
-- `initializerMap` - ONNX initializer map.
-- `nodePair` - Current/previous node slices.
+- `kernelAssignmentContext` - Conv kernel assignment context.
 
-Returns: Nothing.
+Returns: Input coordinate when in bounds.
 
-### hasAggregatedLayerWeights
+### buildInputFeatureLinearIndex
 
 ```ts
-hasAggregatedLayerWeights(
-  aggregatedContext: OnnxImportAggregatedLayerAssignmentContext,
-): boolean
+buildInputFeatureLinearIndex(
+  convSpec: Conv2DMapping,
+  inChannelIndex: number,
+  inputRow: number,
+  inputColumn: number,
+): number
 ```
 
-Determine whether the layer has aggregated weight tensor data.
+Build linear feature index in input feature space.
 
 Parameters:
-- `aggregatedContext` - Aggregated assignment context.
+- `convSpec` - Conv mapping spec.
+- `inChannelIndex` - Input channel index.
+- `inputRow` - Input row index.
+- `inputColumn` - Input column index.
 
-Returns: True when aggregated tensor exists.
+Returns: Linear input feature index.
 
-### buildLayerTensorNames
+### buildLayerNodePair
 
 ```ts
-buildLayerTensorNames(
-  layerIndex: number,
-): OnnxImportLayerTensorNames
+buildLayerNodePair(
+  assignmentContext: OnnxImportWeightAssignmentContext,
+  params: OnnxImportLayerNodePairBuildParams,
+): OnnxImportLayerNodePair
 ```
 
-Build dense weight/bias tensor names for one layer index.
+Build current/previous node slices for one sequential import layer pass.
 
 Parameters:
-- `layerIndex` - Export layer index.
+- `assignmentContext` - Shared assignment context.
+- `params` - Sequential traversal params.
 
-Returns: Layer tensor names.
+Returns: Layer node pair.
 
-### applyAggregatedLayerWeights
+### buildLayerTensorNames
 
 ```ts
-applyAggregatedLayerWeights(
-  aggregatedContext: OnnxImportAggregatedLayerAssignmentContext,
-): void
+buildLayerTensorNames(
+  layerIndex: number,
+): OnnxImportLayerTensorNames
 ```
 
-Apply aggregated dense tensor assignments for one layer.
+Build dense weight/bias tensor names for one layer index.
 
 Parameters:
-- `aggregatedContext` - Aggregated assignment context.
+- `layerIndex` - Export layer index.
 
-Returns: Nothing.
+Returns: Layer tensor names.
 
-### applyAggregatedNeuronAssignment
+### buildPerNeuronTensorNames
 
 ```ts
-applyAggregatedNeuronAssignment(
-  neuronContext: OnnxImportAggregatedNeuronAssignmentContext,
-): void
+buildPerNeuronTensorNames(
+  layerIndex: number,
+  neuronIndex: number,
+): OnnxImportLayerTensorNames
 ```
 
-Apply aggregated dense row weights and bias for one target neuron.
+Build per-neuron tensor names for one layer and neuron index.
 
 Parameters:
-- `neuronContext` - Aggregated neuron assignment context.
+- `layerIndex` - Export layer index.
+- `neuronIndex` - Neuron index in layer.
 
-Returns: Nothing.
+Returns: Per-neuron tensor names.
 
-### applyPerNeuronLayerWeights
+### buildWeightAssignmentContext
 
 ```ts
-applyPerNeuronLayerWeights(
-  perNeuronContext: OnnxImportPerNeuronLayerAssignmentContext,
-): void
+buildWeightAssignmentContext(
+  params: OnnxImportWeightAssignmentBuildParams,
+): OnnxImportWeightAssignmentContext
 ```
 
-Apply per-neuron tensor assignments for one layer.
+Build the shared assignment context for import weight restoration.
 
 Parameters:
-- `perNeuronContext` - Per-neuron layer assignment context.
+- `params` - Assignment context input params.
 
-Returns: Nothing.
+Returns: Shared assignment context.
 
-### buildPerNeuronTensorNames
+### collectConvKernelCoordinates
 
 ```ts
-buildPerNeuronTensorNames(
-  layerIndex: number,
-  neuronIndex: number,
-): OnnxImportLayerTensorNames
+collectConvKernelCoordinates(
+  inChannels: number,
+  kernelHeight: number,
+  kernelWidth: number,
+): OnnxConvKernelCoordinate[]
 ```
 
-Build per-neuron tensor names for one layer and neuron index.
+Collect all kernel traversal coordinates for one Conv output position.
 
 Parameters:
-- `layerIndex` - Export layer index.
-- `neuronIndex` - Neuron index in layer.
+- `inChannels` - Input channel count.
+- `kernelHeight` - Kernel height.
+- `kernelWidth` - Kernel width.
 
-Returns: Per-neuron tensor names.
+Returns: Kernel traversal coordinates.
 
-### applyPerNeuronAssignment
+### collectConvOutputCoordinates
 
 ```ts
-applyPerNeuronAssignment(
-  perNeuronAssignmentContext: OnnxImportPerNeuronAssignmentContext,
-): void
+collectConvOutputCoordinates(
+  convSpec: Conv2DMapping,
+  outChannels: number,
+): OnnxImportConvOutputCoordinate[]
 ```
 
-Apply one per-neuron weight vector and bias assignment.
+Collect all output traversal coordinates for one Conv layer.
 
 Parameters:
-- `perNeuronAssignmentContext` - Per-neuron assignment context.
+- `convSpec` - Conv mapping spec.
+- `outChannels` - Output channel count.
 
-Returns: Nothing.
+Returns: Output traversal coordinates.
 
-### applyOptionalConvReconstruction
+### collectLayerWeightBuckets
 
 ```ts
-applyOptionalConvReconstruction(
-  assignmentContext: OnnxImportWeightAssignmentContext,
-): void
+collectLayerWeightBuckets(
+  initializers: OnnxTensor[],
+): Record<string, OnnxImportLayerWeightBucket>
 ```
 
-Apply optional Conv2D reconstruction pass from metadata payloads.
+Collect ONNX weight tensor buckets grouped by export layer index.
 
 Parameters:
-- `assignmentContext` - Shared assignment context.
+- `initializers` - ONNX initializer tensors.
 
-Returns: Nothing.
+Returns: Layer-weight buckets keyed by export layer index.
 
-### parseConvMetadata
+### collectNodesByType
 
 ```ts
-parseConvMetadata(
-  metadataProps: OnnxMetadataProperty[],
-): OnnxImportConvMetadata | null
+collectNodesByType(
+  nodes: default[],
+  nodeType: "input" | "output" | "hidden",
+): default[]
 ```
 
-Parse Conv reconstruction metadata payload.
+Collect nodes by runtime node type discriminator.
 
 Parameters:
-- `metadataProps` - ONNX metadata properties.
+- `nodes` - Network nodes.
+- `nodeType` - Runtime node type.
 
-Returns: Parsed Conv metadata.
+Returns: Filtered nodes.
 
-### buildConvLayerContext
+### collectSortedLayerIndices
 
 ```ts
-buildConvLayerContext(
-  params: OnnxImportConvLayerContextBuildParams,
-): OnnxImportConvLayerContext | null
+collectSortedLayerIndices(
+  layerWeightBuckets: Record<string, OnnxImportLayerWeightBucket>,
+): number[]
 ```
 
-Build one Conv layer reconstruction context.
+Collect sorted layer indices from weight buckets.
 
 Parameters:
-- `params` - Conv context input params.
+- `layerWeightBuckets` - Layer-weight buckets.
 
-Returns: Conv layer context when valid.
+Returns: Ascending export layer indices.
 
-### applyConvLayerReconstruction
+### collectSortedUniqueLayerIndices
 
 ```ts
-applyConvLayerReconstruction(
-  layerContext: OnnxImportConvLayerContext,
-): void
+collectSortedUniqueLayerIndices(
+  initializerMap: Record<string, OnnxTensor>,
+): number[]
 ```
 
-Apply Conv reconstruction for one validated Conv layer context.
+Collect unique sorted layer indices from initializer weight tensors.
 
 Parameters:
-- `layerContext` - Conv layer context.
+- `initializerMap` - Initializer map keyed by tensor name.
 
-Returns: Nothing.
+Returns: Unique sorted layer indices.
 
-### buildConvNodeSlices
+### deriveHiddenLayerSizes
 
 ```ts
-buildConvNodeSlices(
-  layerContext: OnnxImportConvLayerContext,
-): OnnxImportConvNodeSlices
+deriveHiddenLayerSizes(
+  initializers: OnnxTensor[],
+  metadataProps: OnnxMetadataProperty[] | undefined,
+): number[]
 ```
 
-Build Conv current/previous node slices for one layer context.
+Extract hidden layer sizes from ONNX initializers (weight tensors).
 
 Parameters:
-- `layerContext` - Conv layer context.
+- `initializers` - ONNX initializer tensors.
+- `metadataProps` - Optional ONNX metadata properties.
 
-Returns: Node slice payload.
+Returns: Hidden layer sizes in order.
 
-### buildConvTensorContext
+### hasAggregatedLayerWeights
 
 ```ts
-buildConvTensorContext(
-  layerContext: OnnxImportConvLayerContext,
-): OnnxImportConvTensorContext | null
+hasAggregatedLayerWeights(
+  aggregatedContext: OnnxImportAggregatedLayerAssignmentContext,
+): boolean
 ```
 
-Build validated Conv tensor context for one layer.
+Determine whether the layer has aggregated weight tensor data.
 
 Parameters:
-- `layerContext` - Conv layer context.
+- `aggregatedContext` - Aggregated assignment context.
 
-Returns: Conv tensor context when valid.
+Returns: True when aggregated tensor exists.
 
-### collectConvOutputCoordinates
+### parseConvMetadata
 
 ```ts
-collectConvOutputCoordinates(
-  convSpec: Conv2DMapping,
-  outChannels: number,
-): OnnxImportConvOutputCoordinate[]
+parseConvMetadata(
+  metadataProps: OnnxMetadataProperty[],
+): OnnxImportConvMetadata | null
 ```
 
-Collect all output traversal coordinates for one Conv layer.
+Parse Conv reconstruction metadata payload.
 
 Parameters:
-- `convSpec` - Conv mapping spec.
-- `outChannels` - Output channel count.
+- `metadataProps` - ONNX metadata properties.
 
-Returns: Output traversal coordinates.
+Returns: Parsed Conv metadata.
 
-### applyConvCoordinateAssignment
+### parseLayerIndexFromWeightTensor
 
 ```ts
-applyConvCoordinateAssignment(
-  coordinateContext: OnnxImportConvCoordinateAssignmentContext,
-): void
+parseLayerIndexFromWeightTensor(
+  tensorName: string,
+): number | null
 ```
 
-Apply Conv bias and kernel weights for one output coordinate.
+Parse layer index from dense/per-neuron weight tensor name.
 
 Parameters:
-- `coordinateContext` - Conv coordinate assignment context.
+- `tensorName` - Tensor name.
 
-Returns: Nothing.
+Returns: Parsed layer index or null.
 
-### buildConvNeuronLinearIndex
+### parseMetadataLayerSizes
 
 ```ts
-buildConvNeuronLinearIndex(
-  coordinate: OnnxImportConvOutputCoordinate,
-  convSpec: Conv2DMapping,
-): number
+parseMetadataLayerSizes(
+  metadataProps: OnnxMetadataProperty[],
+): number[] | null
 ```
 
-Build flattened linear index for one Conv output coordinate.
+Parse explicit metadata-driven hidden layer sizes.
 
 Parameters:
-- `coordinate` - Conv output coordinate.
-- `convSpec` - Conv mapping spec.
+- `metadataProps` - ONNX metadata properties.
 
-Returns: Linear neuron index.
+Returns: Parsed hidden layer sizes when available.
 
-### collectConvKernelCoordinates
+### parseWeightTensorName
 
 ```ts
-collectConvKernelCoordinates(
-  inChannels: number,
-  kernelHeight: number,
-  kernelWidth: number,
-): OnnxConvKernelCoordinate[]
+parseWeightTensorName(
+  tensorName: string,
+): { layerIndex: string; neuronIndex: number | null; } | null
 ```
 
-Collect all kernel traversal coordinates for one Conv output position.
+Parse layer/neuron components from a weight tensor name.
 
 Parameters:
-- `inChannels` - Input channel count.
-- `kernelHeight` - Kernel height.
-- `kernelWidth` - Kernel width.
+- `tensorName` - Tensor name.
 
-Returns: Kernel traversal coordinates.
+Returns: Parsed layer+neuron components when matched.
 
-### assignConvKernelWeight
+### readConvKernelWeight
 
 ```ts
-assignConvKernelWeight(
+readConvKernelWeight(
   kernelAssignmentContext: OnnxImportConvKernelAssignmentContext,
-): void
+): number
 ```
 
-Assign one Conv kernel weight to the matching inbound neuron connection.
+Read one Conv kernel weight from flattened ONNX tensor payload.
 
 Parameters:
 - `kernelAssignmentContext` - Conv kernel assignment context.
 
-Returns: Nothing.
+Returns: Kernel weight.
 
-### buildInputCoordinate
+### resolveCurrentLayerNodes
 
 ```ts
-buildInputCoordinate(
-  kernelAssignmentContext: OnnxImportConvKernelAssignmentContext,
-): { inputRow: number; inputColumn: number; } | null
+resolveCurrentLayerNodes(
+  assignmentContext: OnnxImportWeightAssignmentContext,
+  params: { sequentialIndex: number; },
+): default[]
 ```
 
-Build input-space coordinate for one Conv kernel element.
+Resolve current layer nodes for one sequential layer assignment pass.
 
 Parameters:
-- `kernelAssignmentContext` - Conv kernel assignment context.
+- `assignmentContext` - Shared assignment context.
+- `params` - Sequential traversal params.
 
-Returns: Input coordinate when in bounds.
+Returns: Current layer nodes.
 
-### buildInputFeatureLinearIndex
+### resolveLayerHiddenSize
 
 ```ts
-buildInputFeatureLinearIndex(
-  convSpec: Conv2DMapping,
-  inChannelIndex: number,
-  inputRow: number,
-  inputColumn: number,
+resolveLayerHiddenSize(
+  layerWeightBuckets: Record<string, OnnxImportLayerWeightBucket>,
+  layerIndex: number,
 ): number
 ```
 
-Build linear feature index in input feature space.
+Resolve one hidden-layer size from its weight bucket.
 
 Parameters:
-- `convSpec` - Conv mapping spec.
-- `inChannelIndex` - Input channel index.
-- `inputRow` - Input row index.
-- `inputColumn` - Input column index.
+- `layerWeightBuckets` - Layer-weight buckets.
+- `layerIndex` - Export layer index.
 
-Returns: Linear input feature index.
+Returns: Hidden-layer size.
 
-### buildInboundConnectionMap
+### resolvePreviousLayerNodes
 
 ```ts
-buildInboundConnectionMap(
-  neuronInternal: NodeInternals,
-): OnnxImportInboundConnectionMap
+resolvePreviousLayerNodes(
+  assignmentContext: OnnxImportWeightAssignmentContext,
+  params: { sequentialIndex: number; },
+): default[]
 ```
 
-Build inbound connection lookup map for one neuron.
+Resolve previous layer nodes for one sequential layer assignment pass.
 
 Parameters:
-- `neuronInternal` - Neuron internals.
+- `assignmentContext` - Shared assignment context.
+- `params` - Sequential traversal params.
 
-Returns: Inbound connection map keyed by source node.
+Returns: Previous layer nodes.
 
-### readConvKernelWeight
+### sumHiddenSizesToIndex
 
 ```ts
-readConvKernelWeight(
-  kernelAssignmentContext: OnnxImportConvKernelAssignmentContext,
+sumHiddenSizesToIndex(
+  hiddenLayerSizes: number[],
+  exclusiveEndIndex: number,
 ): number
 ```
 
-Read one Conv kernel weight from flattened ONNX tensor payload.
+Sum hidden-layer sizes from index `0` to `exclusiveEndIndex`.
 
 Parameters:
-- `kernelAssignmentContext` - Conv kernel assignment context.
+- `hiddenLayerSizes` - Hidden-layer size list.
+- `exclusiveEndIndex` - Exclusive end index.
 
-Returns: Kernel weight.
+Returns: Prefix sum.
 
 ## architecture/network/onnx/import/network.onnx.import-activations.utils.ts
 
@@ -1030,21 +1030,21 @@ Keeping them here makes the import chapter explain its own execution state
 without forcing the root ONNX compatibility barrel to remain the ownership
 home for importer-only details.
 
-### OnnxImportArchitectureResult
+### NetworkWithOnnxImportPooling
 
-Parsed architecture dimensions extracted from ONNX import graph payloads.
+Network instance augmented with optional imported ONNX pooling metadata.
 
 ### OnnxImportArchitectureContext
 
 Shared architecture extraction context with resolved graph dimensions.
 
-### OnnxImportDimensionRecord
+### OnnxImportArchitectureResult
 
-Loose ONNX shape-dimension record used by legacy import payload access.
+Parsed architecture dimensions extracted from ONNX import graph payloads.
 
-### OnnxImportRecurrentRestorationContext
+### OnnxImportDimensionRecord
 
-Context for recurrent self-connection restoration from ONNX metadata and tensors.
+Loose ONNX shape-dimension record used by legacy import payload access.
 
 ### OnnxImportHiddenLayerSpan
 
@@ -1054,70 +1054,32 @@ Hidden-layer span payload with one-based layer numbering and global offset.
 
 Execution context for assigning one hidden-layer recurrent diagonal tensor.
 
-### OnnxImportSelfConnectionUpsertContext
-
-Context for upserting one hidden node self-connection from recurrent weight.
-
 ### OnnxImportPoolingMetadata
 
 Parsed pooling metadata payload attached to imported network instances.
 
-### NetworkWithOnnxImportPooling
-
-Network instance augmented with optional imported ONNX pooling metadata.
-
-## architecture/network/onnx/import/network.onnx.import-orchestrators.utils.ts
-
-### extractOnnxArchitecture
-
-```ts
-extractOnnxArchitecture(
-  onnx: OnnxModel,
-): OnnxImportArchitectureResult
-```
-
-Extract input/output counts and hidden layer sizes from ONNX model.
-
-Parameters:
-- `onnx` - Source ONNX model.
-
-Returns: Parsed architecture dimensions.
-
-### pruneSingleLayerHiddenPlaceholders
+### OnnxImportRecurrentRestorationContext
 
-```ts
-pruneSingleLayerHiddenPlaceholders(
-  network: default,
-  hiddenLayerSizes: number[],
-): void
-```
+Context for recurrent self-connection restoration from ONNX metadata and tensors.
 
-Remove placeholder hidden nodes for single-layer perceptron imports.
+### OnnxImportSelfConnectionUpsertContext
 
-Parameters:
-- `network` - Target network.
-- `hiddenLayerSizes` - Hidden layer sizes.
+Context for upserting one hidden node self-connection from recurrent weight.
 
-Returns: Nothing.
+## architecture/network/onnx/import/network.onnx.import-orchestrators.utils.ts
 
-### restoreRecurrentSelfConnections
+### applyLayerSelfConnections
 
 ```ts
-restoreRecurrentSelfConnections(
-  network: default,
-  onnx: OnnxModel,
-  hiddenLayerSizes: number[],
-  metadata: OnnxMetadataProperty[],
+applyLayerSelfConnections(
+  layerConnectionContext: OnnxImportLayerConnectionContext,
 ): void
 ```
 
-Restore recurrent self-connections from recurrent metadata and R tensors.
+Apply one hidden layer diagonal recurrent self-weights.
 
 Parameters:
-- `network` - Target network.
-- `onnx` - Source ONNX model.
-- `hiddenLayerSizes` - Hidden layer sizes.
-- `metadata` - Parsed metadata properties.
+- `layerConnectionContext` - Layer connection context.
 
 Returns: Nothing.
 
@@ -1138,56 +1100,20 @@ Parameters:
 
 Returns: Nothing.
 
-### reconstructFusedRecurrentLayers
+### attachParsedPoolingMetadata
 
 ```ts
-reconstructFusedRecurrentLayers(
+attachParsedPoolingMetadata(
   network: default,
-  onnx: OnnxModel,
-  hiddenLayerSizes: number[],
-  layerFactory: OnnxLayerFactory,
-  metadata: OnnxMetadataProperty[],
+  poolingMetadata: OnnxImportPoolingMetadata,
 ): void
 ```
 
-Reconstruct emitted fused LSTM/GRU layers from ONNX metadata and initializers.
+Attach parsed pooling metadata to imported network instance.
 
 Parameters:
 - `network` - Target network.
-- `onnx` - Source ONNX model.
-- `hiddenLayerSizes` - Hidden layer sizes.
-- `layerFactory` - Dynamic layer module.
-- `metadata` - ONNX metadata properties.
-
-Returns: Nothing.
-
-### parseRecurrentLayerIndices
-
-```ts
-parseRecurrentLayerIndices(
-  rawMetadataValue: string,
-): number[]
-```
-
-Parse recurrent layer indices metadata.
-
-Parameters:
-- `rawMetadataValue` - Raw metadata JSON string.
-
-Returns: Normalized recurrent layer indices.
-
-### applyLayerSelfConnections
-
-```ts
-applyLayerSelfConnections(
-  layerConnectionContext: OnnxImportLayerConnectionContext,
-): void
-```
-
-Apply one hidden layer diagonal recurrent self-weights.
-
-Parameters:
-- `layerConnectionContext` - Layer connection context.
+- `poolingMetadata` - Parsed pooling metadata payload.
 
 Returns: Nothing.
 
@@ -1199,57 +1125,44 @@ buildArchitectureContext(
 ): OnnxImportArchitectureContext
 ```
 
-Build architecture extraction context from ONNX graph state.
-
-Parameters:
-- `onnx` - Source ONNX model.
-
-Returns: Normalized architecture extraction context.
-
-### readLastDimensionValue
-
-```ts
-readLastDimensionValue(
-  dimensions: { dim_value?: number | undefined; }[],
-): number
-```
-
-Read the terminal ONNX shape dimension value from one shape array.
+Build architecture extraction context from ONNX graph state.
 
 Parameters:
-- `dimensions` - ONNX shape dimensions.
+- `onnx` - Source ONNX model.
 
-Returns: Terminal `dim_value` payload.
+Returns: Normalized architecture extraction context.
 
-### isSingleLayerPerceptronImport
+### buildHiddenLayerSpans
 
 ```ts
-isSingleLayerPerceptronImport(
+buildHiddenLayerSpans(
   hiddenLayerSizes: number[],
-): boolean
+): OnnxImportHiddenLayerSpan[]
 ```
 
-Determine whether import shape corresponds to a single-layer perceptron.
+Build hidden-layer spans with one-based layer numbering and global offsets.
 
 Parameters:
 - `hiddenLayerSizes` - Hidden-layer size list.
 
-Returns: True when no hidden layers exist.
+Returns: Hidden-layer span payload list.
 
-### collectPerceptronBoundaryNodes
+### collectDiagonalRecurrentWeights
 
 ```ts
-collectPerceptronBoundaryNodes(
-  nodes: default[],
-): default[]
+collectDiagonalRecurrentWeights(
+  recurrentTensorWeights: number[],
+  hiddenLayerSize: number,
+): number[]
 ```
 
-Collect input and output boundary nodes for perceptron imports.
+Collect diagonal recurrent weights from flattened layer tensor data.
 
 Parameters:
-- `nodes` - Full network node list.
+- `recurrentTensorWeights` - Flattened recurrent tensor weights.
+- `hiddenLayerSize` - Hidden-layer width.
 
-Returns: Input/output-only node list.
+Returns: Diagonal recurrent self-weights.
 
 ### collectNodesByType
 
@@ -1268,6 +1181,21 @@ Parameters:
 
 Returns: Filtered node list.
 
+### collectPerceptronBoundaryNodes
+
+```ts
+collectPerceptronBoundaryNodes(
+  nodes: default[],
+): default[]
+```
+
+Collect input and output boundary nodes for perceptron imports.
+
+Parameters:
+- `nodes` - Full network node list.
+
+Returns: Input/output-only node list.
+
 ### collectRecurrentLayerSpans
 
 ```ts
@@ -1283,20 +1211,20 @@ Parameters:
 
 Returns: Hidden-layer spans requiring recurrent restoration.
 
-### resolveRecurrentLayerIndices
+### extractOnnxArchitecture
 
 ```ts
-resolveRecurrentLayerIndices(
-  metadata: OnnxMetadataProperty[],
-): number[]
+extractOnnxArchitecture(
+  onnx: OnnxModel,
+): OnnxImportArchitectureResult
 ```
 
-Resolve recurrent layer indices from ONNX metadata.
+Extract input/output counts and hidden layer sizes from ONNX model.
 
 Parameters:
-- `metadata` - ONNX metadata payload.
+- `onnx` - Source ONNX model.
 
-Returns: Parsed recurrent layer indices.
+Returns: Parsed architecture dimensions.
 
 ### findMetadataProperty
 
@@ -1315,20 +1243,35 @@ Parameters:
 
 Returns: Matching metadata property when present.
 
-### buildHiddenLayerSpans
+### findRecurrentInitializer
 
 ```ts
-buildHiddenLayerSpans(
+findRecurrentInitializer(
+  layerConnectionContext: OnnxImportLayerConnectionContext,
+): { name: string; float_data: number[]; } | undefined
+```
+
+Resolve recurrent initializer tensor for one hidden-layer span.
+
+Parameters:
+- `layerConnectionContext` - Layer connection context.
+
+Returns: Recurrent initializer tensor when available.
+
+### isSingleLayerPerceptronImport
+
+```ts
+isSingleLayerPerceptronImport(
   hiddenLayerSizes: number[],
-): OnnxImportHiddenLayerSpan[]
+): boolean
 ```
 
-Build hidden-layer spans with one-based layer numbering and global offsets.
+Determine whether import shape corresponds to a single-layer perceptron.
 
 Parameters:
 - `hiddenLayerSizes` - Hidden-layer size list.
 
-Returns: Hidden-layer span payload list.
+Returns: True when no hidden layers exist.
 
 ### normalizeRecurrentLayerIndices
 
@@ -1345,105 +1288,174 @@ Parameters:
 
 Returns: Recurrent layer indices.
 
-### findRecurrentInitializer
+### parsePoolingMetadata
 
 ```ts
-findRecurrentInitializer(
-  layerConnectionContext: OnnxImportLayerConnectionContext,
-): { name: string; float_data: number[]; } | undefined
+parsePoolingMetadata(
+  metadata: OnnxMetadataProperty[],
+): OnnxImportPoolingMetadata | null
 ```
 
-Resolve recurrent initializer tensor for one hidden-layer span.
+Parse pooling metadata payload from ONNX metadata.
 
 Parameters:
-- `layerConnectionContext` - Layer connection context.
+- `metadata` - ONNX metadata entries.
 
-Returns: Recurrent initializer tensor when available.
+Returns: Parsed pooling metadata payload.
 
-### sliceLayerHiddenNodes
+### parseRecurrentLayerIndices
 
 ```ts
-sliceLayerHiddenNodes(
-  layerConnectionContext: OnnxImportLayerConnectionContext,
-): default[]
+parseRecurrentLayerIndices(
+  rawMetadataValue: string,
+): number[]
 ```
 
-Slice hidden nodes for one hidden-layer span.
+Parse recurrent layer indices metadata.
 
 Parameters:
-- `layerConnectionContext` - Layer connection context.
+- `rawMetadataValue` - Raw metadata JSON string.
 
-Returns: Hidden nodes belonging to the span.
+Returns: Normalized recurrent layer indices.
 
-### collectDiagonalRecurrentWeights
+### pruneSingleLayerHiddenPlaceholders
 
 ```ts
-collectDiagonalRecurrentWeights(
-  recurrentTensorWeights: number[],
-  hiddenLayerSize: number,
-): number[]
+pruneSingleLayerHiddenPlaceholders(
+  network: default,
+  hiddenLayerSizes: number[],
+): void
 ```
 
-Collect diagonal recurrent weights from flattened layer tensor data.
+Remove placeholder hidden nodes for single-layer perceptron imports.
 
 Parameters:
-- `recurrentTensorWeights` - Flattened recurrent tensor weights.
-- `hiddenLayerSize` - Hidden-layer width.
+- `network` - Target network.
+- `hiddenLayerSizes` - Hidden layer sizes.
 
-Returns: Diagonal recurrent self-weights.
+Returns: Nothing.
 
-### upsertSelfConnection
+### readLastDimensionValue
 
 ```ts
-upsertSelfConnection(
-  selfConnectionContext: OnnxImportSelfConnectionUpsertContext,
+readLastDimensionValue(
+  dimensions: { dim_value?: number | undefined; }[],
+): number
+```
+
+Read the terminal ONNX shape dimension value from one shape array.
+
+Parameters:
+- `dimensions` - ONNX shape dimensions.
+
+Returns: Terminal `dim_value` payload.
+
+### reconstructFusedRecurrentLayers
+
+```ts
+reconstructFusedRecurrentLayers(
+  network: default,
+  onnx: OnnxModel,
+  hiddenLayerSizes: number[],
+  layerFactory: OnnxLayerFactory,
+  metadata: OnnxMetadataProperty[],
 ): void
 ```
 
-Upsert one node self-connection for recurrent import restoration.
+Reconstruct emitted fused LSTM/GRU layers from ONNX metadata and initializers.
 
 Parameters:
-- `selfConnectionContext` - Self-connection upsert context.
+- `network` - Target network.
+- `onnx` - Source ONNX model.
+- `hiddenLayerSizes` - Hidden layer sizes.
+- `layerFactory` - Dynamic layer module.
+- `metadata` - ONNX metadata properties.
 
 Returns: Nothing.
 
-### parsePoolingMetadata
+### resolveRecurrentLayerIndices
 
 ```ts
-parsePoolingMetadata(
+resolveRecurrentLayerIndices(
   metadata: OnnxMetadataProperty[],
-): OnnxImportPoolingMetadata | null
+): number[]
 ```
 
-Parse pooling metadata payload from ONNX metadata.
+Resolve recurrent layer indices from ONNX metadata.
 
 Parameters:
-- `metadata` - ONNX metadata entries.
+- `metadata` - ONNX metadata payload.
 
-Returns: Parsed pooling metadata payload.
+Returns: Parsed recurrent layer indices.
 
-### attachParsedPoolingMetadata
+### restoreRecurrentSelfConnections
 
 ```ts
-attachParsedPoolingMetadata(
+restoreRecurrentSelfConnections(
   network: default,
-  poolingMetadata: OnnxImportPoolingMetadata,
+  onnx: OnnxModel,
+  hiddenLayerSizes: number[],
+  metadata: OnnxMetadataProperty[],
 ): void
 ```
 
-Attach parsed pooling metadata to imported network instance.
+Restore recurrent self-connections from recurrent metadata and R tensors.
 
 Parameters:
 - `network` - Target network.
-- `poolingMetadata` - Parsed pooling metadata payload.
+- `onnx` - Source ONNX model.
+- `hiddenLayerSizes` - Hidden layer sizes.
+- `metadata` - Parsed metadata properties.
+
+Returns: Nothing.
+
+### sliceLayerHiddenNodes
+
+```ts
+sliceLayerHiddenNodes(
+  layerConnectionContext: OnnxImportLayerConnectionContext,
+): default[]
+```
+
+Slice hidden nodes for one hidden-layer span.
+
+Parameters:
+- `layerConnectionContext` - Layer connection context.
+
+Returns: Hidden nodes belonging to the span.
+
+### upsertSelfConnection
+
+```ts
+upsertSelfConnection(
+  selfConnectionContext: OnnxImportSelfConnectionUpsertContext,
+): void
+```
+
+Upsert one node self-connection for recurrent import restoration.
+
+Parameters:
+- `selfConnectionContext` - Self-connection upsert context.
 
 Returns: Nothing.
 
 ## architecture/network/onnx/import/network.onnx.import-fused-recurrent.types.ts
 
-### OnnxFusedRecurrentKind
+### OnnxFusedGateApplicationContext
 
-Supported fused recurrent operator families recognized during ONNX import.
+Gate-weight application context for one reconstructed fused layer.
+
+### OnnxFusedGateRowAssignmentContext
+
+Context for assigning one gate-neuron row from flattened ONNX tensors.
+
+### OnnxFusedLayerNeighborhood
+
+Hidden-layer neighborhood slices around a reconstructed fused layer.
+
+### OnnxFusedLayerReconstructionContext
+
+Execution context for one fused recurrent layer reconstruction.
 
 ### OnnxFusedLayerRuntime
 
@@ -1453,6 +1465,10 @@ The importer only relies on a narrow runtime contract: access to the
 reconstructed nodes, an input wiring hook, and an optional output group that
 can be reconnected to the next restored layer.
 
+### OnnxFusedRecurrentKind
+
+Supported fused recurrent operator families recognized during ONNX import.
+
 ### OnnxFusedRecurrentSpec
 
 Fused recurrent family specification used during import reconstruction.
@@ -1461,10 +1477,6 @@ This tells the importer how to interpret one emitted ONNX recurrent family:
 how many gates to expect, what order those gates were serialized in, and
 which gate owns the self-recurrent diagonal replay.
 
-### OnnxFusedLayerNeighborhood
-
-Hidden-layer neighborhood slices around a reconstructed fused layer.
-
 ### OnnxFusedTensorPayload
 
 Fused recurrent tensor payload read from ONNX initializers.
@@ -1473,18 +1485,6 @@ The importer resolves the three recurrent tensor families up front so the
 reconstruction pass can focus on wiring and row assignment instead of
 repeatedly re-looking up initializers.
 
-### OnnxFusedLayerReconstructionContext
-
-Execution context for one fused recurrent layer reconstruction.
-
-### OnnxFusedGateApplicationContext
-
-Gate-weight application context for one reconstructed fused layer.
-
-### OnnxFusedGateRowAssignmentContext
-
-Context for assigning one gate-neuron row from flattened ONNX tensors.
-
 ### OnnxIncomingWeightAssignmentContext
 
 Context for assigning dense incoming weights for one gate-neuron row.