@reicek/neataptic-ts 0.1.25 → 0.1.26

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

@@ -32,57 +32,69 @@ console.log('First weight from->to', slab.weights[0], slab.from[0], slab.to[0]);
 
 ## architecture/network/slab/network.slab.utils.types.ts
 
-### SLAB_ZERO
+### BuildAdjacencyContext
 
-Numeric zero sentinel used across slab orchestration and helper pipelines.
+Shared immutable inputs used across the adjacency build pipeline.
 
-### SLAB_ONE
+### ConnectionInternals
 
-Numeric one sentinel used for neutral gain defaults and index math.
+Internal Connection properties accessed during slab operations.
 
-### SLAB_GROWTH_FACTOR_NODE
+### ConnectionSlabView
 
-Capacity growth factor for Node.js slab allocations.
+Shape returned by getConnectionSlab describing the packed SoA view.
 
-### SLAB_GROWTH_FACTOR_BROWSER
+### FanOutCollectionContext
 
-Capacity growth factor for browser slab allocations.
+Context for fan-out collection: build inputs plus the output count buffer.
 
-### SLAB_DEFAULT_ASYNC_CHUNK_SIZE
+### FastSlabNodeRuntime
 
-Default async slab rebuild chunk size when no override is provided.
+Node shape required by fast slab activation kernels.
 
-### ConnectionInternals
+### NetworkActivationRuntime
 
-Internal Connection properties accessed during slab operations.
+Runtime activation contract used by slab-based execution paths.
 
 ### NetworkSlabProps
 
 Internal Network properties for slab operations.
 
+### NetworkTopoRuntime
+
+Runtime topology contract used to lazily rebuild topological order.
+
+### OutgoingOrderBuildContext
+
+Context for constructing source-grouped outgoing connection order.
+
 ### PoolKeyMetrics
 
 Per-pool-key allocation & reuse counters (educational / diagnostics).
 
-### TypedArray
+### PublishAdjacencyContext
 
-Union of slab typed array element container types.
+Context for publishing fully built adjacency slabs to internal network state.
 
-### TypedArrayConstructor
+### SLAB_DEFAULT_ASYNC_CHUNK_SIZE
 
-Constructor type for typed arrays used in slabs.
+Default async slab rebuild chunk size when no override is provided.
 
-### NetworkActivationRuntime
+### SLAB_GROWTH_FACTOR_BROWSER
 
-Runtime activation contract used by slab-based execution paths.
+Capacity growth factor for browser slab allocations.
 
-### NetworkTopoRuntime
+### SLAB_GROWTH_FACTOR_NODE
 
-Runtime topology contract used to lazily rebuild topological order.
+Capacity growth factor for Node.js slab allocations.
 
-### FastSlabNodeRuntime
+### SLAB_ONE
 
-Node shape required by fast slab activation kernels.
+Numeric one sentinel used for neutral gain defaults and index math.
+
+### SLAB_ZERO
+
+Numeric zero sentinel used across slab orchestration and helper pipelines.
 
 ### SlabBuildContext
 
@@ -96,31 +108,78 @@ Result of scanning and populating optional gain/plastic slab arrays.
 
 Writable slab arrays targeted during connection serialization.
 
+### StartIndicesBuildContext
+
+Context for constructing CSR start offsets from precomputed fan-out counts.
+
+### TypedArray
+
+Union of slab typed array element container types.
+
+### TypedArrayConstructor
+
+Constructor type for typed arrays used in slabs.
+
+## architecture/network/slab/network.slab.utils.ts
+
+### canUseFastSlab
+
+```ts
+canUseFastSlab(
+  training: boolean,
+): boolean
+```
+
+Public convenience wrapper exposing fast path eligibility.
+Mirrors `_canUseFastSlab` internal predicate.
+
+Parameters:
+- `training` - Whether caller is performing training (disables fast path if true).
+
+Returns: True when slab fast path predicates hold.
+
 ### ConnectionSlabView
 
 Shape returned by getConnectionSlab describing the packed SoA view.
 
-### BuildAdjacencyContext
+### fastSlabActivate
 
-Shared immutable inputs used across the adjacency build pipeline.
+```ts
+fastSlabActivate(
+  input: number[],
+): number[]
+```
 
-### FanOutCollectionContext
+High‑performance forward pass using packed slabs + CSR adjacency.
 
-Context for fan-out collection: build inputs plus the output count buffer.
+Fallback Conditions (auto‑detected):
+ - Missing slabs / adjacency structures.
+ - Topology/gating/stochastic predicates fail (see `_canUseFastSlab`).
+ - Gating present, when applicable (explicit guard).
 
-### StartIndicesBuildContext
+Implementation Notes:
+ - Reuses internal activation/state buffers to reduce per‑step allocation churn.
+ - Applies gain multiplication if optional gain slab exists.
+ - Assumes acyclic graph; topological order recomputed on demand if marked dirty.
 
-Context for constructing CSR start offsets from precomputed fan-out counts.
+Parameters:
+- `input` - Input vector (length must equal `network.input`).
 
-### OutgoingOrderBuildContext
+Returns: Output activations (detached plain array) of length `network.output`.
 
-Context for constructing source-grouped outgoing connection order.
+### getConnectionSlab
 
-### PublishAdjacencyContext
+```ts
+getConnectionSlab(): ConnectionSlabView
+```
 
-Context for publishing fully built adjacency slabs to internal network state.
+Obtain (and lazily rebuild if dirty) the current packed SoA view of connections.
 
-## architecture/network/slab/network.slab.utils.ts
+Gain Omission: If the internal gain slab is absent (all gains neutral) a synthetic
+neutral array is created and returned (NOT retained) to keep external educational
+tooling branch‑free while preserving omission memory savings internally.
+
+Returns: Read‑only style view (do not mutate) containing typed arrays + metadata.
 
 ### getSlabAllocationStats
 
@@ -139,6 +198,16 @@ NOTE: Stats are cumulative (not auto‑reset); callers may diff successive snaps
 
 Returns: Plain object copy (safe to serialize) of current allocator counters.
 
+### getSlabVersion
+
+```ts
+getSlabVersion(): number
+```
+
+Retrieve current monotonic slab version (increments on each successful rebuild).
+
+Returns: Non‑negative integer (0 if slab never built yet).
+
 ### rebuildConnectionSlab
 
 ```ts
@@ -188,75 +257,6 @@ Parameters:
 
 Returns: Promise resolving once rebuild completes.
 
-### getConnectionSlab
-
-```ts
-getConnectionSlab(): ConnectionSlabView
-```
-
-Obtain (and lazily rebuild if dirty) the current packed SoA view of connections.
-
-Gain Omission: If the internal gain slab is absent (all gains neutral) a synthetic
-neutral array is created and returned (NOT retained) to keep external educational
-tooling branch‑free while preserving omission memory savings internally.
-
-Returns: Read‑only style view (do not mutate) containing typed arrays + metadata.
-
-### fastSlabActivate
-
-```ts
-fastSlabActivate(
-  input: number[],
-): number[]
-```
-
-High‑performance forward pass using packed slabs + CSR adjacency.
-
-Fallback Conditions (auto‑detected):
- - Missing slabs / adjacency structures.
- - Topology/gating/stochastic predicates fail (see `_canUseFastSlab`).
- - Gating present, when applicable (explicit guard).
-
-Implementation Notes:
- - Reuses internal activation/state buffers to reduce per‑step allocation churn.
- - Applies gain multiplication if optional gain slab exists.
- - Assumes acyclic graph; topological order recomputed on demand if marked dirty.
-
-Parameters:
-- `input` - Input vector (length must equal `network.input`).
-
-Returns: Output activations (detached plain array) of length `network.output`.
-
-### canUseFastSlab
-
-```ts
-canUseFastSlab(
-  training: boolean,
-): boolean
-```
-
-Public convenience wrapper exposing fast path eligibility.
-Mirrors `_canUseFastSlab` internal predicate.
-
-Parameters:
-- `training` - Whether caller is performing training (disables fast path if true).
-
-Returns: True when slab fast path predicates hold.
-
-### getSlabVersion
-
-```ts
-getSlabVersion(): number
-```
-
-Retrieve current monotonic slab version (increments on each successful rebuild).
-
-Returns: Non‑negative integer (0 if slab never built yet).
-
-### ConnectionSlabView
-
-Shape returned by getConnectionSlab describing the packed SoA view.
-
 ## architecture/network/slab/network.slab.pool.utils.ts
 
 Internal slab pool/stat helpers extracted from network.slab.utils.ts.
@@ -282,25 +282,6 @@ Parameters:
 
 Returns: Acquired typed array.
 
-### _releaseTA
-
-```ts
-_releaseTA(
-  kind: string,
-  bytesPerElement: number,
-  arr: TypedArray,
-): void
-```
-
-Releases a typed array back to bounded per-key pool.
-
-Parameters:
-- `kind` - - Pool kind discriminator.
-- `bytesPerElement` - - Element byte width for keying.
-- `arr` - - Typed array instance to retain when room exists.
-
-Returns: Nothing.
-
 ### _getSlabAllocationStatsSnapshot
 
 ```ts
@@ -311,16 +292,6 @@ Returns allocation stats snapshot for slab typed arrays.
 
 Returns: Serializable snapshot of fresh, pooled, and per-key metrics.
 
-### _slabPoolCap
-
-```ts
-_slabPoolCap(): number
-```
-
-Computes retention cap per key.
-
-Returns: Non-negative max retained arrays per key.
-
 ### _poolKey
 
 ```ts
@@ -340,52 +311,66 @@ Parameters:
 
 Returns: Stable pool key.
 
-## architecture/network/slab/network.slab.view.utils.ts
-
-### _createConnectionSlabView
+### _releaseTA
 
 ```ts
-_createConnectionSlabView(
-  network: default,
-): ConnectionSlabView
+_releaseTA(
+  kind: string,
+  bytesPerElement: number,
+  arr: TypedArray,
+): void
 ```
 
-Creates a read-oriented packed slab view from current network internals.
+Releases a typed array back to bounded per-key pool.
 
 Parameters:
-- `network` - - Target network.
+- `kind` - - Pool kind discriminator.
+- `bytesPerElement` - - Element byte width for keying.
+- `arr` - - Typed array instance to retain when room exists.
 
-Returns: Packed connection slab view.
+Returns: Nothing.
 
-### _readSlabVersion
+### _slabPoolCap
 
 ```ts
-_readSlabVersion(
+_slabPoolCap(): number
+```
+
+Computes retention cap per key.
+
+Returns: Non-negative max retained arrays per key.
+
+## architecture/network/slab/network.slab.view.utils.ts
+
+### _createConnectionSlabView
+
+```ts
+_createConnectionSlabView(
   network: default,
-): number
+): ConnectionSlabView
 ```
 
-Reads the current monotonic slab version from network internals.
+Creates a read-oriented packed slab view from current network internals.
 
 Parameters:
 - `network` - - Target network.
 
-Returns: Non-negative slab version counter.
+Returns: Packed connection slab view.
 
-### _resolveConnectionSlabCapacity
+### _readSlabVersion
 
 ```ts
-_resolveConnectionSlabCapacity(
-  internalNet: NetworkSlabProps,
+_readSlabVersion(
+  network: default,
 ): number
 ```
 
-Resolves effective slab capacity using explicit capacity first.
+Reads the current monotonic slab version from network internals.
 
 Parameters:
-- `internalNet` - - Internal slab runtime shape.
+- `network` - - Target network.
 
-Returns: Effective capacity value.
+Returns: Non-negative slab version counter.
 
 ### _resolveConnectionGainView
 
@@ -404,6 +389,21 @@ Parameters:
 
 Returns: Gain array view.
 
+### _resolveConnectionSlabCapacity
+
+```ts
+_resolveConnectionSlabCapacity(
+  internalNet: NetworkSlabProps,
+): number
+```
+
+Resolves effective slab capacity using explicit capacity first.
+
+Parameters:
+- `internalNet` - - Internal slab runtime shape.
+
+Returns: Effective capacity value.
+
 ## architecture/network/slab/network.slab.setup.utils.ts
 
 ### _prepareSlabBuildPreconditions
@@ -461,112 +461,63 @@ Returns: Nothing.
 
 Internal slab rebuild helper functions extracted from network.slab.utils.ts.
 
-### _createSlabBuildContext
-
-```ts
-_createSlabBuildContext(
-  network: default,
-  growthFactor: number,
-): SlabBuildContext
-```
-
-Creates immutable slab build context for one rebuild pass.
-
-Parameters:
-- `network` - - Target network.
-- `growthFactor` - - Capacity growth multiplier.
-
-Returns: Build context.
-
-### _shouldSkipSlabRebuild
-
-```ts
-_shouldSkipSlabRebuild(
-  internalNet: NetworkSlabProps,
-  force: boolean,
-): boolean
-```
-
-Determines whether slab rebuild can be skipped.
-
-Parameters:
-- `internalNet` - - Internal slab runtime shape.
-- `force` - - True when rebuild must run regardless of dirty state.
-
-Returns: True when rebuild can be skipped.
-
-### _ensureSlabCapacitySync
+### _allocateCoreSlabArrays
 
 ```ts
-_ensureSlabCapacitySync(
+_allocateCoreSlabArrays(
   buildContext: SlabBuildContext,
 ): void
 ```
 
-Ensures sync rebuild has enough slab capacity.
+Allocates core slab arrays (weights/from/to/flags).
 
 Parameters:
 - `buildContext` - - Slab build context.
 
 Returns: Nothing.
 
-### _ensureSlabCapacityAsync
+### _allocateGainSlabForAsync
 
 ```ts
-_ensureSlabCapacityAsync(
+_allocateGainSlabForAsync(
   buildContext: SlabBuildContext,
 ): void
 ```
 
-Ensures async rebuild has enough slab capacity.
+Allocates gain slab for async pass prefill strategy.
 
 Parameters:
 - `buildContext` - - Slab build context.
 
 Returns: Nothing.
 
-### _populateSlabConnectionsSync
-
-```ts
-_populateSlabConnectionsSync(
-  buildContext: SlabBuildContext,
-): SlabPopulateResult
-```
-
-Populates core slab arrays in synchronous single pass.
-
-Parameters:
-- `buildContext` - - Slab build context.
-
-Returns: Population result flags and optional slabs.
-
-### _populateSlabConnectionsAsync
+### _applyGainOmissionPolicy
 
 ```ts
-_populateSlabConnectionsAsync(
+_applyGainOmissionPolicy(
   buildContext: SlabBuildContext,
-  chunkSize: number,
-): Promise<SlabPopulateResult>
+  populateResult: SlabPopulateResult,
+): void
 ```
 
-Populates core slab arrays in cooperative async chunks.
+Applies gain omission rule by releasing neutral gain slab.
 
 Parameters:
 - `buildContext` - - Slab build context.
-- `chunkSize` - - Maximum items per chunk.
+- `populateResult` - - Populate result.
 
-Returns: Population result flags and optional slabs.
+Returns: Nothing.
 
-### _applyGainOmissionPolicy
+### _applyPlasticPolicyAsync
 
 ```ts
-_applyGainOmissionPolicy(
+_applyPlasticPolicyAsync(
   buildContext: SlabBuildContext,
   populateResult: SlabPopulateResult,
 ): void
 ```
 
-Applies gain omission rule by releasing neutral gain slab.
+Applies async plastic slab allocation/release policy.
 
 Parameters:
 - `buildContext` - - Slab build context.
@@ -591,99 +542,101 @@ Parameters:
 
 Returns: Nothing.
 
-### _applyPlasticPolicyAsync
+### _createInitialSlabPopulateResult
 
 ```ts
-_applyPlasticPolicyAsync(
-  buildContext: SlabBuildContext,
-  populateResult: SlabPopulateResult,
-): void
+_createInitialSlabPopulateResult(
+  internalNet: NetworkSlabProps,
+): SlabPopulateResult
 ```
 
-Applies async plastic slab allocation/release policy.
+Creates initial populate result from current optional slab state.
 
 Parameters:
-- `buildContext` - - Slab build context.
-- `populateResult` - - Populate result.
+- `internalNet` - - Internal slab runtime shape.
 
-Returns: Nothing.
+Returns: Initial populate result.
 
-### _resolveAsyncChunkSize
+### _createSlabBuildContext
 
 ```ts
-_resolveAsyncChunkSize(
-  totalConnections: number,
-  requestedChunkSize: number,
-): number
+_createSlabBuildContext(
+  network: default,
+  growthFactor: number,
+): SlabBuildContext
 ```
 
-Resolves effective async chunk size using adaptive heuristics.
+Creates immutable slab build context for one rebuild pass.
 
 Parameters:
-- `totalConnections` - - Number of active connections.
-- `requestedChunkSize` - - Requested chunk size.
+- `network` - - Target network.
+- `growthFactor` - - Capacity growth multiplier.
 
-Returns: Effective chunk size.
+Returns: Build context.
 
-### _finalizeSyncSlabRebuild
+### _createSlabWriteArrays
 
 ```ts
-_finalizeSyncSlabRebuild(
+_createSlabWriteArrays(
   buildContext: SlabBuildContext,
-): void
+): SlabWriteArrays
 ```
 
-Finalizes sync rebuild bookkeeping fields.
+Creates strongly typed write-array bundle for connection population.
 
 Parameters:
 - `buildContext` - - Slab build context.
 
-Returns: Nothing.
+Returns: Write-array bundle.
 
-### _finalizeAsyncSlabRebuild
+### _ensureGainArrayExistsForIndex
 
 ```ts
-_finalizeAsyncSlabRebuild(
+_ensureGainArrayExistsForIndex(
   buildContext: SlabBuildContext,
+  populateResult: SlabPopulateResult,
+  connectionIndex: number,
 ): void
 ```
 
-Finalizes async rebuild bookkeeping fields.
+Ensures gain slab exists before writing non-neutral value.
 
 Parameters:
 - `buildContext` - - Slab build context.
+- `populateResult` - - Mutable populate result.
+- `connectionIndex` - - Current connection index.
 
 Returns: Nothing.
 
-### _weightByteWidth
+### _ensureSlabCapacityAsync
 
 ```ts
-_weightByteWidth(
-  useFloat32Weights: boolean | undefined,
-): number
+_ensureSlabCapacityAsync(
+  buildContext: SlabBuildContext,
+): void
 ```
 
-Resolves byte width for weight slab arrays.
+Ensures async rebuild has enough slab capacity.
 
 Parameters:
-- `useFloat32Weights` - - True when 32-bit weights are enabled.
+- `buildContext` - - Slab build context.
 
-Returns: Byte width for weight elements.
+Returns: Nothing.
 
-### _weightArrayCtor
+### _ensureSlabCapacitySync
 
 ```ts
-_weightArrayCtor(
-  useFloat32Weights: boolean | undefined,
-): Float32ArrayConstructor | Float64ArrayConstructor
+_ensureSlabCapacitySync(
+  buildContext: SlabBuildContext,
+): void
 ```
 
-Resolves typed-array constructor for weight slabs.
+Ensures sync rebuild has enough slab capacity.
 
 Parameters:
-- `useFloat32Weights` - - True when 32-bit weights are enabled.
+- `buildContext` - - Slab build context.
 
-Returns: Matching typed-array constructor.
+Returns: Nothing.
 
 ### _expandSlabCapacity
 
@@ -704,177 +657,190 @@ Parameters:
 
 Returns: Expanded capacity.
 
-### _releaseExistingSlabArrays
+### _fillPlasticityRates
 
 ```ts
-_releaseExistingSlabArrays(
-  buildContext: SlabBuildContext,
+_fillPlasticityRates(
+  network: default,
+  plasticArray: Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>,
+  connectionCount: number,
 ): void
 ```
 
-Releases all currently allocated slab arrays back to pool.
+Fills plastic slab values from connection plasticity rates.
 
 Parameters:
-- `buildContext` - - Slab build context.
+- `network` - - Target network.
+- `plasticArray` - - Plastic slab array.
+- `connectionCount` - - Number of active connections.
 
 Returns: Nothing.
 
-### _allocateCoreSlabArrays
+### _finalizeAsyncSlabRebuild
 
 ```ts
-_allocateCoreSlabArrays(
+_finalizeAsyncSlabRebuild(
   buildContext: SlabBuildContext,
 ): void
 ```
 
-Allocates core slab arrays (weights/from/to/flags).
+Finalizes async rebuild bookkeeping fields.
 
 Parameters:
 - `buildContext` - - Slab build context.
 
 Returns: Nothing.
 
-### _allocateGainSlabForAsync
+### _finalizeSharedSlabState
 
 ```ts
-_allocateGainSlabForAsync(
-  buildContext: SlabBuildContext,
+_finalizeSharedSlabState(
+  internalNet: NetworkSlabProps,
+  connectionCount: number,
 ): void
 ```
 
-Allocates gain slab for async pass prefill strategy.
+Finalizes shared rebuild bookkeeping fields.
 
 Parameters:
-- `buildContext` - - Slab build context.
+- `internalNet` - - Internal slab runtime shape.
+- `connectionCount` - - Number of active connections.
 
 Returns: Nothing.
 
-### _resetOptionalSlabArraysAfterSyncAllocate
+### _finalizeSyncSlabRebuild
 
 ```ts
-_resetOptionalSlabArraysAfterSyncAllocate(
-  internalNet: NetworkSlabProps,
+_finalizeSyncSlabRebuild(
+  buildContext: SlabBuildContext,
 ): void
 ```
 
-Resets optional slabs after sync allocation to keep omission semantics.
+Finalizes sync rebuild bookkeeping fields.
 
 Parameters:
-- `internalNet` - - Internal slab runtime shape.
+- `buildContext` - - Slab build context.
 
 Returns: Nothing.
 
-### _createSlabWriteArrays
+### _populateAsyncChunkRange
 
 ```ts
-_createSlabWriteArrays(
+_populateAsyncChunkRange(
   buildContext: SlabBuildContext,
-): SlabWriteArrays
+  writeArrays: SlabWriteArrays,
+  populateResult: SlabPopulateResult,
+  startIndex: number,
+  endIndex: number,
+): void
 ```
 
-Creates strongly typed write-array bundle for connection population.
+Populates one inclusive-exclusive chunk range for async rebuild.
 
 Parameters:
 - `buildContext` - - Slab build context.
+- `writeArrays` - - Core write arrays.
+- `populateResult` - - Mutable populate result.
+- `startIndex` - - Chunk start index.
+- `endIndex` - - Chunk end index.
 
-Returns: Write-array bundle.
+Returns: Nothing.
 
-### _createInitialSlabPopulateResult
+### _populateSlabConnectionsAsync
 
 ```ts
-_createInitialSlabPopulateResult(
-  internalNet: NetworkSlabProps,
+_populateSlabConnectionsAsync(
+  buildContext: SlabBuildContext,
+  chunkSize: number,
+): Promise<SlabPopulateResult>
+```
+
+Populates core slab arrays in cooperative async chunks.
+
+Parameters:
+- `buildContext` - - Slab build context.
+- `chunkSize` - - Maximum items per chunk.
+
+Returns: Population result flags and optional slabs.
+
+### _populateSlabConnectionsSync
+
+```ts
+_populateSlabConnectionsSync(
+  buildContext: SlabBuildContext,
 ): SlabPopulateResult
 ```
 
-Creates initial populate result from current optional slab state.
+Populates core slab arrays in synchronous single pass.
 
 Parameters:
-- `internalNet` - - Internal slab runtime shape.
+- `buildContext` - - Slab build context.
 
-Returns: Initial populate result.
+Returns: Population result flags and optional slabs.
 
-### _populateAsyncChunkRange
+### _releaseExistingSlabArrays
 
 ```ts
-_populateAsyncChunkRange(
+_releaseExistingSlabArrays(
   buildContext: SlabBuildContext,
-  writeArrays: SlabWriteArrays,
-  populateResult: SlabPopulateResult,
-  startIndex: number,
-  endIndex: number,
 ): void
 ```
 
-Populates one inclusive-exclusive chunk range for async rebuild.
+Releases all currently allocated slab arrays back to pool.
 
 Parameters:
 - `buildContext` - - Slab build context.
-- `writeArrays` - - Core write arrays.
-- `populateResult` - - Mutable populate result.
-- `startIndex` - - Chunk start index.
-- `endIndex` - - Chunk end index.
 
 Returns: Nothing.
 
-### _writeConnectionCoreFields
+### _resetOptionalSlabArraysAfterSyncAllocate
 
 ```ts
-_writeConnectionCoreFields(
-  writeArrays: SlabWriteArrays,
-  connection: ConnectionInternals,
-  connectionIndex: number,
+_resetOptionalSlabArraysAfterSyncAllocate(
+  internalNet: NetworkSlabProps,
 ): void
 ```
 
-Writes core fields for one connection into slab arrays.
+Resets optional slabs after sync allocation to keep omission semantics.
 
 Parameters:
-- `writeArrays` - - Core write arrays.
-- `connection` - - Connection internals.
-- `connectionIndex` - - Connection index.
+- `internalNet` - - Internal slab runtime shape.
 
 Returns: Nothing.
 
-### _writeConnectionGainField
+### _resolveAsyncChunkSize
 
 ```ts
-_writeConnectionGainField(
-  buildContext: SlabBuildContext,
-  populateResult: SlabPopulateResult,
-  connection: ConnectionInternals,
-  connectionIndex: number,
-): void
+_resolveAsyncChunkSize(
+  totalConnections: number,
+  requestedChunkSize: number,
+): number
 ```
 
-Writes gain field for one connection and updates gain flags.
+Resolves effective async chunk size using adaptive heuristics.
 
 Parameters:
-- `buildContext` - - Slab build context.
-- `populateResult` - - Mutable populate result.
-- `connection` - - Connection internals.
-- `connectionIndex` - - Connection index.
+- `totalConnections` - - Number of active connections.
+- `requestedChunkSize` - - Requested chunk size.
 
-Returns: Nothing.
+Returns: Effective chunk size.
 
-### _ensureGainArrayExistsForIndex
+### _shouldSkipSlabRebuild
 
 ```ts
-_ensureGainArrayExistsForIndex(
-  buildContext: SlabBuildContext,
-  populateResult: SlabPopulateResult,
-  connectionIndex: number,
-): void
+_shouldSkipSlabRebuild(
+  internalNet: NetworkSlabProps,
+  force: boolean,
+): boolean
 ```
 
-Ensures gain slab exists before writing non-neutral value.
+Determines whether slab rebuild can be skipped.
 
 Parameters:
-- `buildContext` - - Slab build context.
-- `populateResult` - - Mutable populate result.
-- `connectionIndex` - - Current connection index.
+- `internalNet` - - Internal slab runtime shape.
+- `force` - - True when rebuild must run regardless of dirty state.
 
-Returns: Nothing.
+Returns: True when rebuild can be skipped.
 
 ### _updatePlasticPresence
 
@@ -893,39 +859,73 @@ Parameters:
 
 Returns: Nothing.
 
-### _fillPlasticityRates
+### _weightArrayCtor
 
 ```ts
-_fillPlasticityRates(
-  network: default,
-  plasticArray: Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>,
-  connectionCount: number,
+_weightArrayCtor(
+  useFloat32Weights: boolean | undefined,
+): Float32ArrayConstructor | Float64ArrayConstructor
+```
+
+Resolves typed-array constructor for weight slabs.
+
+Parameters:
+- `useFloat32Weights` - - True when 32-bit weights are enabled.
+
+Returns: Matching typed-array constructor.
+
+### _weightByteWidth
+
+```ts
+_weightByteWidth(
+  useFloat32Weights: boolean | undefined,
+): number
+```
+
+Resolves byte width for weight slab arrays.
+
+Parameters:
+- `useFloat32Weights` - - True when 32-bit weights are enabled.
+
+Returns: Byte width for weight elements.
+
+### _writeConnectionCoreFields
+
+```ts
+_writeConnectionCoreFields(
+  writeArrays: SlabWriteArrays,
+  connection: ConnectionInternals,
+  connectionIndex: number,
 ): void
 ```
 
-Fills plastic slab values from connection plasticity rates.
+Writes core fields for one connection into slab arrays.
 
 Parameters:
-- `network` - - Target network.
-- `plasticArray` - - Plastic slab array.
-- `connectionCount` - - Number of active connections.
+- `writeArrays` - - Core write arrays.
+- `connection` - - Connection internals.
+- `connectionIndex` - - Connection index.
 
 Returns: Nothing.
 
-### _finalizeSharedSlabState
+### _writeConnectionGainField
 
 ```ts
-_finalizeSharedSlabState(
-  internalNet: NetworkSlabProps,
-  connectionCount: number,
+_writeConnectionGainField(
+  buildContext: SlabBuildContext,
+  populateResult: SlabPopulateResult,
+  connection: ConnectionInternals,
+  connectionIndex: number,
 ): void
 ```
 
-Finalizes shared rebuild bookkeeping fields.
+Writes gain field for one connection and updates gain flags.
 
 Parameters:
-- `internalNet` - - Internal slab runtime shape.
-- `connectionCount` - - Number of active connections.
+- `buildContext` - - Slab build context.
+- `populateResult` - - Mutable populate result.
+- `connection` - - Connection internals.
+- `connectionIndex` - - Connection index.
 
 Returns: Nothing.
 
@@ -948,35 +948,35 @@ Parameters:
 
 Returns: Nothing.
 
-### createBuildAdjacencyContext
+### asNetworkSlabProps
 
 ```ts
-createBuildAdjacencyContext(
+asNetworkSlabProps(
   network: default,
-): BuildAdjacencyContext | null
+): NetworkSlabProps
 ```
 
-Build adjacency context when required slabs are available.
+Cast network instance into internal slab-backed shape.
 
 Parameters:
 - `network` - - Target network.
 
-Returns: Build context or null when adjacency cannot be built yet.
+Returns: Internal slab-backed network representation.
 
-### collectFanOutCounts
+### buildOutgoingOrder
 
 ```ts
-collectFanOutCounts(
-  buildContext: BuildAdjacencyContext,
+buildOutgoingOrder(
+  outgoingOrderBuildContext: OutgoingOrderBuildContext,
 ): Uint32Array<ArrayBufferLike>
 ```
 
-Collect fan-out counts for each source node.
+Build source-grouped outgoing order using CSR start offsets.
 
 Parameters:
-- `buildContext` - - Shared adjacency build context.
+- `outgoingOrderBuildContext` - - Context holding build data and start offsets.
 
-Returns: Fan-out counts per node.
+Returns: Ordered outgoing connection indices.
 
 ### buildOutgoingStartIndices
 
@@ -993,35 +993,35 @@ Parameters:
 
 Returns: Outgoing start indices slab.
 
-### buildOutgoingOrder
+### collectFanOutCounts
 
 ```ts
-buildOutgoingOrder(
-  outgoingOrderBuildContext: OutgoingOrderBuildContext,
+collectFanOutCounts(
+  buildContext: BuildAdjacencyContext,
 ): Uint32Array<ArrayBufferLike>
 ```
 
-Build source-grouped outgoing order using CSR start offsets.
+Collect fan-out counts for each source node.
 
 Parameters:
-- `outgoingOrderBuildContext` - - Context holding build data and start offsets.
+- `buildContext` - - Shared adjacency build context.
 
-Returns: Ordered outgoing connection indices.
+Returns: Fan-out counts per node.
 
-### publishAdjacency
+### createBuildAdjacencyContext
 
 ```ts
-publishAdjacency(
-  publishAdjacencyContext: PublishAdjacencyContext,
-): void
+createBuildAdjacencyContext(
+  network: default,
+): BuildAdjacencyContext | null
 ```
 
-Publish adjacency slabs and clear dirty flag.
+Build adjacency context when required slabs are available.
 
 Parameters:
-- `publishAdjacencyContext` - - Values to publish on the internal network slab state.
+- `network` - - Target network.
 
-Returns: Nothing.
+Returns: Build context or null when adjacency cannot be built yet.
 
 ### createFanOutCollectionContext
 
@@ -1038,50 +1038,50 @@ Parameters:
 
 Returns: Fan-out collection context.
 
-### populateFanOutCounts
+### createFanOutCountsBuffer
 
 ```ts
-populateFanOutCounts(
-  fanOutCollectionContext: FanOutCollectionContext,
-): void
+createFanOutCountsBuffer(
+  nodeCount: number,
+): Uint32Array<ArrayBufferLike>
 ```
 
-Populate fan-out counts from the connection source slab.
+Allocate fan-out counts buffer.
 
 Parameters:
-- `fanOutCollectionContext` - - Fan-out collection context.
+- `nodeCount` - - Number of nodes.
 
-Returns: Nothing.
+Returns: Zero-initialized fan-out counts.
 
-### incrementFanOutCountAtSource
+### createInsertionCursor
 
 ```ts
-incrementFanOutCountAtSource(
-  context: { fanOutCounts: Uint32Array<ArrayBufferLike>; connectionFromSlab: Uint32Array<ArrayBufferLike>; connectionIndex: number; },
-): void
+createInsertionCursor(
+  outgoingStartIndices: Uint32Array<ArrayBufferLike>,
+): Uint32Array<ArrayBufferLike>
 ```
 
-Increment fan-out count for one connection source index.
+Create insertion cursor copy from outgoing start indices.
 
 Parameters:
-- `context` - - Increment context.
+- `outgoingStartIndices` - - Outgoing start indices slab.
 
-Returns: Nothing.
+Returns: Mutable insertion cursor.
 
-### createFanOutCountsBuffer
+### createOutgoingOrderBuffer
 
 ```ts
-createFanOutCountsBuffer(
-  nodeCount: number,
+createOutgoingOrderBuffer(
+  connectionCount: number,
 ): Uint32Array<ArrayBufferLike>
 ```
 
-Allocate fan-out counts buffer.
+Allocate outgoing order buffer.
 
 Parameters:
-- `nodeCount` - - Number of nodes.
+- `connectionCount` - - Number of active connections.
 
-Returns: Zero-initialized fan-out counts.
+Returns: Outgoing order buffer.
 
 ### createOutgoingStartIndicesBuffer
 
@@ -1098,78 +1098,33 @@ Parameters:
 
 Returns: Outgoing start indices buffer.
 
-### populateOutgoingStartIndices
-
-```ts
-populateOutgoingStartIndices(
-  context: { fanOutCounts: Uint32Array<ArrayBufferLike>; outgoingStartIndices: Uint32Array<ArrayBufferLike>; },
-): number
-```
-
-Populate outgoing start indices and return terminal offset.
-
-Parameters:
-- `context` - - Population context.
-
-Returns: Terminal running offset after the last node.
-
-### setTerminalOutgoingStartOffset
-
-```ts
-setTerminalOutgoingStartOffset(
-  context: { nodeCount: number; outgoingStartIndices: Uint32Array<ArrayBufferLike>; terminalRunningOffset: number; },
-): void
-```
-
-Set terminal outgoing start offset at the tail slot.
-
-Parameters:
-- `context` - - Terminal offset context.
-
-Returns: Nothing.
-
-### createOutgoingOrderBuffer
-
-```ts
-createOutgoingOrderBuffer(
-  connectionCount: number,
-): Uint32Array<ArrayBufferLike>
-```
-
-Allocate outgoing order buffer.
-
-Parameters:
-- `connectionCount` - - Number of active connections.
-
-Returns: Outgoing order buffer.
-
-### createInsertionCursor
+### hasRequiredConnectionSlabs
 
 ```ts
-createInsertionCursor(
-  outgoingStartIndices: Uint32Array<ArrayBufferLike>,
-): Uint32Array<ArrayBufferLike>
+hasRequiredConnectionSlabs(
+  internalNet: NetworkSlabProps,
+): boolean
 ```
 
-Create insertion cursor copy from outgoing start indices.
+Check whether required connection slabs exist.
 
 Parameters:
-- `outgoingStartIndices` - - Outgoing start indices slab.
+- `internalNet` - - Internal slab-backed network representation.
 
-Returns: Mutable insertion cursor.
+Returns: True when adjacency build prerequisites are present.
 
-### populateOutgoingOrder
+### incrementFanOutCountAtSource
 
 ```ts
-populateOutgoingOrder(
-  context: { connectionCount: number; connectionFromSlab: Uint32Array<ArrayBufferLike>; outgoingOrder: Uint32Array<ArrayBufferLike>; insertionCursor: Uint32Array<ArrayBufferLike>; },
+incrementFanOutCountAtSource(
+  context: { fanOutCounts: Uint32Array<ArrayBufferLike>; connectionFromSlab: Uint32Array<ArrayBufferLike>; connectionIndex: number; },
 ): void
 ```
 
-Populate outgoing order by source-grouped insertion.
+Increment fan-out count for one connection source index.
 
 Parameters:
-- `context` - - Outgoing order population context.
+- `context` - - Increment context.
 
 Returns: Nothing.
 
@@ -1222,204 +1177,169 @@ Parameters:
 
 Returns: Nothing.
 
-### hasRequiredConnectionSlabs
-
-```ts
-hasRequiredConnectionSlabs(
-  internalNet: NetworkSlabProps,
-): boolean
-```
-
-Check whether required connection slabs exist.
-
-Parameters:
-- `internalNet` - - Internal slab-backed network representation.
-
-Returns: True when adjacency build prerequisites are present.
-
-### asNetworkSlabProps
+### populateFanOutCounts
 
 ```ts
-asNetworkSlabProps(
-  network: default,
-): NetworkSlabProps
+populateFanOutCounts(
+  fanOutCollectionContext: FanOutCollectionContext,
+): void
 ```
 
-Cast network instance into internal slab-backed shape.
+Populate fan-out counts from the connection source slab.
 
 Parameters:
-- `network` - - Target network.
-
-Returns: Internal slab-backed network representation.
-
-## architecture/network/slab/network.slab.fast-path.helpers.utils.ts
+- `fanOutCollectionContext` - - Fan-out collection context.
 
-Internal fast slab activation helpers extracted from network.slab.utils.ts.
+Returns: Nothing.
 
-### _canUseFastSlab
+### populateOutgoingOrder
 
 ```ts
-_canUseFastSlab(
-  training: boolean,
-): boolean
+populateOutgoingOrder(
+  context: { connectionCount: number; connectionFromSlab: Uint32Array<ArrayBufferLike>; outgoingOrder: Uint32Array<ArrayBufferLike>; insertionCursor: Uint32Array<ArrayBufferLike>; },
+): void
 ```
 
-Predicate gating usage of high-performance slab forward pass.
+Populate outgoing order by source-grouped insertion.
 
 Parameters:
-- `training` - - Whether caller is in training mode.
+- `context` - - Outgoing order population context.
 
-Returns: True if fast path can be safely used.
+Returns: Nothing.
 
-### _tryFastSlabFallbackForGating
+### populateOutgoingStartIndices
 
 ```ts
-_tryFastSlabFallbackForGating(
-  network: default,
-  input: number[],
-): number[] | null
+populateOutgoingStartIndices(
+  context: { fanOutCounts: Uint32Array<ArrayBufferLike>; outgoingStartIndices: Uint32Array<ArrayBufferLike>; },
+): number
 ```
 
-Falls back to legacy activation when gating is present.
+Populate outgoing start indices and return terminal offset.
 
 Parameters:
-- `network` - - Target network.
-- `input` - - Activation input.
+- `context` - - Population context.
 
-Returns: Legacy output or null when fast path may continue.
+Returns: Terminal running offset after the last node.
 
-### _tryFastSlabFallbackForMissingPrerequisites
+### publishAdjacency
 
 ```ts
-_tryFastSlabFallbackForMissingPrerequisites(
-  network: default,
-  internalNet: NetworkSlabProps,
-  input: number[],
-): number[] | null
+publishAdjacency(
+  publishAdjacencyContext: PublishAdjacencyContext,
+): void
 ```
 
-Falls back to legacy activation when slab prerequisites are missing.
+Publish adjacency slabs and clear dirty flag.
 
 Parameters:
-- `network` - - Target network.
-- `internalNet` - - Internal slab runtime shape.
-- `input` - - Activation input.
+- `publishAdjacencyContext` - - Values to publish on the internal network slab state.
 
-Returns: Legacy output or null when fast path may continue.
+Returns: Nothing.
 
-### _prepareFastSlabRuntime
+### setTerminalOutgoingStartOffset
 
 ```ts
-_prepareFastSlabRuntime(
-  network: default,
-  internalNet: NetworkSlabProps,
-  reindexNodes: (network: default) => void,
+setTerminalOutgoingStartOffset(
+  context: { nodeCount: number; outgoingStartIndices: Uint32Array<ArrayBufferLike>; terminalRunningOffset: number; },
 ): void
 ```
 
-Prepares topology and indices for fast slab pass.
+Set terminal outgoing start offset at the tail slot.
 
 Parameters:
-- `network` - - Target network.
-- `internalNet` - - Internal slab runtime shape.
-- `reindexNodes` - - Callback used to reindex nodes when needed.
+- `context` - - Terminal offset context.
 
 Returns: Nothing.
 
-### _resolveFastTopoOrder
+## architecture/network/slab/network.slab.fast-path.helpers.utils.ts
+
+Internal fast slab activation helpers extracted from network.slab.utils.ts.
+
+### _activateThroughLegacyPath
 
 ```ts
-_resolveFastTopoOrder(
+_activateThroughLegacyPath(
   network: default,
-  internalNet: NetworkSlabProps,
-): FastSlabNodeRuntime[]
+  input: number[],
+): number[]
 ```
 
-Resolves topological iteration order for fast slab pass.
+Executes legacy network activation fallback.
 
 Parameters:
 - `network` - - Target network.
-- `internalNet` - - Internal slab runtime shape.
+- `input` - - Activation input.
 
-Returns: Topological node order.
+Returns: Legacy activation output.
 
-### _ensureFastSlabBuffers
+### _canUseFastSlab
 
 ```ts
-_ensureFastSlabBuffers(
-  internalNet: NetworkSlabProps,
-  nodeCount: number,
-): void
+_canUseFastSlab(
+  training: boolean,
+): boolean
 ```
 
-Ensures fast activation/state buffers are allocated and shape-compatible.
+Predicate gating usage of high-performance slab forward pass.
 
 Parameters:
-- `internalNet` - - Internal slab runtime shape.
-- `nodeCount` - - Node count.
+- `training` - - Whether caller is in training mode.
 
-Returns: Nothing.
+Returns: True if fast path can be safely used.
 
-### _seedFastInputLayer
+### _collectFastSlabOutput
 
 ```ts
-_seedFastInputLayer(
+_collectFastSlabOutput(
   network: default,
-  input: number[],
   activationBuffer: Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>,
-): void
+  nodeCount: number,
+): number[]
 ```
 
-Seeds input-layer activations for fast slab pass.
+Collects output activations into detached number array.
 
 Parameters:
 - `network` - - Target network.
-- `input` - - Activation input.
 - `activationBuffer` - - Activation buffer.
+- `nodeCount` - - Node count.
 
-Returns: Nothing.
+Returns: Output activation array.
 
-### _propagateFastSlabActivations
+### _createFastActivationBuffer
 
 ```ts
-_propagateFastSlabActivations(
-  network: default,
-  internalNet: NetworkSlabProps,
-  topoOrder: FastSlabNodeRuntime[],
-  activationBuffer: Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>,
-  stateBuffer: Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>,
-): void
+_createFastActivationBuffer(
+  useFloat32Activation: boolean,
+  nodeCount: number,
+): Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>
 ```
 
-Propagates activations through topology using slab arrays.
+Creates typed fast activation/state buffer.
 
 Parameters:
-- `network` - - Target network.
-- `internalNet` - - Internal slab runtime shape.
-- `topoOrder` - - Topological node order.
-- `activationBuffer` - - Activation buffer.
-- `stateBuffer` - - State buffer.
+- `useFloat32Activation` - - True when 32-bit buffer is required.
+- `nodeCount` - - Node count.
 
-Returns: Nothing.
+Returns: New typed buffer.
 
-### _collectFastSlabOutput
+### _ensureFastSlabBuffers
 
 ```ts
-_collectFastSlabOutput(
-  network: default,
-  activationBuffer: Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>,
+_ensureFastSlabBuffers(
+  internalNet: NetworkSlabProps,
   nodeCount: number,
-): number[]
+): void
 ```
 
-Collects output activations into detached number array.
+Ensures fast activation/state buffers are allocated and shape-compatible.
 
 Parameters:
-- `network` - - Target network.
-- `activationBuffer` - - Activation buffer.
+- `internalNet` - - Internal slab runtime shape.
 - `nodeCount` - - Node count.
 
-Returns: Output activation array.
+Returns: Nothing.
 
 ### _hasFastSlabPrerequisites
 
@@ -1436,35 +1356,26 @@ Parameters:
 
 Returns: True when all required slabs/adjacency arrays exist.
 
-### _activateThroughLegacyPath
-
-```ts
-_activateThroughLegacyPath(
-  network: default,
-  input: number[],
-): number[]
-```
-
-Executes legacy network activation fallback.
-
-Parameters:
-- `network` - - Target network.
-- `input` - - Activation input.
-
-Returns: Legacy activation output.
-
-### _recomputeTopologyOrder
+### _maybeActivateNonInputNode
 
 ```ts
-_recomputeTopologyOrder(
+_maybeActivateNonInputNode(
   network: default,
+  node: FastSlabNodeRuntime,
+  nodeIndex: number,
+  stateBuffer: Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>,
+  activationBuffer: Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>,
 ): void
 ```
 
-Recomputes topological order on demand.
+Activates one non-input node when required.
 
 Parameters:
 - `network` - - Target network.
+- `node` - - Current node.
+- `nodeIndex` - - Node index.
+- `stateBuffer` - - State buffer.
+- `activationBuffer` - - Activation buffer.
 
 Returns: Nothing.
 
@@ -1487,60 +1398,45 @@ Parameters:
 
 Returns: True when replacement is needed.
 
-### _createFastActivationBuffer
-
-```ts
-_createFastActivationBuffer(
-  useFloat32Activation: boolean,
-  nodeCount: number,
-): Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>
-```
-
-Creates typed fast activation/state buffer.
-
-Parameters:
-- `useFloat32Activation` - - True when 32-bit buffer is required.
-- `nodeCount` - - Node count.
-
-Returns: New typed buffer.
-
-### _writeInputNodeRuntime
+### _prepareFastSlabRuntime
 
 ```ts
-_writeInputNodeRuntime(
-  node: default,
-  inputValue: number,
+_prepareFastSlabRuntime(
+  network: default,
+  internalNet: NetworkSlabProps,
+  reindexNodes: (network: default) => void,
 ): void
 ```
 
-Writes runtime activation/state for one input node.
+Prepares topology and indices for fast slab pass.
 
 Parameters:
-- `node` - - Input node.
-- `inputValue` - - Input activation value.
+- `network` - - Target network.
+- `internalNet` - - Internal slab runtime shape.
+- `reindexNodes` - - Callback used to reindex nodes when needed.
 
 Returns: Nothing.
 
-### _maybeActivateNonInputNode
+### _propagateFastSlabActivations
 
 ```ts
-_maybeActivateNonInputNode(
+_propagateFastSlabActivations(
   network: default,
-  node: FastSlabNodeRuntime,
-  nodeIndex: number,
-  stateBuffer: Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>,
+  internalNet: NetworkSlabProps,
+  topoOrder: FastSlabNodeRuntime[],
   activationBuffer: Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>,
+  stateBuffer: Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>,
 ): void
 ```
 
-Activates one non-input node when required.
+Propagates activations through topology using slab arrays.
 
 Parameters:
 - `network` - - Target network.
-- `node` - - Current node.
-- `nodeIndex` - - Node index.
-- `stateBuffer` - - State buffer.
+- `internalNet` - - Internal slab runtime shape.
+- `topoOrder` - - Topological node order.
 - `activationBuffer` - - Activation buffer.
+- `stateBuffer` - - State buffer.
 
 Returns: Nothing.
 
@@ -1573,6 +1469,38 @@ Parameters:
 
 Returns: Nothing.
 
+### _recomputeTopologyOrder
+
+```ts
+_recomputeTopologyOrder(
+  network: default,
+): void
+```
+
+Recomputes topological order on demand.
+
+Parameters:
+- `network` - - Target network.
+
+Returns: Nothing.
+
+### _resolveFastTopoOrder
+
+```ts
+_resolveFastTopoOrder(
+  network: default,
+  internalNet: NetworkSlabProps,
+): FastSlabNodeRuntime[]
+```
+
+Resolves topological iteration order for fast slab pass.
+
+Parameters:
+- `network` - - Target network.
+- `internalNet` - - Internal slab runtime shape.
+
+Returns: Topological node order.
+
 ### _resolveWeightedConnectionValue
 
 ```ts
@@ -1591,3 +1519,75 @@ Parameters:
 - `connectionIndex` - - Connection index.
 
 Returns: Effective weighted value.
+
+### _seedFastInputLayer
+
+```ts
+_seedFastInputLayer(
+  network: default,
+  input: number[],
+  activationBuffer: Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>,
+): void
+```
+
+Seeds input-layer activations for fast slab pass.
+
+Parameters:
+- `network` - - Target network.
+- `input` - - Activation input.
+- `activationBuffer` - - Activation buffer.
+
+Returns: Nothing.
+
+### _tryFastSlabFallbackForGating
+
+```ts
+_tryFastSlabFallbackForGating(
+  network: default,
+  input: number[],
+): number[] | null
+```
+
+Falls back to legacy activation when gating is present.
+
+Parameters:
+- `network` - - Target network.
+- `input` - - Activation input.
+
+Returns: Legacy output or null when fast path may continue.
+
+### _tryFastSlabFallbackForMissingPrerequisites
+
+```ts
+_tryFastSlabFallbackForMissingPrerequisites(
+  network: default,
+  internalNet: NetworkSlabProps,
+  input: number[],
+): number[] | null
+```
+
+Falls back to legacy activation when slab prerequisites are missing.
+
+Parameters:
+- `network` - - Target network.
+- `internalNet` - - Internal slab runtime shape.
+- `input` - - Activation input.
+
+Returns: Legacy output or null when fast path may continue.
+
+### _writeInputNodeRuntime
+
+```ts
+_writeInputNodeRuntime(
+  node: default,
+  inputValue: number,
+): void
+```
+
+Writes runtime activation/state for one input node.
+
+Parameters:
+- `node` - - Input node.
+- `inputValue` - - Input activation value.
+
+Returns: Nothing.