Finalize bounded typed pipeline implementation

internal/framework/pipeline/runner_concurrency_test.go

@@ -178,6 +178,59 @@ func TestRunnerStartsLaneContinuationWhileOtherLaneExtractsRemain(t *testing.T)
 	}
 }
 
+func TestRunnerBoundsConcurrentLaneContinuations(t *testing.T) {
+	prepared := preparedConcurrentPipeline(t, 1)
+	base := prepared.lanes[0]
+	lanes := make([]preparedLaneExecutor, 8)
+	resolvedLanes := make([]ResolvedArtifactLane, len(lanes))
+	publicLanes := make([]PreparedArtifactLane, len(lanes))
+	var active atomic.Int32
+	var maximum atomic.Int32
+	for i := range lanes {
+		lane := base
+		lane.resolved.ID = fmt.Sprintf("lane-%02d", i)
+		lane.typed = &preparedTypedLane{
+			extractor:  base.typed.extractor,
+			merger:     base.typed.merger,
+			normalizer: base.typed.normalizer,
+			extract: func(_ context.Context, _ any, request contracts.TypedExtractionRequest) (erasedTypedResult, error) {
+				return erasedTypedResult{Value: codecNotes{Items: []string{request.Chunk.ID}}}, nil
+			},
+			merge: func(_ context.Context, _ any, _ contracts.TypedMergeRequest[any]) (erasedTypedResult, error) {
+				current := active.Add(1)
+				defer active.Add(-1)
+				for {
+					seen := maximum.Load()
+					if current <= seen || maximum.CompareAndSwap(seen, current) {
+						break
+					}
+				}
+				time.Sleep(5 * time.Millisecond)
+				return erasedTypedResult{Value: codecNotes{}}, nil
+			},
+			normalize: base.typed.normalize,
+			codec:     base.typed.codec,
+		}
+		lanes[i] = lane
+		resolvedLanes[i] = lane.resolved
+		publicLanes[i] = PreparedArtifactLane{Resolved: lane.resolved}
+	}
+	prepared.lanes = lanes
+	prepared.resolved.ArtifactLanes = resolvedLanes
+	prepared.ArtifactLanes = publicLanes
+
+	output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input"), ExtractWorkers: 2})
+	if err != nil {
+		t.Fatalf("Run() error = %v", err)
+	}
+	if len(output.NormalizeOutputs) != len(lanes) {
+		t.Fatalf("normalize outputs = %d, want %d", len(output.NormalizeOutputs), len(lanes))
+	}
+	if got := maximum.Load(); got != 2 {
+		t.Fatalf("maximum concurrent lane continuations = %d, want 2", got)
+	}
+}
+
 func TestRunnerSelectsFrameworkErrorByStableLaneOrder(t *testing.T) {
 	prepared := preparedConcurrentPipeline(t, 1)
 	ready := make(chan struct{}, 2)