Mark undelivered Channel items on cancellation without erasing prior errors

[MasterOfBinary]

Current outcome

Keep the successfully delivered prefix distinct from the undelivered remainder when a channel sink is canceled.

Replanned on 2026-09-06 against GoBatch master 63ef757 and ShitQuant's recorder, enrichment, paper/replay, and flow workloads. This is an implementation target, not a claim that the behavior already exists.

Required behavior

• Preserve success for items actually delivered before cancellation.
• Mark healthy undelivered items canceled/skipped under the chosen item-status contract; preserve earlier errors unchanged.
• Return a distinguishable stage cancellation outcome where appropriate, consistent with Preserve item/stage error identity and define reporting cardinality #79/Make Transform StopOnError fail closed without duplicate failure reports #82 counting.
• Do not claim output delivery from a nil Item.Error alone after a failed stage.

Verification and completion

Cancel after one synchronized send to a controlled/unbuffered consumer; assert exactly which items arrived and each remaining item's status/cause. Include a prior-error item.

Follow the repository's formatting, race-test, vet/lint, package documentation, example and changelog requirements for the changed surface. Report the actual supported behavior and migration; do not treat a passing coverage percentage as proof of these outcomes.

Scope and relationships

Precise bug remains useful independently. Coordinate lifecycle and #79, without making a future flow package a prerequisite.

Design history

The earlier report/prototype remains below for provenance; the requirements above supersede conflicting prescriptions. Existing discussion is preserved.

Original issue: processor.Channel reports undelivered items as successful on context cancel

When the context is canceled mid-batch, processor.Channel.Process returns immediately with the remaining unsent items untouched (processor/channel.go:30-34):

select {
case <-ctx.Done():
    return items, ctx.Err()
case p.Output <- item.Data:
}

The stage error becomes a single ProcessorError, but every item that never reached Output comes back with Error == nil — per-item accounting says "delivered" for data that was never sent.

Repro sketch: unbuffered Output with a slow consumer, cancel the context after the first send; items 2..N are reported as processed successfully.

Suggested fix: mark undelivered items with ctx.Err() before returning (same pattern as processor.Nil's MarkCancelled), so downstream error accounting reflects reality.

Found in the 2026-07-10 full-repo review (verified by repro).