multi event chain

// Test 829: Multi-event chain (realistic composition)
//
// Real programs chain multiple events together with deep nesting.
// This tests that the compiler can handle:
// - 5+ events in a chain
// - 3+ levels of nested continuations
// - Data flowing through multiple stages
// - Error handling at multiple levels

const std = @import("std");

// Stage 1: Parse input
~tor parse { input: string }
| parsed i32
| invalid string

~proc parse|zig {
    const value = std.fmt.parseInt(i32, input, 10) catch {
        return .{ .@"invalid" = "Not a number" };
    };
    return .{ .@"parsed" = value };
}

// Stage 2: Validate
~tor validate { value: i32 }
| valid i32
| invalid string

~proc validate|zig {
    if (value < 0 or value > 100) {
        return .{ .@"invalid" = "Out of range" };
    }
    return .{ .@"valid" = value };
}

// Stage 3: Transform
~tor transform { value: i32 } -> i32

~proc transform|zig {
    return value * 2;
}

// Stage 4: Format
~tor format { value: i32 } -> string

~proc format|zig {
    const allocator = std.heap.page_allocator;
    const text = std.fmt.allocPrint(allocator, "Result: {}", .{value}) catch {
        return "Error formatting";
    };
    return text;
}

// Stage 5: Display
~tor display { text: string }

~proc display|zig {
    std.debug.print("{s}\n", .{text});
}

// The chain: parse -> validate -> transform -> format -> display
// With error handling at each stage
~parse(input: "42")
| parsed p |> validate(value: p)
    | valid v |> transform(value: v): t |> format(value: t): f |> display(text: f)
    | invalid i |> display(text: i)
| invalid i |> display(text: i)