// The tor declares the USER surface: any raw-name branch (the name IS the
// pattern, byte-for-byte) with a bindable payload, plus an optional void
// `no-match` fallback. The shape checker enforces this contract — binding
// rule included — with zero match-specific code; the transform's output
// needs no exemption.
//
// The `[transform]` annotation on the PROC is what makes this a transform:
// a transform IS a proc on an ordinary tor. Its machine interface
// (invocation/item/program/allocator → SiteResult) is the proc-return
// convention, not part of the tor. The tor keeps `[transform]` too —
// downstream passes read it as "implemented by a transform" (deferred
// bindings, comptime-flow skipping, variant emission).
~[comptime|transform] pub tor match {
    expr: Expression,
    reporter: std/compiler:*ErrorReporter
}
| * *
| ?no-match

// Koru Standard Library: the `scan` part of regex.kz.
// Joined via `~part scan` in regex.kz; merged into the regex
// module at load.
//
// SCAN - unanchored, streaming regex: `!` (each) where match uses `|` (once).
// `match` finds ONE whole-input match (anchored); `scan` finds EVERY
// non-overlapping occurrence as an effect stream — it fires its `!` pattern
// branch per hit (with the same named-group destructure match uses), then runs
// the optional `| done` continuation once. This is the terminal layer of the
// parser stack: a lexer in a few lines. Built on the engine's leftmost-longest
//
// unanchored search: the compiled SEARCH fn locates each span, and the same
// captures matcher `match` uses extracts the groups from that span. The `!`
// branch body is spliced once via `__koru_inline_<idx>` — INSIDE the loop it
// therefore runs per match, which is exactly effect-branch semantics. Single
// pattern for now (multi-pattern scan is pinned as a follow-up); pattern
// branches MUST be effect `!` (dispatch-into-each-match), mirroring the router.
~[comptime|transform] pub tor scan {
    input: string,
    reporter: std/compiler:*ErrorReporter
}
! * *
| ?done