Aggregate & partial failure.

export type FailurePattern = 'none' | 'one' | 'multiple';

export type InviteFailure = Readonly<{ reason: string; retryable: boolean }>;

export type InviteResult =
	Readonly<{ ok: true; item: string }> | Readonly<{ ok: false; error: InviteFailure }>;

export type ItemFailure = InviteFailure & Readonly<{ item: string }>;

export type BatchReport = Readonly<{
	succeeded: string[];
	failed: ItemFailure[];
}>;

type FailedAttempt = Readonly<{
	item: string;
	result: Extract<InviteResult, { ok: false }>;
}>;

const invites = ['Mina', 'Omar', 'Ivo', 'Rae', 'Tala'];

function attempt(item: string, pattern: FailurePattern): InviteResult {
	if (pattern === 'one' && item === 'Rae') {
		return { ok: false, error: { reason: 'provider timeout', retryable: true } };
	}
	if (pattern === 'multiple' && item === 'Omar') {
		return { ok: false, error: { reason: 'invalid address', retryable: false } };
	}
	if (pattern === 'multiple' && item === 'Tala') {
		return { ok: false, error: { reason: 'provider timeout', retryable: true } };
	}
	return { ok: true, item };
}

/** The operation has a result for each invite, but the failure shape is still local. */
export function sendInvite(item: string, pattern: FailurePattern): InviteResult {
	return attempt(item, pattern);
}

/** AggregateError keeps several reasons, but this return value no longer names their inputs. */
export function canonicalBatch(pattern: FailurePattern): string[] | AggregateError {
	const results = invites.map((item) => sendInvite(item, pattern));
	const failures = results.filter((result) => !result.ok).map((result) => result.error.reason);
	if (failures.length > 0) return new AggregateError(failures, 'Some invites failed');
	return results
		.filter((result): result is Extract<InviteResult, { ok: true }> => result.ok)
		.map((result) => result.item);
}

/** Carry the input beside every outcome so a caller can retry exactly the failed work. */
export function batchWithAssociation(pattern: FailurePattern): BatchReport {
	const results = invites.map((item) => ({ item, result: sendInvite(item, pattern) }));
	const failed = results.filter((entry): entry is FailedAttempt => !entry.result.ok);
	return {
		succeeded: results.filter(({ result }) => result.ok).map(({ item }) => item),
		failed: failed.map(({ item, result }) => ({ item, ...result.error }))
	};
}

export function retryableItems(report: BatchReport): string[] {
	return report.failed.filter((failure) => failure.retryable).map((failure) => failure.item);
}

export function observe(pattern: FailurePattern) {
	const canonical = canonicalBatch(pattern);
	const report = batchWithAssociation(pattern);
	return {
		canonical:
			canonical instanceof AggregateError
				? { kind: 'aggregate-error', reasons: canonical.errors }
				: { kind: 'success', items: canonical },
		report,
		retry: retryableItems(report)
	};
}

export function runExample() {
	return observe('multiple');
}

console.log(JSON.stringify(runExample(), null, 2));

package main

import (
	"errors"
	"fmt"
	"strings"
)

var ErrInvalidAddress = errors.New("invalid address")
var ErrProviderTimeout = errors.New("provider timeout")

// RunCanonical collects reasons but has no input key beside each error.
func RunCanonical(items []string) ([]string, error) {
	var failures []error
	var succeeded []string
	for _, item := range items {
		failure := failureFor(item)
		if failure != nil {
			failures = append(failures, failure)
			continue
		}
		succeeded = append(succeeded, item)
	}
	if len(failures) > 0 {
		return nil, errors.Join(failures...)
	}
	return succeeded, nil
}


func failureFor(item string) error {
	switch item {
	case "Omar":
		return ErrInvalidAddress
	case "Tala":
		return ErrProviderTimeout
	default:
		return nil
	}
}

type ItemFailure struct {
	Item      string
	Reason    string
	Retryable bool
}

type BatchReport struct {
	Succeeded []string
	Failed    []ItemFailure
}

// RunWithAssociation keeps the input beside its outcome.
func RunWithAssociation(items []string) BatchReport {
	var report BatchReport
	for _, item := range items {
		if err := failureFor(item); err != nil {
			report.Failed = append(report.Failed, ItemFailure{
				Item:      item,
				Reason:    err.Error(),
				Retryable: errors.Is(err, ErrProviderTimeout),
			})
			continue
		}
		report.Succeeded = append(report.Succeeded, item)
	}
	return report
}

func RetryableItems(report BatchReport) []string {
	var items []string
	for _, failure := range report.Failed {
		if failure.Retryable {
			items = append(items, failure.Item)
		}
	}
	return items
}

func main() {
	invites := []string{"Mina", "Omar", "Ivo", "Rae", "Tala"}

	_, err := RunCanonical(invites)
	fmt.Printf("canonical reasons: %q\n", strings.Split(err.Error(), "\n"))

	report := RunWithAssociation(invites)
	fmt.Printf("succeeded: %v\n", report.Succeeded)
	for _, failure := range report.Failed {
		fmt.Printf("failed: %s (%s, retryable %t)\n", failure.Item, failure.Reason, failure.Retryable)
	}
	fmt.Printf("retry: %v\n", RetryableItems(report))
}