The outcome pipeline
Every result a matchUp receives travels one path: setMatchUpStatus validates and orchestrates,
setMatchUpState decides, attemptToSetMatchUpStatus routes, and modifyMatchUpScore is the one
place matchUp.score and matchUp.matchUpStatus are written. What that write causes, direction of
the winner and loser and propagation of an exit, is the rest of the pipeline. This page states the
rules a second implementation has to reproduce: the inputs, every refusal by its error code, the
routes, what a write does, the side effects in order, and the guarantees. Where the engine's
behaviour is a question rather than a decision it is marked OPEN.
First version, 2026-10-01, written from the source and from the golden corpus's measurements. The
pipeline is 6,548 lines across twelve files; 281 test files touch it; the corpus records 50,559
setMatchUpStatus steps and has observed eighteen distinct refusal codes from it.
setMatchUpStatus validate params, resolve the draw, read policy, derive score strings
└─ setMatchUpState guards, participants, downstream dependencies, dispatch
├─ noDownstreamDependencies ──┐
├─ winningSideWithDownstream ─┤─▶ attemptToSetMatchUpStatus / attemptToModifyScore
└─ applyMatchUpValues ────────┘ └─▶ modifyMatchUpScore (the only score write)
└─▶ direction, exit propagation, tally
└─ progressExitStatus (≤10 levels) · reconcileStaleExitOrigins · settleDraw
1. The inputs
An outcome carries at most score, matchUpStatus, winningSide and matchUpStatusCodes, and
optionally a matchUpFormat. The call also takes matchUpId, a draw (drawId or drawDefinition),
a schedule to apply once accepted, notes, and the flags below.
Score strings are derived, never accepted. When score.sets is present, empty sets are dropped
and scoreStringSide1 / scoreStringSide2 are regenerated from the sets under the matchUp's
effective format. A caller's strings are discarded. score.sets is the single source of truth.
Three flags, one precedence rule: the policy governs, both ways (CA, 2026-10-01).
| flag | precedence | absent both |
|---|---|---|
allowChangePropagation | policy ?? param ?? undefined | not allowed |
propagateExitStatus | policy ?? param ?? undefined | no |
propagateRetirementAsExit | policy ?? param ?? false | no |
An applied scoring policy that speaks on a flag, true or false, wins over anything on the
call; the call decides only where the policy is silent. So under a policy that propagates
retirement as an exit, a tournament director passing false is overruled, and under a policy that
forbids it, a director passing true is overruled too: "if a governance policy is someone who
retires can no longer continue playing, a tournament director under that policy shouldn't be able to
allow a participant to continue in the draw." POLICY_SCORING_DEFAULT is silent on all three, so a
provider that attaches it leaves the decision to the call. Until 2026-10-01 the call won on
propagateRetirementAsExit and a truthy call won on the other two (||), so a caller could
override its federation's rule; the three authored scenarios authored/outcome-pipeline/flags-*
pin the new contract from both directions.
A matchUpFormat on the call is validated before anything runs and persisted only once the outcome
is accepted. It used to be written first, so a refused outcome left a new format behind.
2. The refusals, in the order they are checked
A refused call returns one ErrorType with a code and changes nothing (§ 6); its context, when
present, is an object, and a sentence for a person goes in info (two row-9 refusals returned the
sentence AS context until the authored scenarios refused to record them, 2026-10-01). The checks run in
this order; the first that fails is the answer. Two corrections from S2a (2026-10-01), measured by
running v2 differentially against v1: the TEAM clause of row 5 (AWAITING_RESULT) is asked after
row 10, and the participants clause of row 6 (§ 2.1) after row 11; and row 9's second condition
judges the stored score under the stored format while its third judges the incoming score under
the format the call would apply, so a call that carries a new matchUpFormat can be refused under
the old one. The checks v1's writers make before their first write, after the dispatch (rows 13 to 15),
are asked there (S7, refuseRoute): row 24's removal clause, row 28 and row 6's fallthrough clause.
A context holds the attributes that are defined, as v1's decorateResult leaves it: a call that names no
matchUpStatus is refused by row 6's participants clause with requiredParticipants alone. Row 14's TEAM clause (a
decided dual with an active downstream whose auto-calc the call turns on, its lines projecting another winner) names
the stored dual beside the call's winningSide, as v1's handleTeamAutoCalc does.
Row 6's fallthrough clause is asked of the call as it is dispatched: a TEAM dual's call that turns auto-calc on takes
the winner and score its lines project, whatever it names, so an exit entered with a winner the lines do not project is
an exit with no winner, refused. v1 asks it before the dual's own writes (its sides and line-ups, setMatchUpState's
refusedAtTheStatusRoute), so the refusal leaves the record as it was.
| # | code | condition | where |
|---|---|---|---|
| 1 | ERR_MISSING_MATCHUP_ID | no matchUpId | setMatchUpStatus |
| 2 | ERR_MISSING_DRAWDEF | no draw could be resolved from drawId / drawDefinition | setMatchUpStatus |
| 30 | ERR_UNDECIDED_LEVEL_RESULT | COMPLETED with no winningSide, in a structure that advances a winner, on a level score of a format that can end level: a level result there names its winner and records how it was decided (score.overtime.decidedIn: 'EXTERNAL', standings phase 2 § 1.1, CA 2026-11-04). The same check refuses any other winnerless COMPLETED there with ERR_INVALID_SCORE (completed elimination results require a winningSide). Asked between rows 2 and 3, before anything else is read | resolveRotatingPartnerOutcome |
| 3 | ERR_INVALID_WINNING_SIDE | winningSide present and not 1 or 2; 0 is refused (CA, 2026-10-01: there is never a winningSide: 0); a set's own winningSide likewise | setMatchUpStatus |
| 23 | ERR_INVALID_VALUES | notes present and not a string. Checked here, between rows 3 and 4: notes are written last, onto the matchUp, after the score, so addNotes refusing them there was an error over a written result (2026-10-22). Numbered 23 so the existing rows keep their numbers | setMatchUpStatus; every other, where the notes are data, is read off v1's whole write (recordedWhole) |
| 4 | ERR_UNRECOGNIZED_MATCHUP_FORMAT | the call's matchUpFormat is not well-formed (does not parse), or is well-formed but refused for new use (a tiebreak below setTo − 1, an aggregate of standard sets; scoring engine spec § 16 decision 19, CA 2026-10-18) AND differs from the format the matchUp plays under (matchUp, structure, draw, event): a score sent back with the stored format is not a new use | checkMatchUpFormatApplication |
| 5 | ERR_INVALID_VALUES | matchUpStatus is one of CANCELLED, INCOMPLETE, ABANDONED, TO_BE_PLAYED with a winningSide; or a TEAM dual with AWAITING_RESULT | validateMatchUpStateInputs, setMatchUpState |
| 6 | ERR_INVALID_MATCHUP_STATUS | matchUpStatus is not a known status; or a directing outcome on a matchUp without two participants (§ 2.1); or no route accepts it (§ 3's fallthrough: an exit named with no winner; asked after row 15, where attemptToSetMatchUpStatus asks it) | validateMatchUpStateInputs, checkParticipants, attemptToSetMatchUpStatus |
| 7 | ERR_MATCHUP_STATUS_OUT_OF_SCOPE | the status exists but means nothing here: CHALLENGED outside a LADDER; DEAD_RUBBER on a matchUp that is neither a rubber of a team tie nor in a DOUBLE_ELIMINATION Decider (found by its links). The matchUp half needs the matchUp, so it applies once found and refuses nothing before | getMatchUpStatusScopeViolation |
| 8 | ERR_NOT_FOUND_MATCHUP | matchUpId is not in the draw | resolveMatchUpAndContext |
| 9 | ERR_INCOMPATIBLE_MATCHUP_STATUS | BYE with a winningSide (existing or requested); a live status (IN_PROGRESS, SUSPENDED) on a COMPLETED matchUp whose score is a valid win and the call carries no new result; a live status with a winningSide or a score that decides a winner under the incoming format; a non-directing or double-exit status without winningSide while downstream is active; a winningSide equal to the current one with a non-directing status | resolveMatchUpAndContext, checkCompletedRevertGuard, checkImpliedCompletionGuard, checkDownstreamCompatibility The result carries activeDownstream and winningSide beside error, as v1's checkDownstreamCompatibility returns them (no context). |
| 20 | ERR_UNCHANGED_CANNOT_CHANGE_OUTCOME | a direct write that would change a matchUp holding a carried or produced exit: a re-score, another winner, a relabel to a played result, or a clear (CA, 2026-10-03). The correction is made at the exit's origin. Checked here, between rows 9 and 10; numbered 20 so the existing rows keep their numbers | rewritesCarriedExit |
| 21 | ERR_INVALID_VALUES | a WINNER or LOSER link with no source.roundNumber, a malformed draw (CA, 2026-10-06: an error, not a crash). Checked between rows 20 and 10, for the matchUp's own targets, any structure downstream of it, and (2026-10-22) any such link in the draw: a settle pass asks matchUps the call never reached, and met one only after the cascade had written. With none, no positionTargets error can arise later in the call (§ 6) | positionTargets, getActiveDownstream |
| 10 | ERR_PROPAGATED_EXITS_DOWNSTREAM | a clear (TO_BE_PLAYED, empty strings, no winner) that would leave a propagated exit standing downstream | hasPropagatedExitDownstream |
| 11 | ERR_INVALID_SCORE | the score is not valid under the format (sets, tiebreaks, a 7-5 after 6-5 is valid, a 7-6 needs a tiebreak); skipped for TEAM duals and with disableScoreValidation | validateScore |
| 22 | ERR_UNCHANGED_CANNOT_CHANGE_OUTCOME | a correction that changes the KIND of a decided outcome — an exit carried downstream (WALKOVER, DEFAULTED, RETIRED under propagateRetirementAsExit) to a played result or the reverse, by a winner change or by a status-only correction — once the loser's path holds a result a director recorded, played or not (P52, CA 2026-10-11). Checked just before row 12; numbered 22 so the existing rows keep their numbers | correctionKindChange |
| 12 | ERR_CANNOT_CHANGE_FEED_ELIGIBILITY | the loser of the linked round has already been directed under the previous outcome, or the FIRST_MATCHUP reservation the previous outcome placed has been played on | feedEligibilityChange |
| 16 | ERR_INVALID_TIME | the schedule carries a time that does not parse (validated before the write, applied after; asked after row 12 and before the dispatch, rows 26 and 13 to 15, where v1 asks it) | addMatchUpScheduleItems with validateOnly |
| 25 | ERR_INVALID_DATE | the schedule carries a date, or a date-time's date, outside the tournament or off the calendar (#5774; validated before the write, so the outcome does not land) | addMatchUpScheduleItems with validateOnly |
| 27 | ANACHRONISM | the schedule carries a recorded time out of played order with a linked matchUp (an end time given with the outcome is judged before the outcome lands, #5979; validated before the write, so the outcome does not land) | addMatchUpScheduleItems with validateOnly |
| 29 | the schedule writer's own code | the schedule refused by v1's writer with any other code (ERR_INVALID_STOP_TIME, ERR_INVALID_RESUME_TIME, ERR_INVALID_END_TIME, ERR_NOT_FOUND_VENUE, ERR_INVALID_VALUES for a court order, ...), returned whole as v1's validateOnly pass returns it (S7: these were compared as v2 accepting, a divergence) | scheduleRefusal (scheduleItems.ts): the refusals, then the write on a copy of the draw |
| 24 | ERR_MISSING_DRAW_POSITIONS | a winner (or, under propagateExitStatus, an exit) for a matchUp stored without drawPositions that has sent nothing, is not a line of a dual and is not ad hoc: there is nobody to direct. A second clause after row 15: a score with no winner, or a winner's removal (remove-directed), on a matchUp holding no drawPositions and not ad hoc, a line's dual included, the dual's auto-calc on (removeDirectedParticipants, before its first write; v1 asks it before the dual's writes, removesDirected; S7) (2026-10-22: was raised by directParticipants after the score was written). Checked after row 16 | missingDrawPositionsRefusal |
| 26 | ERR_ACTIVE_DRAW_POSITION | a swap (allowChangePropagation) over a FIRST_MATCHUP link that would place a loser on, or take one off, a fed seat that has played on (v1's fedLoserPlacementRefusal and relabelledPathFeedRefusal, asked before the swap writes). Decided by v2 since S4, on its structural index | fedLoserPlacementRefusal, relabelledPathFeedRefusal |
| 13 | ERR_UNCHANGED_CANNOT_CHANGE_OUTCOME | a line of a dual that holds a double exit, with the dual's downstream active; or changing a double exit that has propagated | resolveAndApplyOutcome, winningSideWithDownstreamDependencies The context names the stored matchUp beside winningSide, as v1's winningSideWithDownstreamDependencies does. |
| 14 | ERR_UNCHANGED_CANNOT_CHANGE_WINNING_SIDE | changing the winner of a matchUp whose winner has been played on, without allowChangePropagation | winningSideWithDownstreamDependencies The context names the stored matchUp beside winningSide, as v1's winningSideWithDownstreamDependencies does. |
| 15 | ERR_NO_VALID_ACTIONS | downstream is active, the matchUp has propagated, the call names no winner and no directing status, and auto-calc is on | resolveAndApplyOutcome |
| 28 | ERR_UNCHANGED_CANNOT_ASSIGN_BYE | matchUpStatus: BYE on a matchUp none of whose drawPositions holds a bye assignment (the constant INVALID_MATCHUP_STATUS_BYE; v1's attemptToSetMatchUpStatusBYE, § 3's BYE route, asked after row 15; S7) | attemptToSetMatchUpStatusBYE |
| 17 | ERR_ACTIVE_DRAW_POSITION | a direction would move a participant off a position already played on (a swap's, decided earlier: row 26) | reconcileFedLoserEligibility, BYE and qualifier assignment |
| 18 | ERR_MUTATION_LOCKED | the tournament holds a mutation lock whose scope covers the method: asked by the engine before the method runs (executeMethod), so neither pipeline is reached; nothing inside setMatchUpStatus asks a lock | engine, before the pipeline |
| 19 | ERR_FORCED | not an engine code: the failure the error-path tests force on a cascade write (cascadeWriteErrorsReachTheCaller, reconcileDeciderReturnsItsError, aWinnerAcrossALinkIsSeatedOnce), which the corpus records from their steps (traced 2026-10-31). It stands for a write failing inside the cascade, which v2 does not plan: apply-stage |
Of the eighteen codes the corpus has observed from setMatchUpStatus, none is declared by
setMatchUpStatus.ts itself: every refusal is raised by a helper. A reader of the entry file alone
sees no refusal at all. That is why the catalogue above is by condition, not by file.
2.1 Who may receive a directing outcome
A directing outcome (a winner, or COMPLETED, RETIRED, WALKOVER, DEFAULTED, a double exit) requires two participants, with one family of exceptions and one rule inside it:
- The waiver. WALKOVER, DEFAULTED, DOUBLE_WALKOVER or DOUBLE_DEFAULT on a matchUp holding ONE
participant is accepted when it is the cascade's own write (
propagatingExit), or when the call names no winner, or when the winner it names is awardable. A DOUBLE exit is waived only as the cascade's own write: entered directly it needs both seats reached, because a double exit is one exit per seat (CA, 2026-10-04). Entered beside a seat nobody has reached, the arrival there would meet a double exit already standing, a third entity in a matchUp that holds two. - Awardable means the winning side is not the participant already present (a walkover over an opponent nobody knows yet would be two winners of one matchUp), is not a BYE, and is not a phantom: a drawPosition whose assignment exists and holds nobody. An unfilled feed slot, no drawPosition at all, is awardable; so is a QUALIFIER placeholder.
- A BYE is never the winning side. The participant advances through the BYE and their carried exit occurs where they land. This was decided in two places before it was written here.
- A policy may switch the requirement off:
requireParticipantsForScoring: false. - No request flag is involved. The waiver is how a director records a walkover or default before
the second opponent arrives (CA, 2026-10-04): "propagateExitStatus shouldn't have anything to do with
this ability".
propagateExitStatusdecides only whether the exit is then carried into the loser's next matchUp.matchUpActionsoffers it asEXIT.
3. The routes
attemptToSetMatchUpStatus chooses exactly one route, in this order:
| route | when | does | v2 |
|---|---|---|---|
| unrecognized | status is neither directing nor non-directing | refuse ERR_UNRECOGNIZED_MATCHUP_STATUS | not reached past row 6: every valid status is one or the other |
| already in the requested double exit | same double exit requested, no winner | success, no-op (§ 6) | noop |
| only modify score | a TEAM line; or a winner exists and the status is directing and not a double exit | write the score | only-score |
| completed → double exit | a winner exists and a double exit is requested | remove the directed participants, then advance the double exit | completed-to-double-exit |
| existing winner | a winner exists | remove the directed participants, re-evaluate | existing-winner-removed |
| non-directing | status is non-directing | clear the score (CANCELLED and WALKOVER remove it) | clear |
| BYE | status is BYE | the BYE path | bye; without a bye seat refused → row 28 |
| not directing | refuse ERR_UNRECOGNIZED_MATCHUP_STATUS | not reached past row 6 (as unrecognized) | |
| double exit | clear the score, then advance the double exit | double-exit | |
| team round robin | a dual in a round-robin container | write the score | team-round-robin |
| propagating | propagateExitStatus | write the score | propagating |
| fallthrough | refuse ERR_INVALID_MATCHUP_STATUS | refused → row 6 |
Before any route, resolveAndApplyOutcome dispatches on two facts: whether downstream is active
(something later depends on this result) and whether this matchUp has propagated (it holds a
winner or a double exit). A matchUp that has never sent anything downstream cannot invalidate
anything there, so a first entry always takes the propagating branch. With both true, a named winner
goes to winningSideWithDownstreamDependencies; a directing status or disabled auto-calc goes to
applyMatchUpValues; anything else is ERR_NO_VALID_ACTIONS.
A clear of a BYE changes nothing, and is asked before the dispatch: a request with no winner, no
score with value and no status but TO_BE_PLAYED, made of a matchUp stored as a BYE, succeeds as
noop and still applies its schedule. A BYE has no result to clear, and a TO_BE_PLAYED matchUp with
a BYE side never occurs (CA, 2026-10-24; punch-list P26). Until then the clear was accepted and wrote
TO_BE_PLAYED against nobody: four seeds of census window sched-w1, on both arms. v1 and v2 ask the one
predicate (clearsABye); the harness invariant TO_BE_PLAYED_BESIDE_BYE checks the shape at every
census step (aClearedByeStaysABye.test.ts). The lines of a BYE dual are not that shape: the dual is the
BYE, and its lines stay TO_BE_PLAYED, as they are generated (CA, 2026-10-24).
The route v2 names (Route, src/mutate/matchUps/outcome/types.ts) is the table's last column for
a call that reaches attemptToSetMatchUpStatus; refused is any of its three refusals. The dispatch
names six more:
swap:allowChangePropagationwith a different winner on a matchUp that has one (below).winner: the propagating branch with a winner named, an exit underpropagateExitStatus, or a CANCELLED or ABANDONED line that changes its dual's winner:attemptToSetWinningSide.line-score: a line rescored with a winner while its dual loses the winner it had.remove-directed: a score with no winner, or a winner taken away with no score: the directed participants are taken back.clear-score: nothing else matched; the score is removed.apply-values: downstream is active and this matchUp has propagated, with a winner, a directing status or auto-calc disabled (applyMatchUpValues); also a drawn result in a rotating-partner or combined-point round robin with nothing active downstream.
A matchUp in play downstream is active (CA, 2026-10-18, P57): "downstream matchUps e.g. "the
match it feeds" should be considered active and a source matchUp (a matchUp earler in the dependency
chain) should not be able to be re-scored as unfinished! a downstream matchUp AWAITING_RESULT should
be considered an active matchUp also". isActiveDownstream counts a winner or loser target as active
when it has a decided result, as before, or when it is in play: its status is IN_PROGRESS,
SUSPENDED, AWAITING_RESULT or INCOMPLETE, or its score has a value. A BYE or an exit is not judged by
play; its activity remains a question of provenance. So with the final in play, re-scoring a
completed semifinal as unfinished is refused the way it is when the final is COMPLETED: IN_PROGRESS,
AWAITING_RESULT or a clear is row 9 (ERR_INCOMPATIBLE_MATCHUP_STATUS), a score with no status and
no winner is row 15 (ERR_NO_VALID_ACTIONS), and another winner is row 14. A correction that keeps
the winner is still accepted, and allowChangePropagation still swaps. Both implementations read
the one query (getTargetsDownstream), so v1 and v2 change together. Before 2026-10-18 the re-score
was accepted through noDownstreamDependencies, which took the advanced participant back out of the
final and left it TO_BE_PLAYED with no score (inPlayDownstreamIsActive.test.ts).
allowChangePropagation with a different winner on a matchUp that has one swaps winner and
loser everywhere they have gone (swapWinnerLoser), rather than refusing.
4. What a write does
modifyMatchUpScore → applyScoreAndStatus is the only place score and matchUpStatus change.
- A walkover, or a removal, blanks the result with the
toBePlayedfixture:matchUpStatus: TO_BE_PLAYED,scorewith emptyscoreStringSide1/scoreStringSide2andsets: undefined,winningSide: undefined,matchUpStatusCodes: [], andmatchUpFormat: undefined, though since 7.5.0 a matchUp-levelmatchUpFormatis carried across the blank (below). The requested status is then written over the blank. Exit provenance survives the blank when the written status is an exit, and BYE claims survive it on a BYE; everything else insideExitProvenancegoes. - Otherwise the given
scorereplaces the old one, thenmatchUpStatus,matchUpFormat(only if given) andmatchUpStatusCodesare written. - Status codes are split at this boundary: the positional array a client sends (
['', 'DM']) becomessideStatusCodeskeyed by side, with the exiting side taken fromwinningSide, not from the index. Only a client's array is split (census A1 residue F1b, 2026-10-18). An engine write whose array is not client input (a propagation inprogressExitStatus; the convergence reconcile and the forward writes indoubleExitAdvancement, which re-store the target's own, possibly derived, array; the unwinds inremoveDoubleExit) passesderivedStatusCodes, naming the matchUp it describes. Its array is stored as given. It keeps the reasons the matchUp already holds, plus the real reason it carries for the arriving side, on the sides that exited: both sides of a double exit, the losing side of a single exit. A bareWOorDEFthat the projection wrote is never a reason. The choice is made by origin, not by value: a client's['WO']is still split as its reason. An array naming no reason deletes the reasons the matchUp kept: a write handed[](the call's own, or the one the winner route always passes) splits to nothing, sosideStatusCodesandmatchUpStatusCodeboth go; a write handed no array (a clear, a live score or a double exit entered with no codes) leaves them standing, beside whatever the display array becomes. v2 plans only the requested matchUp's own write, from client input, and comparesmatchUpStatusCodesas display; a call carrying codes is v1's (status-codes), so the onesideStatusCodeswrite it plans is that deletion (clearsStatusReasons,clearedStatusReasons.test.ts), and it plans no propagation write. scoredTimeis stamped onschedulethe first time the matchUp becomes scored (a score with value, a winner, or a completed status), kept through corrections, and deleted when the result is removed. One exception: a DOUBLE_ELIMINATION decider made a DEAD_RUBBER was not played, so it is never stamped and keeps no stamp from a result it held before. A rubber of a team tie is not the exception; its DEAD_RUBBER is stamped like an ABANDONED line (CA, 2026-10-24). It is first-class in NATIVE and has no timeItem mirror.- The schedule the call carried is applied after the outcome is accepted, and was validated
before it, so a refusal cannot land on a draw this call has just changed. v2 plans it (S7) where it lands
on the matchUp alone, a date, a time, a court, a venue or a court order: v1's own writer is run on a copy of the
matchUp, and the schedule it leaves is written (
setMatchUpSchedule) before the result, soscoredTimeis stamped onto it as v1 stamps it. A schedule v1 refuses, or one carrying another attribute (start, stop, resume and end times, officials), stays v1's.
Decided 2026-10-01 (CA), found by the corpus on real records: rule 1 means a clear
normalises rather than restores. On a record whose matchUp had no matchUpStatus and no
score, a score-then-clear leaves matchUpStatus: "TO_BE_PLAYED" and an explicit score object;
measured on 4 of 11 probed fixtures. That stays: TO_BE_PLAYED and an empty score object are the
canonical cleared state, and a reader never sees an undefined status. A clear keeps a
matchUp-level matchUpFormat: the format is a property of the match, not of its result. The
blank fixture still carries matchUpFormat: undefined, because it is the unwound-matchUp shape, and
applyScoreAndStatus now carries the existing format across it the way it carries exit provenance;
a call that brings a new format still writes the new one. Pinned by
clearKeepsMatchUpFormat.test.ts.
A double exit entered over a completed result (CA, 2026-10-02). A DOUBLE_DEFAULT keeps the score
the matchUp had, finished or not, unless the call brings one: both players can be defaulted after
the last ball (post-match misconduct at the net, for example), and the score is the record of what
was played. The reason belongs in a penalty, addPenalty with each player's participantId and the
matchUpId. A DOUBLE_WALKOVER says the match was not played, so it blanks the score; one entered
over a completed result is taken at its word, and correcting a mistaken one is the director's re-entry.
Neither has a winner. Pinned by authored/outcome-pipeline/double-exit-over-a-completed-result.
5. The side effects, in order
After the write, and only on success:
-
Direction. A winner is advanced to the winner target; the loser is directed along the loser link, if the structure has one. A changed result first removes what the previous one directed (
removeDirectedParticipants), and that is whereERR_ACTIVE_DRAW_POSITIONcan arise. A loser taken back leaves every seat their loss reached, a link further on included, and no exit stays awarded to a seat so emptied (census A1,aSeatEmptiedFurtherOnLeavesNoAwardBehind). A first-match loser feed (the link's conditionFIRST_MATCHUP) takes the loser only if the match they lost was their first played: no win of their own in the source structure. For a swap (allowChangePropagationwith a different winner) the wins counted are those in the rounds before the swapped one. A swap rewrites the advancing drawPosition in every later matchUp, so the new loser loses their later wins with it; counted, those wins would keep out a loser whose first match this was (census w1 9000582 and nine more FMLC seeds,aSwapCountsOnlyTheRoundsBeforeIt; v1'sreconcileFedLoserEligibility). A winner directed across a link is seated once (2026-10-22). A winner who already holds a seat in the target matchUp is left there and nothing is written: a direction can arrive twice in one call (a DOUBLE_ELIMINATION Decider seated from the Main final, then the same winner re-advanced by a correction below), and the second used to reach for the other seat and be refused. A placement across a link that fails otherwise, and a winner with no position to take, are not returned: the direction runs after the result is written, and a refusal there would leave that write behind. For a Decider,reconcileDecidersseats it from the final that stands (step 5). Over the suite and the frozen census windows the only placement failures reached were the already-seated case (census de 9304558 withdoubleExitPropagateBye: false, census F2 20477784). Pinned byaWinnerAcrossALinkIsSeatedOnce.test.ts. -
Exit propagation. WALKOVER, DEFAULTED and (by policy) RETIRED carry into the consolation the loser is fed to; a double exit produces exits downstream. The rules are on exit propagation and are not repeated here.
progressExitStatusiterates through up to ten levels of consolation (COMPASS feeds consolation into consolation); a failsafe, not a limit anyone has reached. A relabel keeps the winner the matchUp already has and changes what it says about the loser (CA, 2026-10-02). Re-entered as a WALKOVER or DEFAULTED, it carries the exit to the matchUp the loser already stands in; re-entered as COMPLETED, it withdraws the exit it carried there. Where that matchUp already has a result a director recorded, or the winner of the carried exit has played on from it (counting past any BYEs they were advanced through), the correction is refused before anything is written (row 22, P52): a recorded result downstream fixes whether the origin's outcome is an exit or a played result. The same holds one structure on: where the loser's loss carried their exit into a matchUp it decided for whoever stood opposite, a result that winner has recorded onward counts too (census 20496362). A correction that names the same winner with no status and no score is a played result (COMPLETED), as the write records it, so re-entering a walkover as a bare win changes its kind. An exit carried into a matchUp that another exit already decided for the seat awaiting the loser, with a result recorded below it, is carried past that matchUp as past a BYE: the loser takes the seat, goes on to its winner matchUp, and carries the exit on from there (P51 group 2, CA 2026-10-11). A winner change (a flip) relabels the old loser's place onto the new loser, and their carried exit is re-derived from the corrected result in the same way, so a corrected draw is the one forward play reaches. Both apply whether or not the relabelled matchUp's own winner has played on since. Where the carried exit had converged with another, only this origin's entry is withdrawn and the matchUp re-derives to the kept exit (its carrier directed on, or — a produced exit — won by the relabelled loser, who goes on; a produced exit relayed past a BYE, with nobody in the seat it would be awarded to, stays pending, and the withdrawn side's reason code goes with its exit). Where the kept exit is awarded to the other side than the award that stood, the old winner's advancement is released with it (census S4, DOUBLE_ELIMINATION 20617910); a pending exit stays pending. A double exit re-derived to a single one keeps only its winner's position in the next round: its carrier, now the loser, is released from it (census S4, COMPASS 20586104,doubleExitPropagateBye: false); from a structure's last round that release crosses the link, as a winner's does (DOUBLE_ELIMINATION 20622028). A BYE matchUp left holding only the BYE-status entry a convergence recorded beside it is a plain BYE again. A loser who had won a produced exit on arrival has that award taken back when the origin becomes an exit again, so the exit converges as it would have at first entry (7.7.0; exit propagation). -
Round robin tally is recomputed when the matchUp is in a group (
updateTallyIfNeeded). -
Stale exit origins are reconciled once removals, directions and propagation have all settled: a carried exit whose origin no longer describes an exit is corrected. The reconciliation is asked of the draw as it stands at that point, read afresh, never of a view of the draw taken earlier in the call: such a view describes the draw as the direction left it, before propagation wrote. Steps 4 and 5 run only when the call was accepted (§ 6). Until 2026-10-11 the reconciliation read a deep copy carried in the call's context: what it wrote was lost, and the next call repaired the origin, a refused call included (census family F2).
-
The draw is settled: held exits are released (
settleHeldExits), including to a participant who already passed the BYE holding them and carries no exit of their own (only an exit whose origin is still a double exit travels this way), and a convergence that has not produced its exit produces it. Into a winner target that is the BYE it holds, with nobody in it and no matchUp beyond, it produces only where that moves something, asked on a copy of the draw: a BYE does not always record the exit produced into it, so such a convergence read as owed on every later call, and the BYE was written over itself, announced and stamped each time (aSettledByeTargetIsNotProducedAgain); the drawPosition opposite a lone BYE, a participant or an empty seat the structure placed there, goes on where its next matchUp has room (reconcileByeAdvancements; census A1,theSeatLeftOppositeAByeGoesOn); and a final that feeds a decider settles whether the decider is needed (reconcileDeciders) when a final's winner changed, or when the cascade moved a decider while the final's winner stayed put (7.8.0). A mutation OF the decider never triggers it, so a decider played anyway keeps its result; in a TEAM draw a line of the decider's dual is a mutation of the decider (7.8.0). See Double Elimination. Last, no matchUp left without a result keeps itsscoredTime(reconcileScoredTimes). It is asked after every settle step, because they can take a result away:settleHeldExitsturns an exit holder into a BYE, and the forward settle and the link passes release what was placed. Until 2026-10-24 it was asked before them, so the stamp outlived the result until the next call, whatever that call was: 19 calls over the exitPropagation, drawDefinitions and matchUps suites ended that way (13 BYEs, 6 TO_BE_PLAYED), and none does now (aResultTheSettleRemovesTakesItsScoredTime.test.ts). A result is what § 4 counts as one, so a decider played and then made a DEAD_RUBBER loses its stamp, and a team rubber made a DEAD_RUBBER keeps it. -
Notifications (MODIFY_MATCHUP and the draw's topics) are emitted; the factory extension's
timeStampis written by the engine after the call.An entity's
updatedAtis stamped once per call (F2 (i), CA 2026-10-19): the call's captured instant, or the previous stamp + 1 ms when that is already as late, however many notices the call raises for it. AnexecutionQueueis one call. Until 2026-10-24 v1 stamped at each notice, so one first-round score moved the draw's stamp on by 2 ms (oneStampPerEntityPerCall.test.ts). A state provider without the optionalgetCapturedStamps/setCapturedStampshooks keeps no ledger and stamps at each notice, as before.The touched entities are the matchUps the call writes, the draw, the top-level structure holding each matchUp written (a round robin's container, the dual's structure for a line), and any structure whose position assignments change (a loser fed across a link). A matchUp notice stamped every top-level structure until 2026-10-24, so a CURTIS main score stamped its Play Off. A matchUp that no top-level structure holds still stamps every structure.
5.1 Settlement dependencies (S6)
v2 owns a call only when no settle pass has work on the draw its ops leave (settleWork.ts, F5 (a)). Each row is a
pass at its observePass site, in v1's order, with what v2 asks. Exact is the pass's own detector run on the working
view; scope is true whenever the pass could have work. The last two columns are filled as S6 makes a pass plannable:
what must hold for the pass to write nothing, and what a write of it would invalidate for the passes after it.
| pass | v2 asks | writes nothing when (S6) | a write invalidates |
|---|---|---|---|
settleExitOrigins | scope: a result on a matchUp that was a double exit, but the call's own; and stale origins | no matchUp but the call's was a double exit the ops change (settleRederivedDoubleExits skips the call's), none stale | every pass below: it re-derives and replays carries |
reconcileConsolationReservations | exact: findReservationWork | ||
reconcileStaleExitOrigins | exact: hasStaleExitOrigins | a cleared double exit's produced exit is withdrawn with its origin, so nothing names it | |
reconcileCarriesPastByes | exact: findOwedCarry | ||
settleHeldExits | exact: hasHeldExitWork | ||
reconcileByeAdvancements | exact: findOwedByeAdvance | ||
reconcileMissedLinkAdvancements | exact: findMissedLinkAdvancements | ||
reconcileProvenanceSides | exact: findMisplacedProvenance | ||
reconcileDeciders | exact for the trigger: a final's winner changes, or a decider moves | ||
settleForwardConsequences | exact: hasForwardWork | ||
reconcileLinkAdvancements | exact: getUnearnedLinkAdvancements | ||
reconcileScoredTimes | exact: a scoredTime on a matchUp holding no result |
A double exit or an exit carried across a loser link that the plan does not hold as ops puts every pass in reach.
6. Guarantees
-
A refusal changes nothing (
ERROR_IMPLIES_NO_MUTATION). The checks in § 2 run above every write; the two that used to run late (participants on a bare winner, feed eligibility) were moved up after each was measured leaving a destroyed previous result behind a refusal. Nothing of § 5 after propagation runs on a refused call: no reconciliation, no settling, noscoredTimeclean-up. A refusal must not repair, as a side effect, what an earlier call left; that repair is the next accepted call's to make (2026-10-11: the settle step ran after a refusal and was the refused call's only write in 55 of 92 census refusals after a write). -
A settle step has no failure to report (outcome v2 executor plan, Phase C prerequisite 2; CA, 2026-10-22: "The pipeline needs to work without rollback"). Steps 4 and 5 run after the cascade has written, so an error found there could not be refused without leaving those writes behind, and no caller rollback is relied on. A settle step's inner calls must therefore be unable to fail, and where one could, the failure is checked before the call's first write. Today:
reconcileLinkAdvancementscannot fail by construction.releaseLinkedWinnerAdvancementreturns nothing orreleaseAdvancedDrawPosition's success and declares noerror; the pass holds its result in a type that admits none, so a release that one day declares an error does not compile.reconcileScoredTimescannot fail by construction. Its notice's only error is a missing matchUp, which the pass's guard keeps from reaching it (settlePassesCannotFail.test.ts).reconcileMissedLinkAdvancementsreturns the error of the direction it makes, and the call is refused on it (CA, 2026-10-24).directWinnercan return one there: a target matchUp with no free slot (ERR_EXISTING_POSITION_ASSIGNMENT), or one from the advance it makes onward. It is known only once the cascade has written, and whether a placement will fail depends onyieldSquattingPropagatedBye, which can itself write before it decides, so no pure check can be asked for it in advance. It was dropped until 2026-10-24; it was never reached with an error over the suite and the frozen census windows (2026-10-22), nor over ~97,000 census schedules (settle telemetry, 2026-10-24). A refusal here is an error after a write, accepted because it is not reached; v2 plans it before its first write (aSettlePassReportsWhatItCannotDo.test.ts).
-
A settle loop that reaches its bound with work left refuses the call with
SETTLE_BOUND_REACHED, naming the loop (F9 (i), CA 2026-10-19 and 2026-10-24). The bounded loops arepropagateExitFrom,sendHeldExitsOn,produceStrandedConvergences,crossLinksThroughByesandreconcileLinkAdvancements; their limits areSETTLE_PASS_LIMITS. Each asks once more whether work is left before refusing, so a draw needing exactly its limit is not refused. None was reached on ~97,000 census schedules; like the dropped error above, a refusal at a bound is an error after a write, accepted because it is not reached, and v2 plans it before its first write (aSettleLoopAtItsBoundRefuses.test.ts). The one exception is the forward settle (settleForwardConsequences): it is a repair loop that a record missing many winner advancements reaches, so it keeps its success with aFORWARD_SETTLE_EXHAUSTEDwarning naming the matchUp still owed, and the next call settles the rest (CA, 2026-10-24).Measured 2026-10-22 over the suite and the frozen census windows w1, w2 and de: the release was reached 4 times and the notice 3,922 times, never with an error.
What can no longer fail, and why (2026-10-22, CA: an error found after a write is made impossible by construction where that can be shown, and is otherwise handed to v2 as a planned refusal):
- No
positionTargetserror after the first write. Its only error is a malformed round link (§ 2 row 21), and row 21 now asks every WINNER and LOSER link in the draw, not only those the matchUp's targets and its downstream walk reach. Nothing that sets an outcome writes a link, so a draw that passes row 21 has none for the rest of the call. That closes thepositionTargetsrefusals insettleRederivedDoubleExits,reconcileStaleExitOrigins(whose only error it was),reconcileDecider,settleForwardConsequences,settleHeldExits,propagateUnfillableLoserBye, andswapWinnerLoser'sgetDownstreamStructureIdsafter its relabel. Measured ondev01ce40e544 before the change: a malformed link the walk did not reach was met bysettleHeldExitsafter the score had been written in 57 cells of a scan over five draw types (refusedBeforeTheFirstWrite.test.ts). - No
addNoteserror.notesare validated before the first write (§ 2 row 23). - No
MISSING_DRAW_POSITIONSfromdirectParticipants. A matchUp with nodrawPositions, given a winner on the route that reaches it, is refused before the score is written (§ 2 row 24). - A TEAM dual writes nothing before its refusals. Its auto-calc flag and its sides' lineUps were
written by
handleTeamAutoCalcabove every refusal that followed (row 5'sAWAITING_RESULT, row 6, row 16); they are now decided there and written once those refusals have been asked.
Handed to v2 (each is a cascade write whose failure depends on the draw as the cascade leaves it, so v1 cannot ask it before the first write; reached in the suite only by fault injection, and never with an error in the frozen census windows w1, w2 and de, default and
doubleExitPropagateBye: false, 2026-10-22):propagateExitFrom(progressExitStatus's placements); the apply-stage refusals insidesetMatchUpStateafter its first write (noDownstreamDependencies,removeDoubleExit,attemptToSetWinningSide'sremoveDirectedParticipantsanddirectParticipants,attemptToModifyScore'sMISSING_ASSIGNMENTSon a line of a dual under manual scoring (its other reach, a line given a winner with no line-up assigned, is refused before any write),updateTieMatchUpScore,relabelWithoutDirection,swapWinnerLoser's writes after its relabel); and in the settle steps,settleRederivedDoubleExits(itspropagateUnfillableLoserBye,directWinnerand carry),oweDissolvedConvergencesTheirByes,reconcileConsolationReservations,reconcileCarriesPastByes(both calls),settleHeldExits,reconcileByeAdvancements,reconcileDecidersandsettleForwardConsequences. They still return their error; none is relied on to be rolled back. Every one of them reachesv2.comparebeforesetMatchUpStatusreturns it (outcome v2 executor plan, Phase C prerequisite 3), so underdifferentiala refusal v2 did not plan is a divergence (§ 7.1: the comparison writes back what it captured before v1 ran; v2 itself plans every refusal before its first op, so it has nothing to undo). Until 2026-10-24 the refusals out ofsettleDraw,settleForwardConsequencesand the carry asked after it returned without the comparison (aLateRefusalIsCompared.test.ts). - No
-
A refused call stores none of a draw's missing edges (CA, 2026-10-18: "no, a refused call does not store a draw's missing edges. v1 should no longer do so."). A draw stored without
winnerMatchUpId/loserMatchUpId(an older record, a file the factory did not produce) is given them once, before anything is decided, because the cascade decides on the stored ids. What that write touches (the edges,finishingPositionRange,finishingRound) is held before it and written back on any error the call returns: directly, insidebulkMatchUpStatusUpdateorexecutionQueue, with or withoutrollbackOnError, and on the async engine. A call that succeeds keeps them, and the draw stores its edges from then on. v2 refuses before the write is made. Pinned bystoredEdgesAreNotRequired.test.ts. A successful call that repairs them announces the draw once, with oneMODIFY_DRAW_DEFINITIONand noMODIFY_MATCHUPfor a matchUp whose only change is an edge (CA, 2026-10-18;anEdgeRepairAnnouncesItsDraw.test.ts). -
What one step hands the next is the draw itself. A context passed between steps carries references to the stored matchUps, never copies: the engine's deep-copy setting governs what is RETURNED to a caller, never what a mutation reads or writes.
-
Asking for the state a matchUp is already in is satisfied, not repeated. A second identical double exit is a no-op success; without this, the cascade read its own earlier work as a second source and escalated a WALKOVER to a DOUBLE_WALKOVER. Scoped to double exits only.
-
A first entry always propagates. Dispatching on "downstream active" alone refused a TO_BE_PLAYED Main matchUp above a played consolation and, routed the other way, silently stopped winners advancing in 27 FMLC cells.
-
Score strings never disagree with sets, because they are not accepted.
-
A completed matchUp with a valid winning score cannot be reverted to a live status without a new result; submit a corrected outcome or clear first.
-
The properties the exit-propagation harness checks (
DO_UNDO_IDENTITY,IDEMPOTENT_REAPPLY,MONOTONIC_DECISION) are stated in the corpus vocabulary (corpus/INVARIANTS.md) and measured on the generated fixtures in the matrix and census. These are intended invariants, not a universal proof. On real records, see § 8 (real-record do/undo) and the clear that normalises in § 4.
7. Write mode
In NATIVE mode (the default since 5.0.0), schedule stamps such as scoredTime use first-class
matchUp.schedule attributes. LEGACY uses the corresponding timeItems; BRIDGE writes both via
setFirstClassOrTimeItem. Result, status and scoring codes remain first-class.
This storage mapping is not evidence that exit behavior is identical across modes. Provenance writes are mode-gated and propagation decisions read provenance; a NATIVE census result must not be reported as LEGACY/BRIDGE validation. Cross-mode compatibility requires its own fixtures and replay evidence. See harness measurement limits.
7.1 Two implementations (S2)
src/mutate/matchUps/outcome/ is the clean-room re-implementation of this page, written from it and
from the corpus. It works over a read-only view of the draw: refuseOutcome(request, view) is § 2
as one pure function, chooseRoute is § 3, planWrite is § 4 and planDirection is § 5's
direction and exit propagation. v1 is the pipeline as written across setMatchUpState and the
matchUpGovernor routes, and it is still the only one that writes.
The mode is process-wide, set with
engine.outcomePipeline(mode) and read with
engine.getOutcomePipeline(); no argument
restores v1, and an unknown mode is INVALID_VALUES.
-
v1(the default): nothing is built and nothing is decided by v2. -
v2: v2 decides the refusals. A refusal it raises is the call's result and v1 is not asked. An outcome it accepts is planned (§ 7.2); a call whose complete plan is a shape v2 owns is written by v2 (outcome/apply.ts: the plan's ops folded into the stored draw by the one reducer, then v1's own notices for what was written) and v1 is not asked; every other call is handed to v1 whole, which routes and writes as underv1. Since S2 v2 owns the local write: the matchUp's own result (an in-progress, suspended or corrected live score, a format change with it, a cleared live score, or the same result submitted again, which changes nothing but stamps), with no winner before or after, no exit, nothing directed, no tally and no settle work. It leaves the record, the notices and the result v1 leaves for the same call (ownedLocalWrites.test.ts, under a fixed clock); an owned call takes no hydration, and itsupdateInContextMatchUpis built only for a subscriber, after the call has succeeded. Since S3 v2 also owns the first direction: a result naming a winner, not an exit, whose winner goes into the next matchUp of the same structure (holding no exit or result) and whose loser, if a link takes them, arrives on a free seat carrying nothing, with no settle work after. A loser arriving where a carried single exit already stands awarded to their seat (the carrier's WALKOVER or DEFAULTED came down the link first, itswinningSidenaming the empty seat) takes the award as v1'sassignDrawPositiongives it (participantArrivesAtExit, C18): that matchUp is written back as it stands with its codes re-derived ([]) and announced as the assignment, and the loser's position goes on into the next matchUp of the structure, a clean arrival there, or nowhere from the structure's last round (standingAwardArrival). A produced exit standing pending (no winner until somebody arrives), an award on the other side, codes stored, a BYE beside the seat or a position already standing onward stay v1's. The winner arriving at a single produced exit pending in their same-structure target takes that exit (C19,pendingProducedArrival): exactly one provenance entry names the paired feeder's double exit, the target has no winner, positions, BYE, score or codes, and the arriving side is empty. Its status is retained, its winner becomes the arriving side, codes are[], the stored scoreless shape is kept (blank strings or absent), and no scored time is stamped. The arrival's source origin is merged into provenance, the position is placed, and the award is announced asassignMatchUpDrawPositionwith the event and tournament. The arriving position goes on into a clean next matchUp (onwardFrom), announced and stamped, or nowhere from the structure's last round. A loser also meeting a pending produced exit across their link remains v1's at the earlier loser wall. A loser placed opposite a BYE goes on through it at once, as v1 sends them (advanceIntoWinnerMatchUp): their position joins the next matchUp of that structure, or occupies it there when it was advanced structurally while their seat stood empty, and that matchUp is announced. Only a clean next matchUp is planned (TO_BE_PLAYED, no BYE, exit, carry, provenance or result, no earlier advance of the BYE's position to replace, and no FIRST_MATCHUP reservation it would then raise). C20 also plans a first plain loser's arrival through a chain of BYEs or at a last-round BYE (plainByeArrival). Each BYE remains scoreless, without a winner, codes or provenance, and holds the arriving position opposite a BYE in the loser's linked structure. The entry is written on position assignments; every later BYE and the clean landing is announced as an assignment and stamped. No result is awarded and no provenance is created. A last-round BYE has no onward placement. A winner link crossing into another structure remains v1's. For a TEAM dual's own call, draw line-ups are assigned from the furthest reached matchUp back toward the entry, whose line-up notice has no event. A deciding TEAM line assigns draw line-ups beyond the entry in the same reverse order, then carries the losing side's held line-up onto the entry, announceddirectLoserwith the event. A winner whose next matchUp holds a BYE (a consolation seat a reservation filled) goes on past it the same way, under the same conditions. An ad hoc matchUp's winner directs nothing, and its structure's tally is planned when it holds one round (a Swiss's later rounds stay v1's). A result in a lucky draw's pre-feed round (a round of odd size) directs nothing either: v1 advances no one from it, the advancement being chosen afterwards (luckyDrawAdvancement). A double exit in a lucky draw (LUCKY_DRAW, ADAPTIVE) advances nobody, in a round of any size (CA, 2026-11-17): it is written on its own matchUp, produces no exit in the next round, and whoever arrives beside the seat it leaves empty waits there (doubleExitAdvancementreturns at once; cleared, nothing is taken back). The planners plan no produced exit for it and abstain (exit), entered, cleared or replaced: the call is read off v1's whole write. An FMLC loser fed into the consolation's round 2 is included (the seatpositionTargetsreports is the onedirectLosertakes). A loser that feed keeps out (they have won before) is owned too: their seat takes a propagated BYE and its matchUp becomes a BYE, asdirectLoserplaces it, or nothing is written when a reservation made the seat a BYE already; a BYE that would meet somebody in the other seat stays v1's. A seeded loser stays v1's: v1 carries the seed into the structure they are placed in (propagateLoserSeed), which is not yet an op. It writes v1's notices for it (the next matchUp'smodifyMatchUpnamedassignMatchUpDrawPosition, amodifyPositionAssignmentsfor the structure the loser is placed in) and returns v1's directioncontext(ownedDirectionWrites.test.ts). Underv2the mutations suite has about 10,000 calls v2 writes as a direction. A final is owned the same way: a winner with no next matchUp and no winner link out of the structure (a qualifying final places its winner in the main draw, and stays v1's), whose loser, if a link takes them, arrives as a plain placement. AFIRST_MATCHUPreservation the winner's arrival makes is owned with it: when the next matchUp then holds two positions, no BYE and no result, and every first-round matchUp feeding it has a scored win (this call's among them), its loser will have won and may not enter the consolation, so the seat the link feeds is a BYE (markedbyeFromPropagation) and its matchUp a BYE, as v1'spropagateConsolationByewrites them, with v1's notices (modifyPositionAssignmentsfor the consolation, its matchUp'smodifyMatchUpnamedsetMatchUpStatusBye). A seat already a BYE needs nothing. A reservation that would meet somebody (the consolation matchUp's other seat held, or this call's own loser placed in it), a seat holding a participant or provenance, a stale reservation to withdraw, and a BYE-only target beside a playoff link stay v1's. The first corrections are owned too (S4). A new played score beneath an active downstream that keeps its winner (apply-values) writes the matchUp's values and re-directs nothing. A decided result cleared while its downstream is untouched (remove-directed), where all it directed is the winner's position in a clean next matchUp of the same structure, takes the position back out, with that matchUp's score; a loser the result placed across a link is taken back out with it when they still hold the seat the link fed, in a matchUp they have not played (no result, exit, provenance or BYE beside them): the seat is emptied and their seed entry there goes, and, when the call names a status, the matchUp's codes are re-derived from its provenance, as v1'sremoveDirectedLoserwrites them ([]where it stored none, which announces the matchUp). A cleared final whose loser a link fed (FEED_IN_CHAMPIONSHIP's Main final into the consolation's last round) takes that seat back the same way, with no winner's position to take back (C17); until thenremovedOpsplanned nothing for a final, the fed seat stayed occupied, and the settle check abstained the call. AFIRST_MATCHUPlink, whose removal may take a BYE back, stays v1's. So does a winner cleared in a structure that feeds its playoffs by finishing position (WIN_RATIO): v1 answers it with the playoff structures it reaches (connectedStructures, fromcheckConnectedStructures), a read of the whole structure. The same winner entered again while nothing downstream is active (thewinnerroute) is directed once more by v1, whose placements find the winner and the loser where the first entry put them; v2 writes the matchUp's own result and places nobody. That is planned when the stored result is a playedCOMPLETEDone, the winner stands in a clean next matchUp of the same structure (or the matchUp is a final), and the loser, if a link takes them, holds the seat it feeds in a matchUp with no result or exit. A draw holdingFIRST_MATCHUPlinks is not itself a reason to abstain, for the re-entry or a clear: a reservation the call would leave standing, or one to withdraw, is the consolation reservation pass's work, and its has-work predicate abstains the call (settle); a BYE-only target beside a playoff link, whose BYE v1 takes back with the removal, stays v1's. A changed winner while nothing downstream is active (thewinnerroute, the other side) is v1's removal and then a first direction (removeDirectedParticipants, thendirectParticipants), and is owned where both halves are clean: what the old result directed is taken back as a clear would take it, and the new winner goes into the same next matchUp (one write: the old winner's position out, with that matchUp's score, and the new one in), and the new loser onto the seat the old one leaves, carrying nothing and not seeded. The old loser's matchUp is announced first, as v1 announces it, then the result and the placements. A loser's matchUp has its codes re-derived only when the call names a status, as v1'sremoveDirectedLoserre-derives them (itssourceMatchUpStatus), for a clear and a changed winner alike. A swap (allowChangePropagationwith the other side winning) is a relabel, v1'sswapWinnerLoser: in the source structure the two positions are exchanged in every later round that holds either (each announced asswapWinnerLoser, before the score), a decided matchUp's winner carried across the re-sort, and nothing is placed or removed. It is owned when the result is a played one before and after, and no matchUp on the path holds an exit or exit provenance. Downstream, in each structure downstream of the matchUp (its structure's links from its round on, then every link out of each structure reached, as v1'sgetDownstreamStructureIdswalks them), the two participants' seats change identity (relabelPosition), every result there kept; a structure upstream (a consolation's Main, COMPASS's East beside West) is not touched. Owned when no link walked carries a condition, but the source structure's ownFIRST_MATCHUPfeeds, and those only where the flip leaves every feed's eligibility as it was (the new loser of the flipped matchUp may enter exactly when the old one held the fed seat, and no later loss on the path changes, v1'srelabelledPathFeedChanges), so v1'sreconcileFedLoserEligibilitywrites nothing; and no loser link feeds the structure from a downstream one (an origin, whose re-entries v1 exchanges by origin positions); a winner link back into it (DOUBLE_ELIMINATION's Backdraw champion re-entering the Main final on their own position) is covered by the path. The first exits are owned too (S5). A singleWALKOVER,DEFAULTEDorRETIREDentered with a winner on a matchUp holding no result, whose loser carries nothing on, is directed by v1 as a played result (directParticipants), so v2 plans it as a first direction with the exit's status, score and codes on the matchUp. Nothing is carried whenpropagateExitStatusis off, or on with no loser link, or for a retirement the policy does not propagate (propagateRetirementAsExit):directLoserthen places the loser plainly and sets nothing forpropagateExitFrom, and an arrival records no provenance in a target outside the exit cascade (assignMatchUpDrawPosition'sparticipatesInExitCascadegate). The settle passes are asked as they are for a played result; only an exit v1 propagates (a double exit, or a single exit carried across a loser link) still puts every pass in reach, unless the plan holds the carry as ops (below). ADEFAULTEDunder a scoring policy namingprocessCodes.incompleteAssignmentsOnDefaultstays v1's: v1 may write those codes onto the matchUp (modifyMatchUpScore), which is not an op. A carried exit is owned one level deep: aWALKOVERorDEFAULTED(or a retirement underpropagateRetirementAsExit, carried as aWALKOVER) that follows its loser across the link onto a free seat with nobody and no BYE opposite, in a matchUp holding no result, exit, codes or provenance, which does not link its own loser on. v1'sprogressExitStatustakes RULE 2 there: the loser's matchUp is written the carried status, awarded to the side nobody has reached, its codes[]and aWALKOVER's score blanked, and the carrier's side given the carried entry (mergeSideExitProvenance); nobody advances from the empty side. Where a participant stands opposite (RULE 3) they are awarded the exit and go on: their position joins the next matchUp of that structure, planned only where it isTO_BE_PLAYEDwith no result, BYE or provenance and a seat to take, and announced as v1'sdirectWinnerannounces it. Where a BYE stands opposite (RULE 1) the carrier passes it into the next matchUp of that structure, planned only where that matchUp is clean (as a plain loser's pass through a BYE is) and holds no codes or provenance: the BYE matchUp stays a BYE and records the carry beside its BYE on the carrier's side, announced by itself (progressExitStatus), and the exit lands beyond it by RULE 2 or 3. Where what lies beyond that BYE is no clean matchUp (S6 tail, the BYE passage), v1 re-propagates the exit onto the nearest later matchUp of the structure holding the carrier (findAdvancementMatchUp), RULE 1 again wherever that is a BYE-held matchUp: each BYE matchUp passed records the carry beside its BYE on the carrier's side, announced by itself, the source and status those of the matchUp the carrier lost, until the passage reaches a clean matchUp, where the exit lands by RULE 2 or 3 as above, or the structure's last round, where there is nowhere further and the carry stops (nothing more is written). Planned where every BYE-held matchUp passed already holds the carrier's position (advanced structurally while their seat was empty) opposite a BYE, and the passage ends in the last round or in a clean matchUp; a BYE whose winner crosses a link (DOUBLE_ELIMINATION's Backdraw final) is v1's. A TEAM dual's passage is planned as a dual's carry is (S7, below). It is announced as a score write, its in-context matchUp to a subscriber included, and the call's result carries no propagation context. A matchUp that links its loser on (COMPASS, OLYMPIC, PLAYOFF) makes the carrier, its loser, carry the exit again (propagateExitFrom's loop): v2 plans the loop level by level from the draw as the call found it, each level's seat and matchUp clean as the first must be (no link condition; a BYE opposite passed by RULE 1 into the clean matchUp beyond it, which records the carry beside its BYE as at the first level), the carrier placed and the exit written with the landing they lost as its origin, a level's BYE passage planned as the first level's. The walk is bounded by v1's ownSETTLE_PASS_LIMITS.exitLevels, counted as v1's loop counts it: one iteration for each landing written and one for each BYE passed; a chain that reaches it is v1's, which refuses there (SETTLE_BOUND_REACHED, F9 (i)), so v2 never plans the bound. A double exit in a round robin group sends nobody on (doubleExitAdvancementreturns at once in a container): its result and the group's tally are planned, and the settle passes are asked as for a played result. A double exit elsewhere is owned where its produced exit lands pending: entered on a matchUp holding no result, in a structure it links nothing out of, it produces aWALKOVER(or aDEFAULTEDfrom aDOUBLE_DEFAULT) in the next matchUp on the side it feeds, written with no winner, its codes[], aWALKOVER's score blanked and the fed side given its origin (buildSideExitProvenance, v1's builder). Planned where that next matchUp is to be played with no result, BYE, exit, codes or provenance, links no loser on (a seat nobody can fill takes a BYE,propagateUnfillableLoserBye), nobody stands on the side it would be awarded to, and the matchUp beside this one is still to be played. Where the winner of the matchUp beside this one already stands there (a played result or a single exit that delivered them), the produced exit is theirs at once: written with their side as winner, their origin recorded beside this one's, and they go on into a clean next matchUp, announced, as v1'sdoubleExitAdvancementannounces it, with no event or tournament (announcesContext: false). In a feed round (as many matchUps as the round before it, a position fed from another structure on side 1) the double exit feeds side 2, and where the fed seat holds a position nobody has reached yet the produced exit stands pending for whoever arrives there while v1 advances that empty position into the next matchUp ahead of them (a reservation), announced the same way; a fed seat already filled stays v1's. A convergence (RULE 4) is owned where a carried exit lands on the seat a carried exit standing there was awarded to: the matchUp becomes the double exit (collapseDoubleExitStatus: two defaults aDOUBLE_DEFAULT, anything else aDOUBLE_WALKOVER, whose score is blanked), its award taken away and the arriving side's entry merged beside the standing one; then that double exit produces onward as one entered there would, pending, with the reservation beside a fed seat. Planned where the landing holds that single exit and no score value, links no loser on, and the produced exit lands clean. The same rule holds at every level of the carry's walk, not only the first (S6 tail): a carrier crossing a deeper loser link onto a seat a carried exit standing there was awarded to meets it there, written as above with the landing they lost as the arriving entry's origin, and the walk ends (a double exit has no loser to carry on). In a structure's last round the double exit produces nothing (doubleExitAdvancementfinds no winner target). Its codes are v1's projection of the landing's provenance before the arrival (deriveStatusCodes): a side whose standing exit a double exit delivered shows its outcome code. Stays v1's: a landing whose award's position has already gone on into the matchUp it would produce into (v1 takes it back out as the convergence unseats it). A landing that links its own loser on (S6 tail) is owned where the double exit's BYEs plan as the BYE walk places them (below): from the landing's own loser seat and from the seat its produced exit leaves unfillable, at the first level or a deeper one. A carrier standing on a seat that BYE takes is displaced with their carry (withdrawDisplacedCarry): the seat's carried entry withdrawn, and a BYE origin opposite it, the matchUp they had landed in made a BYE and itsscoredTimetaken byreconcileScoredTimes, which announces it after every other write; where that matchUp links its loser on, the BYE it becomes sends a BYE on and the carry they took further is displaced the same way. Planned where the displaced carrier's landing holds their carry alone (a single exit awarded to the empty side opposite, no score or codes); any other occupant of such a seat is v1's. A double exit whose produced exit meets a pending one a double exit beside it produced there converges with it: the matchUp becomes the double exit (collapseDoubleExitStatus), with no winner, codes[], aDOUBLE_WALKOVER's score blanked and the arriving side's origin beside the standing one, and it produces on as one entered there would (advanceConvergedWinner); planned with nobody there and the exit produced onward landing clean (or none, from a final). With loser links (underdoubleExitPropagateBye; off, the landing's BYE gives way to a produced exit,serveConvergedLoserLink: v1's), this matchUp's own loser seat takes its BYE first, with all it sends on; the landing's loser seat, a BYE since the first exit was produced there, is left as it is; and the onward matchUp's loser seat, which its produced exit leaves unfillable, takes a BYE with its chain before that exit is written. A double exit with loser links is owned where its produced exit lands pending, or is awarded at once to the winner of the matchUp beside it, who goes on as above: nobody loses the double exit, so the seat its link feeds takes a propagated BYE and that matchUp a BYE, and the position opposite (empty, or the participant standing there) is advanced through it into the next matchUp (advanceWinner, announced with no event, the matchUp it joins written with no score); nobody will lose the produced exit's matchUp either, so the seat ITS link feeds takes a BYE too, announced with no event (propagateUnfillableLoserBye), its structure's assignments announced with no event unless another placement there named one (the notice buffer keeps an earlier event,preserveNoticeIdentity). Each BYE goes on as v1'sassignDrawPositionByesends it: the position opposite it goes on into the next matchUp where there is one, and, a BYE matchUp's loser being the BYE, a matchUp that links its loser on puts a BYE on that seat too, with no event, level by level (COMPASS, OLYMPIC, CURTIS), the structures' assignments announced deepest first. A BYE opposite the double exit's own seat (the paired feeder a BYE) makes a double BYE: that matchUp, a BYE already, is left as it stands; the seat's position already stands a round on (the BYE opposite advanced it), so the matchUp there becomes a BYE, announced with its event, and the one other position it holds (a fed seat nobody has reached) goes on into a clean matchUp, as the winner standing in the produced exit's matchUp, delivered by that BYE, is awarded the exit with the BYE recorded as their origin; where it holds no other position (its other feeder still to be played) it becomes a BYE and nothing goes on yet. A double BYE in a final goes nowhere: v1 writes that matchUp, a BYE already, as a BYE again (announced with no event at a deeper level). Where the next matchUp is a BYE the position had passed through (a BYE opposite it, a feed round's fed BYE included: S6 tail), the double BYE goes on from there as from the first (S6). A matchUp the double BYE makes a BYE in its structure's last round sends the position beside it nowhere (S6 tail). A double BYE's matchUp was a BYE already and sent its BYE across its loser link when it became one, so the chain ends there (S7). The own seat behindFIRST_MATCHUP(FIRST_MATCH_LOSER_CONSOLATION's Main round 2) takes the BYE too, whatever the condition: nobody loses the double exit (S7, walked). Each level is a first-round seat, free behind no condition, in a clean matchUp: alone, or opposite a BYE, a double BYE there too, planned as the first one is but announced with no event (S6), the walk bounded bySETTLE_PASS_LIMITS.exitLevels(F9). A level whose seat holds a BYE already takes nothing, and the chain ends there (S6 tail). UnderdoubleExitPropagateBye: falsethe loser seat shows the produced exit instead: the loser matchUp is written the double exit's flavour awarded to the side opposite the seat, its codes[], aWALKOVER's score blanked and the seat's side given the origin (conditionallyAdvanceDrawPosition), with noscoredTime; its structure is stamped, and the position opposite is advanced into the next matchUp, announced with no event or tournament: a participant standing there goes on, an empty position goes ahead of the arrival it awaits; from its structure's final (a one-round structure, COMPASS's North) nothing advances (S7). Planned in a first round that is not fed, no BYE opposite the seat. Where that advance goes into the matchUp the unfillable seat is in (FIRST_MATCH_LOSER_CONSOLATION, behindFIRST_MATCHUP), the unfillable seat's BYE reads the matchUp as the advance leaves it: it becomes a BYE, announced last with the tournament, and the advanced position goes on through it (S7). A fed seat (a feed round's: a Main double exit past the first round in FEED_IN_CHAMPIONSHIP, DOUBLE_ELIMINATION and their kin) takes a BYE whatever the policy, planned as the BYE chain below plans it (S7). A loser matchUp that links its own loser on (COMPASS, OLYMPIC) leaves that seat to nobody: before the exit is written there, the seat takes a BYE with no event, with all it sends on, as the BYEs below go on. Where a BYE stands opposite the seat (its matchUp a BYE already), v1 records the exit on the BYE matchUp, on the seat's side, its score removed, and carries it on into the matchUp the seat's position already stands in, where it lands pending with its origin on that side (stampExitOnByeHeldLoserTarget,carryExitOnward); both written with neither the tournament nor the event (setMatchUpResult.announcesContext: false), planned where nobody stands on the other side there and its feeder is still to be played, or is a BYE (the position it advanced waits for its arrival). Where that matchUp is BYE-held too, the exit is recorded there the same way and carried on again, to a matchUp to be played or to the structure's last round, where it stops (S7). Where the landing is the matchUp the unfillable seat is in (FIRST_MATCH_LOSER_CONSOLATION, behindFIRST_MATCHUP), that seat's BYE makes it a BYE, keeping the exit's origin (announced assetMatchUpStatusBye, with the tournament; its context read without it); once the produced exit is written, the position goes on into the matchUp after it and the exit lands there pending, announced last with the tournament and no event, on the side the position takes (beside another position in their order, alone the side its feeder's place sends it to). Planned where nobody stands there and a matchUp follows the landing (S7). Where a participant stands on the other side of the landing, the exit is theirs: written with them as its winner, and they go on into a clean next matchUp, announced asadvanceWinnerwith the event, or nowhere from the structure's final. When an unfillable-seat BYE writes that onward matchUp later in the same call, the notice keeps the advance's event and the finalsetMatchUpStatusByecontext (preserveNoticeIdentity, C26N). A landing that links its loser on stays v1's (decided, nobody loses it, and v1 sends a BYE across that link too) (S7). Otherwise outside a feed round, for links with no condition, free seats with no BYE beside them (a BYE there makes a double BYE, below), clean matchUps, and each matchUp touched once, but where the unfillable seat's matchUp is the one the first BYE advanced a position into (FIRST_MATCH_LOSER_CONSOLATION): that position goes on again through the second BYE; a participant standing opposite the unfillable seat goes on through its BYE the same way (S6). Where the own seat's double BYE has made the unfillable seat's matchUp a BYE, the position opposite gone on (FIRST_MATCH_LOSER_CONSOLATION), the unfillable seat makes a double BYE there too: the matchUp stands, and the one its position went on into becomes a BYE, announced with no event (S6). A BYE already standing opposite the unfillable seat (another double exit's, or the draw's) makes a double BYE there the same way; and where the own seat's BYE sent its position on through a BYE standing in the next matchUp, the unfillable seat's BYE sends its own position into the matchUp beyond as that chain leaves it, the two meeting there (S6 tail, FEED_IN_CHAMPIONSHIP and its kin). Where those shapes do not plan, the seats are placed by the BYE walk (S6 tail): v1'sassignDrawPositionByerecursion, run on a copy of the draw as the call found it. A seat given a BYE makes the furthest matchUp of its structure holding its position a BYE (setMatchUpStatusBYE); the position beside it there goes on into the next matchUp of the structure (advanceDrawPosition→advanceWinner), and beside a BYE there it goes on again; a BYE matchUp whose other side is a BYE sends a BYE to the seat its loser link feeds in another structure's first round; and a BYE matchUp past its position's first round holding no other position sends its BYE to its loser seat (assignByeToLoserTarget). The own seat is walked first, with the event named; the seat the produced exit leaves unfillable is walked on the draw the first walk leaves, with no event; a placement reached through an advance names no event (v1's recursion drops it there), one reached through a loser target names its caller's. The structures' assignments are announced deepest first, the matchUps in the order written. The walk is planned where every matchUp it writes holds no result, score, codes or provenance, no participant is displaced, no seat it reaches is fed or behind a link condition (the unfillable seat behindFIRST_MATCHUPexcepted), no winner link is crossed, and no advance turns a matchUp to be played into a BYE. It serves the convergence's own seat the same way. A BYE's position sent on into a next matchUp that is a BYE already, its other side the BYE alone, goes into it and on through it into a clean matchUp beyond (S6), each announced asadvanceWinnerwith no event. The unfillable seat takes its BYE behind aFIRST_MATCHUPlink too, as v1 places it (advanceByeToLoserMatchUpasks no condition); this matchUp's ownFIRST_MATCHUPfeed stays v1's. v1 writes it throughmodifyMatchUpScore, notsetMatchUpState, so it takes noscoredTime. Stay v1's: a double exit with a loser link beside a BYE or into a feed round; a carry past a BYE into anything but a clean matchUp or a BYE passage (above); a present opponent, for a carried or a produced exit, with nowhere clean to go on to (a produced exit awarded in the structure's final goes nowhere and is planned, S7: the award is all there is; a final whose winner links out, a qualifying final or DOUBLE_ELIMINATION's into its Decider, has its winner target across the link); a convergence but RULE 4's clean one; a correction to or from an exit (but the clean clear below); and an exit whose target holds a BYE, an exit or a result but for this one (S7): a double exit whose next matchUp holds a BYE on the side its produced exit is awarded to (a consolation feed round whose fed seat took a BYE, or a plain round's double BYE). v1 leaves that matchUp a BYE: it records the produced exit beside its BYE on the side the double exit feeds (in a plain round the BYE's own origin, the matchUp beside, too), keeps the codes its policy keeps ([]), and sends the exit into the matchUp beyond (advanceByeAdvancedDrawPosition), where it stands pending, no winner, its score blanked, recorded on the side that BYE matchUp feeds; no position is advanced, and the matchUp beyond is announced with neither event nor tournament. Where the matchUp beyond is BYE-held too, v1 carries the exit on (carryExitOnward): each BYE-held matchUp passed stays a BYE, codes[], score blanked, the exit recorded on the side it arrives at, announced with neither event nor tournament; the walk ends at the structure's last round (nothing more written) or lands the exit pending in the first clean matchUp, which is then announced with its event and tournament, its matchUp in context read without the tournament (inContextBare). Straight past the first BYE, a position nobody has reached may stand on the matchUp's other side (the exit stands pending), or an opponent, who is awarded the exit at once and goes on into a clean matchUp (advanceWinner, with neither event nor tournament), or a produced exit pending on its other side: the two converge into the double exit (collapseDoubleExitStatus, codes[], the arriving exit recorded on its side, announced with neither event nor tournament), which produces on as any double exit: pending in a clean matchUp after (a WALKOVER's score blanked) or converging again with a pending exit there, each later level announced with its event and tournament, to the structure's end. Planned where nothing links a loser on, no matchUp walked links its own loser on, and the matchUp landed in is to be played in a plain round of the same structure, holding no result, BYE, provenance or loser link and nobody on the side the exit arrives at; the rest stays v1's (exit,cascade).The first unwind is owned too (S6). A double exit cleared (the
clear-scoreroute) is v1'sremoveDoubleExitand then the clear's own write. It is owned where all the double exit sent on is its produced exit, still pending, in a structure whose only links out are loser links with no condition: the next matchUp holds that exit alone (no winner, positions, score or codes, and this matchUp's origin, on the side it fed, as its only provenance), and every matchUp beyond it on the winner's path to the final is to be played with no positions, result, codes or provenance. v1 walks that whole path, not just the produced exit (conditionallyRemoveDrawPosition→removeDoubleExit, level by level), and writes each matchUp back to be played: codes[], its score blanked, throughmodifyMatchUpScore(noscoredTimerule), and the produced exit's origin withdrawn (setSideExitProvenance). Past the produced exit's matchUp v1's walk passes on neither the tournament nor the event, so those writes are announced without them (announcesContext: false). At each level it also visits the seat the loser link feeds (removeDirectedBye, underdoubleExitPropagateBye). The two seats the double exit gave BYEs (its own loser seat and the one its produced exit left unfillable) have them withdrawn (withdrawBye). Each BYE's matchUp is to be played again (clearMatchUpBye), and a position the BYE sent on is taken back out of the next matchUp. These are announced as v1'sclearDrawPositionannounces them,removeDrawPosition-<the BYE's position>, with neither event nor tournament. A seat further on holds nothing yet, and the visit only announces and stamps its structure (CURTIS's Play Off). A BYE matchUp that is to be played again and links its own loser on takes back, in turn, the BYE it had sent to that seat (S6 tail, v1'shandleLoserMatchUpRemoval): at a first-round seat holding a propagated BYE behind no condition, withdrawn as above and recursively on, but announcing no assignments for that structure (drawPositionRemovalswrites none:withdrawBye.announcesAssignments: false). A double BYE's matchUp keeps the other BYE, so it cascades nothing; a BYE matchUp in its structure's last round (COMPASS's one-round structures) sent nothing on, and only becomes to be played. The order is v1's recursion: deepest first, each level's seat before its matchUp, the call's own seat last, and the clear's own write after all of it. Where the produced exit had been awarded at once to the winner of the matchUp beside this one, who went on into the next matchUp and stands there alone, the unwind takes the award back: the produced exit's matchUp is to be played with its winner removed and all its provenance gone (the awardee's arrival entry with this origin), and the awardee's position comes back out of the next matchUp as v1's walk writes that matchUp back to be played; the awardee stays where they arrived. A WINNER link out of the structure (DOUBLE_ELIMINATION's Main to its Decider) does not change the unwind: v1's walk crosses it from the final, takes back a participant the final had sent across (nobody, the final being undecided) and writes the matchUp there back to be played as it writes the path, its structural positions standing, with neither event nor tournament; and the final's loser seat in that structure is visited (its assignments announced with no event) (S6 tail). A BYE the double exit placed behind aFIRST_MATCHUPlink (the seat its produced exit left unfillable,advanceByeToLoserMatchUpasking no condition) is withdrawn as any BYE it placed; a seat further on behind one may hold a standing reservation and stays v1's. The next matchUp a withdrawn BYE's opposite position stands in is read as the deeper withdrawal leaves it (v1 withdraws the produced exit's BYE before the double exit's own, and the two meet in FIRST_MATCH_LOSER_CONSOLATION's second consolation round); where the position taken back out leaves that matchUp with no position, v1 releases it (releaseAdvancedDrawPosition, with neither event nor tournament) rather than clearing it: FIRST_ROUND_LOSER_CONSOLATION, and the matchUp a double BYE had sent its position on into two rounds on (S6 tail). Stay v1's: a cleared double exit in a feed round; behind a loser link with any other condition; whose produced exit was awarded to a winner who has gone further or does not stand alone; whose BYE went on across a further loser link (COMPASS, OLYMPIC); whose a final that has sent its winner across its link; or with anything played beyond it.A produced exit that converged with the paired matchUp's (two adjacent double exits in one round: the next matchUp a double exit by convergence, two origins, nobody there, producing on in turn) is dissolved as v1 dissolves it (S6 tail): the converged matchUp is not written back to be played but re-derived to the kept origin's pending exit (
getUnwoundStateunderpairedPreviousDoubleExit: the status its retained provenance derives, a mixed pair keeping the other's label; no winner; the score kept; codes re-derived, none kept), and what it produced onward is taken back as any produced exit's is, the next matchUp reset where that origin was its only one and re-derived in turn where another stands beside it, to the first matchUp reset or a final re-derived (convergedChain); the path beyond is the plain unwind's. Each re-derived matchUp is written on the unwind (the first level's with the call's event and tournament, a deeper one's without, as its in-context notice shows) and again, as it stands, after the call's own write, undersettleRederivedDoubleExit(v1's settle pass), with the event and tournament at every depth: that later notice is itsmodifyMatchUp. Its loser seat keeps the BYE the convergence placed (its pending exit still sends nobody: v1 withdraws the claim and P39 claims it back, no notice); the BYE the reset matchUp's exit left unfillable is withdrawn as the produced exit's is in the plain unwind. The two paired double exits' own seats are adjacent, a double BYE: withdrawing the call's own, the other BYE's position is taken back out of the next matchUp, which is to be played again, and what that matchUp, a BYE until then, had sent on is released out of the matchUp beyond (releaseAdvancedDrawPosition, no event or tournament); then, after the call's own write, the standing BYE advances the freed seat into the next matchUp (reconcileByeAdvancements, announcedadvanceWinnerwith the event). Stay v1's: a next matchUp kept a BYE by another standing BYE, through which the advance goes on (FIRST_MATCH_LOSER_CONSOLATION); the convergence given a winner (the winner then lands beside the re-derived pending exit and is awarded it); and the dissolution underdoubleExitPropagateBye: false(the consolation convergence of the two carries re-derived the same way).A produced exit awarded to a participant who came through the paired matchUp's BYE (the double exit beside the draw's BYE: the BYE matchUp's position arrives opposite the exit, wins it, and goes on; the produced exit records the BYE-origin pair opposite itself,
{ matchUpStatus: BYE, previousMatchUpStatus: BYE }naming the BYE matchUp) is unwound as the awarded plain one: the awardee's position back out of the next round, the matchUp written back to be played holding them alone, both entries withdrawn (S6 tail). Its own loser seat stands beside the BYE matchUp's BYE loser, a double BYE whose own position the double BYE had sent on: withdrawing it, the next matchUp keeps that position as the freed seat it now is and is to be played again (removeDrawPosition-<seat>, no event or tournament), and what it had sent on as a BYE is released out of the matchUp beyond; no advance follows. The reset matchUp's unfillable BYE is withdrawn as in the plain unwind, its next matchUp read without the position the own seat's release takes out of it. Stay v1's: FIRST_MATCH_LOSER_CONSOLATION (the BYE matchUp's loser seat behindFIRST_MATCHUP), and the given winner.Where those plain readings of a placed seat refuse, the unwind walk (
unwindWalk.ts, S6 tail) runs v1's removal of the two placed BYEs on a copy of the draw, as the BYE walk runs v1's placement: the seat the produced exit left unfillable first, then the double exit's own, each throughclearDrawPosition. A seat emptied, its removal tasks are built over every round of the structure (buildPairingDetails: a BYE partner standing in the next round makes the step transitive, another partner there adds a task for it, a lone position's matchUp adds one for the hole-holding pair it feeds); each task finds its matchUp by the positions it holds at that moment, takes the position out of later rounds, then visits the matchUp (removeDrawPosition): the position comes out past its first round unless an opponent's BYE advanced it, the matchUp is a BYE while a BYE stays on it and to be played otherwise, and a matchUp left to be played that was a BYE releases the positions it had advanced (releaseUndecidedAdvancements); one left with no BYE takes back what it sent to its round-1 loser seat across a link (handleLoserMatchUpRemoval), the seat's removal run quietly (no assignments notice; an empty consolation seat's tasks change nothing). A visit is announced (removeDrawPosition-<the seat's position>, no event or tournament) unless the matchUp held the removed position at that visit and its status did not change; a release is announcedreleaseAdvancedDrawPosition. Each matchUp keeps the place and context of its last notice, and the structures announced in are stamped; a BYE the round-1 cascade takes back quietly stamps nothing by itself. The walk abstains where v1 takes another branch: a matchUp it reaches holding a result, score, codes, provenance or a line-up, a participant on a seat it clears, a participant's position across a winner link out of a round it releases (DOUBLE_ELIMINATION's Backdraw; a BYE's position there names nobody, and v1 returns without a write, S7), a release of a BYE's position or of one a BYE advanced (vacatedByes,advancedByBye), a fed loser seat (consolationCleanup), a loser seat a feeder still sends nobody to or behind a link condition (byeSeatStands), a write v1 makes without a notice, a BYE advance owed afterwards (reconcileByeAdvancements), or a walk past v1's bound. UnderdoubleExitPropagateBye: falsethe own seat holds the carry, not a BYE, and is read plainly (its branch or passage, below); the walk takes the seats that do hold a propagated BYE, the unfillable seat's (S7: DOUBLE_ELIMINATION and MODIFIED_FEED_IN_CHAMPIONSHIP 5 of 8, the seat in a double BYE whose own position went on alone into a BYE-held matchUp). A matchUp the branch wrote back to be played quietly and the walk then visits (the Backdraw final, from the Main final's loser link) is announced as the walk's visit,removeDrawPosition-<n>, with neither event nor tournament: v1's buffer keeps the later name. A double exit given a winner reads the same unwind.A seat's BYE matchUp that holds a participant's carried exit beside the BYE, in the structure's last round (a loser who walked over or defaulted, carried into COMPASS's South final or CURTIS's Play Off where the double exit's BYE stood: nothing passed on), is not written back to be played when the BYE goes: v1 re-derives it to that exit, awarded to the side without it, the carrier's record kept, announced
removeDrawPosition-<the seat's position>with neither event nor tournament and no in-context notice (clearMatchUpByewithrederived, S7). Owned where the carry is the matchUp's one origin, on the carrier's side, a participant's (not a double exit's produced exit), and the matchUp holds no winner, score or codes. Stay v1's: a produced exit relayed beside the BYE, and a BYE matchUp with a next matchUp but for the shape below.A seat's BYE matchUp whose carrier the BYE sent on (the same participant's carried exit beside the BYE, in a round with a next matchUp: the BYE advanced the carrier past each matchUp another standing BYE holds, a relay recording the carry beside its BYE, to the landing where the carry stands pending over an empty seat, or awarded to the participant there and that participant sent on) comes home with the carry when the BYE goes (S7,
carrierSentOn). v1 re-derives the BYE matchUp to the carry as above, then releases the carrier out of every round the BYE moved them through (releaseAdvancedDrawPosition, the carry withdrawn with the position,withdrawRelayedExit;bringCarryHomefinds it recorded beside the BYE already): the landing loses the position and the carry and is to be played, itsscoredTimetaken byreconcileScoredTimes, which announces it last, with the event and tournament; an awardee the landing had sent on comes back out of the matchUp beyond (releaseAdvancedDrawPosition, with neither event nor tournament, the landing keeping their position); each relay, a BYE still, loses the position and the carry and is announced as the position clear rewrites it after the release,removeDrawPosition-<the seat's position>, with neither event nor tournament (releasedDrawPositionon the landing and the matchUp beyond,withdrawnByePositionon a relay, the provenance removed). Cleared, that is all; given a winner, the loser seated beside the carry wins the re-derived matchUp as they are placed, and v1'sassignDrawPositionre-derives its codes ([]) and announces it (assignMatchUpDrawPosition, with the event and tournament, no in-context notice:placedDrawPositionwithrederivesCodes), then sends them on through each relay (announced the same way, the BYE standing) into the landing, whose last notice stays the settle pass's. Owned where the carry is each matchUp's one origin, on the carrier's side, from the same source, nothing else of a result anywhere on the chain, in one structure, no loser link out of the BYE matchUp, a relay or the landing, every relay's standing BYE another unwind's, and the matchUp beyond holding nothing of the landing's but the awardee, to be played with no result or provenance and the awardee sent no further. Measured on the four dirs (S7): the walls left are a BYE matchUp whose entry is not a participant's carry on the side opposite the BYE (65: a produced exit relayed there, or an entry on the BYE's side), a landing holding something else (20), a relay whose standing BYE this unwind withdraws (FIRST_MATCH_LOSER_CONSOLATION, 4), and a matchUp beyond that is not clean (2). The loser arriving with a carry that converges is planned against the rebuilt view below.A double exit given a single exit whose loser carries it across their link (
propagateExitStatus) onto the seat the unwind has just freed (S7,unwoundCarryReason): v1 directs the loser against the draw as its unwind leaves it, and the carry lands there as a fresh carry lands (progressExitStatus, RULES 1 to 3, then each further level). So the unwind's ops (its deferred settle writes left out) are folded into a working view, read again as an outcome view with the direction re-planned (rebuild, the composition point a result turned into a double exit uses), and the carry is planned on that view on a fresh carry's own terms (plainLoserReason: the seat free, as the unwind leaves it;carriedReason: the landing) and written from it (carriedOps). The writes are the unwind's, then the call's own, then the carry's: the loser's matchUp, freed of the BYE, written the carried status, awarded to the side opposite (the participant standing there, or nobody: v1 awards the empty side) with the carrier's entry merged into its provenance (modifyMatchUpScore, with the event and tournament, announced in context); the awardee sent on into the next matchUp, which the unwind had just written as the position clear or the release left it (the position the BYE advanced taken out, the matchUp emptied) and which v1'sassignMatchUpDrawPositionnow announces last, with the event and tournament, the withdrawal's or the release's name and quiet superseded (a plain placement after a withdrawal, a release or a quiet write is the matchUp's notice:withdrawnByeNotices,placedAfter, the orderedreleased). A feed round's fed seat lands the carry pending over its structural position the same way; underdoubleExitPropagateBye: falsethe loser's matchUp the unwind wrote back to be played takes the carry the same way (DOUBLE_ELIMINATION). Stays v1's: a loser behind a link condition, a carry the re-planned direction reads as anything but a fresh carry (converged with a re-derived exit), and whatever a fresh carry's own checks keep v1's (a seat the unwind did not free, still a BYE on the rebuilt view; a seeded loser; a BYE opposite with no clean passage, a landing holding a result or provenance, a further level not clean, a seat the unwind's cascade frees further on, which the re-planned walk reads as the stored BYE: COMPASS underdoubleExitPropagateBye: false).A double exit given a single exit whose loser converges with the home-coming carry (S7,
unwoundConvergedReason) uses the same rebuild, with the released landings read as the unwind will leave them to be played; deferred BYE advancements remain outside the fold. The rebuilt direction must still converge, and the fresh convergence's checks (convergedReason, RULE 4) must admit its free seat, standing carry and produced target. After the unwind and the call's own write, the loser is seated without advancing as an awardee: both sides now carry an exit. The re-derived BYE matchUp becomes the double exit, a DOUBLE_WALKOVER's score is blanked, the arriving side's carried provenance is merged beside the standing side's, and its produced exit is written into the released relay (convergedOps, from the rebuilt view). That fresh exit supersedes the relay's deferred reset: its existing scored time stays, as v1's reconciliation leaves the new exit standing. Covered by FRLC and DE 8's Main 1/2 walkover(2) CARRIED, Main 1/1 double exit, then Main 1/1 walkover(1) CARRIED, including a standing default and either stored double exit. A conditioned loser link, a direction that no longer converges, or anything the convergence's own checks refuse stays v1's. No new op field is needed.A produced exit relayed beside a withdrawn BYE (S7) stays where that BYE was: the origin still a double exit, directly feeding that matchUp, its one produced entry on the side opposite the BYE, no position or participant on that side. The unwind re-derives the matchUp to the retained exit, pending with no winner (
clearMatchUpBye.rederived). Owned here where its next matchUp holds only the unawarded pending copy, no position, score value, code, BYE or loser link, and a matchUp beyond is clean as the unwind leaves it. A plain loser arriving in the freed seat is awarded the produced exit with codes re-derived, no scored-time stamp and no in-context notice (assignMatchUpDrawPosition). The copy beyond is then withdrawn (withdrawProducedExits): its provenance cleared and result reset; an onward award's transient advancement is released from the matchUp beyond. Without an arrival, the empty fed position is reserved onward (advanceWinner, with event and tournament), its blank score removed by that placement. Thus the produced exit rests on the matchUp whose BYE went, and the later copy no longer decides the next round. A produced side holding a position, an indirect origin or a converged copy stays v1's; an awarded copy is owned below.An already-awarded copy of that produced exit (S7) is instead withdrawn during the unwind, before the arrival is planned. Its legitimate occupant stays: one real participant, opposite the retained produced origin, no score value, code or loser link; any other provenance only a completed feeder's ordinary arrival. The result is reset and its provenance cleared without changing its blank score (
withdrawsProducedExitonsetMatchUpDrawPositions), announced byremoveDrawPosition-<withdrawn BYE position>with neither event nor tournament. The advancement the award granted is released from a clean matchUp beyond, in the same structure, asreleaseAdvancedDrawPosition, also without event or tournament. A result beyond, advancement further on, or a linked continuation stays v1's. The unwind is folded before the direction is planned; the participant arriving at the re-derived home wins its retained exit and joins the now-undecided next matchUp beside its existing occupant. Without an arrival, the empty fed position is reserved there withadvanceWinner. The late withdrawal of a pending copy does not run again on the copy this unwind already reset, and the arriving loser does not take its former awardee's onward place.A converged onward copy of that produced exit (S7) can retain a foreign origin while the unwind takes back its own. The bounded shape has an empty feed-round BYE relay, an undecided two-origin double exit beyond with one reserved position, and a final holding only the exit that convergence produced. Withdraw the relay's BYE and retain its produced exit pending; re-derive the onward matchUp to its foreign exit, pending, and clear the final's withdrawn product. The own loser seat is itself a two-origin carried convergence: withdraw only this call's origin, retain the other direct carried single exit and its award, quietly reset the intervening relay, and stop at the retained onward origin. A plain loser arrival wins the retained carry and joins the relay; a clear leaves that seat empty. The own-seat score notice follows the call's write, while the onward re-derivation and final withdrawal are announced last as
settleRederivedDoubleExitandwithdrawProducedExits. An absent final score stays absent.clearMatchUpBye.retainedOnwardMatchUpIdbinds the stop to this relay. The own result'sretainedExitPlannedcertifies its retained origin and explicitly planned forward consequences without changing its score-writer notice. Settle prediction exempts only certified result operations from its broad propagation scope; all actual work detectors remain active. Occupied onward seats, indirect home origins and longer continuations stay v1's. A carried arrival has the additional composition below.A carried arrival into that retained convergence (S7) is re-planned on the working view after the unwind and its early released-landings writes. Its stored loser target was a double exit, so the original direction could not see this fresh carry. The private certificate binds the exact original own seat, relay, foreign onward origin, same-structure links and reserved position to their checked folded state. Only that certificate lets the fresh convergence produce its pending exit into the clean relay while reserving the relay's empty fed position into the retained onward exit; ordinary
producedTargetReasonremains strict elsewhere. A second working-view fold reads the new side geometry after reservation. The foreign provenance moves to that local side with all its origin metadata preserved. The old own retained-single result is not re-announced over the fresh double exit; onward settlement and successor withdrawal retain their late writer order and score shape. The relay's new actual score writer follows its quiet unwind write and names the event and tournament.setMatchUpResult.restoresNoticeIdentityrecords that measured restoration without changing itsmodifyMatchUpScorename or deferred in-context callback. Only the last actual score's marker applies; a later quiet or unmarked score does not inherit it. Unmarked score-write ordering outside this captured composition keeps the existing rules; no global identity assumption is introduced.A clear whose relay copy converged in an occupied final (S7) retains the real carrier's own awarded WALKOVER or DEFAULTED while removing only the relay producer's copied origin. The relay keeps that direct producer's pending exit; its propagated BYE is withdrawn. The carrier must be the live single-exit source's loser, reaching the final through standing BYEs whose positions and provenance still agree. A distinct
clearMatchUpBye.retainedCarriedAwarddescriptor carries the checked final, carrier, status and full retained origin. Folding the unwind and the empty position's reservation throughrebuildderives the new carrier side, provenance key and opposite award side together. An award to an empty position is retained as v1 retains it; existing blank scores remain blank. Ordinary position writes preserve those scores, unlikeadvancesThroughBye. The final's actual score follows the source's, deferring its callback last; a late namedadvanceWinnerwrite represents the reservation's notice without another callback. Only this clear's terminal re-derived result, with neither winner nor loser continuation, is certified as fully planned for propagation scope; all actual settle detectors remain active. Given-winner corrections remain separate from that clear program. Indirect origins, awarded continuations beyond the occupied matchUp and non-BYE carrier paths remain v1's.A plain given winner whose loser fills that occupied-final relay (S7) composes the same retained-carrier certificate with a terminal Main award. The original Main target is an unplaced, scoreless double exit with no forward links, codes or scored time; its foreign produced origin is a live DOUBLE_WALKOVER in the same structure. The unwind is folded into
rebuildbefore directing the fresh winner and loser. Only then is the terminal Main result projected to WALKOVER, retaining its foreign origin and adding the incoming COMPLETED origin without an exit status. Its early actual result supplies the first callback; its late named settle write carries the awarded result. The loser joins the relay through ordinary placement, whose namedassignMatchUpDrawPositionaward supplies no extra callback. Folding those arrivals with the occupied final's reservation derives the retained carrier's side and provenance anew. The final's actual score follows the source's; this winner program has no clear-onlyadvanceWinnerannouncement. Scored requests, format or carries changes, seeded or reserved loser arrivals and nonterminal re-derived winner targets remain v1's. The original five-setup outer correction still uses both legacy writers.A terminal directly produced relay (S7) retains the producer's pending WALKOVER or DEFAULTED when the source's propagated BYE is withdrawn. It has one position, one opposing produced origin, no raw winner or loser continuation, and a live direct producer in the same structure whose double status still matches that origin. The reader keeps producer codes and indirect origins outside this certificate. A clear leaves the pending exit and its original provenance. A plain arriving loser receives the relay's award through the existing named
assignMatchUpDrawPositionresult, without another callback. No onward position or copy is invented. The raw relay score property is absent in the captured family and stays absent; the named award carries no score field. Trigger propagation enabled still permits the captured clears; given winners under that flag remain refused by the existing per-op settle scope. No scope marker or detector exemption is added.A FIRST_MATCHUP arrival on a double exit's own unwound loser seat (S7) is admitted only for a round-two target when this own unwind explicitly withdraws the matching propagated BYE and the original seat has both
byeandbyeFromPropagation, or when the policy-off unwind has already validated and restored that own seat's branch with a planned result write. The already planned plain arrival supplies its participant and zero qualifying wins, using the same win-count query as v1; that is not a claim of zero prior matches. Existing seeded, reservation, clean BYE-through and settle checks still apply. The ordinary unwind, result and direction ops are unchanged. A conditioned arrival outside round two remains v1's. The existing branch-or-withdrawal check still refuses an uncertified seat. No history is recomputed and no scope marker or reducer field is added.A final's double exit (or the one matchUp of a one-round structure) produced nothing: cleared or given a winner, its unwind is the own loser seat's withdrawal alone, where a link feeds one (FEED_IN_CHAMPIONSHIP's consolation final seat; under
doubleExitPropagateBye: falsethe carry there, taken back as the branch), and the call's own write; given a winner, the loser lands on the freed seat as plainly (S6 tail). A final whose winner link leads on into another structure (DOUBLE_ELIMINATION's Decider, fed by both the final's links) stays v1's.A consolation double exit whose produced exit lands in a feed round (FEED_IN_CHAMPIONSHIP: the next matchUp holds the fed seat's structural position, which v1 reserves on into the round beyond) is unwound as the plain one once the exit stands pending beside that seat (S6 tail): the feed path is written back to be played with its structural fed positions standing, the reservation taken back out of the next round, the produced exit's origin withdrawn. On any path, the position the level before sent ahead (the awardee's, the reservation) comes back out of the matchUp holding it, and another position standing there (a feed round's own fed seat, an opponent arrived from the other half) stays, as v1 leaves it. Stay v1's: the exit awarded to the loser fed beside it, and the given winner.
A final's double exit entered (or the one matchUp of a one-round structure) produces nothing (
doubleExitAdvancementfinds no winner target): the call's own write, and the own loser seat's BYE with its chain where a link feeds one (doubleExitSeatswith no produced exit's matchUp), as v1'shandleLoserMatchUpplaces it; the settle predicates read such a call as propagating nothing, as a group's (S6 tail). Stay v1's: a final whose winner link leads on (DOUBLE_ELIMINATION's Decider), and the final underdoubleExitPropagateBye: false(the carry its loser seat takes).Under
doubleExitPropagateBye: falsethe seat a level's loser link feeds shows no BYE: the double exit carries its exit there (awarded to whoever stands or arrives opposite), and a further level's seat holds nothing of this unwind's. v1 visits the matchUp holding the seat all the same (conditionallyRemoveDrawPosition, the loser branch ofremoveDoubleExit) and walks on from it as it walks the main path, over winner and loser links alike: the position its result sent on is taken back out of every later round holding it (removeDirectedWinner,removeSubsequentRoundsParticipant), its winner path is followed to its final and across the final's winner link, then the seat its own loser link feeds, and each matchUp reached is written back to be played, deepest first, the visited matchUp last. The first level's matchUp is written with the call's event and tournament (v1 passes its arguments on there), the rest without; the carried exit's origin is withdrawn with the first write. A matchUp the branch reaches twice (DOUBLE_ELIMINATION: the Backdraw's final sends its winner across to the Main final, which the main path has already written) is written twice, and its notices take their place from the last write, the in-context one from the last score write. The structures of the matchUps written are stamped, as v1's notice for each stamps them. Owned where the first level's matchUp holds the carried exit alone (its one origin, on the fed side; a winner opposite or none; scoreless) and every other matchUp reached holds nothing (to be played, or a BYE this unwind withdraws, with no winner, score, codes or provenance; structural positions and the position taken back stand), the position taken back going no further than the matchUps written. A double exit given a winner under the policy is owned the same way, the loser placed on their seat in the matchUp the branch wrote back. Stay v1's: a carry that met a BYE or another exit there (a convergence), a participant sent across a winner link, a BYE placed behind one of the branch's own loser links (the carry's award with nobody for a loser sends one on through the BYE chain beyond: COMPASS, OLYMPIC), and the produced exit awarded (S6 tail).Where that seat stands opposite a generated BYE (the paired first-round matchUp's BYE loser), the carry passed the BYE (RULE 1): it is recorded beside it and beside each BYE-held matchUp after, and stands pending where it landed. v1's visit takes it back without walking on (S7): each BYE matchUp passed keeps its BYE, its provenance withdrawn by a score write that leaves the blank score and codes
[]and names neither event nor tournament; then the landing is written back to be played as quietly, the carrier's position standing in it (the BYE sent it there, and v1 never takes it out); the loser structure is stamped. A cleared double exit leaves it so. Given a winner, the loser placed on the seat goes on through the BYE into the landing (assignMatchUpDrawPosition, with the event and tournament, announced last; the landing's in-context notice stays the quiet score write's). Owned where the carry is each matchUp's one origin, on the carrier's side, and the landing holds it pending (its status, no winner, scoreless). Stay v1's: an award at the landing (somebody stood opposite and went on) and another origin beside the carry.Where the passage runs through the BYE the unfillable seat holds (FIRST_MATCH_LOSER_CONSOLATION and CURTIS_CONSOLATION: the produced exit's loser seat is the consolation's fed seat, whose BYE matchUp relays the carry on its other side and had sent the carrier's position on into the landing), v1 sequences the two levels across the landing (S7). The unfillable seat is visited first: its BYE withdrawn, its matchUp to be played, and the landing written by the position clear, the position the BYE had sent on taken out and the pending exit with it (to be played, no winner, codes
[], provenance removed, the score left as it is), namedremoveDrawPosition-<the BYE's position>with neither event nor tournament and no in-context notice (clearsPendingExit). The own seat's passage then finds the relay to be played and writes it so (the quiet score write, its provenance withdrawn), and nothing of this unwind's at the landing, where it stops. Given a winner, the loser goes on through the generated BYE into the relay, announced last as above. Owned where the relay and the landing hold this double exit's carry alone (ownCarryAlone: one origin naming it, no winner, scoreless, no codes) and no BYE stands in the landing; the deeper seats are read before the own seat for this (UnwindRelay), as v1 withdraws them first.A single exit cleared (a WALKOVER, DEFAULTED or RETIRED on the
remove-directedroute, back to be played) that carried nothing on is the removal of a played result: v1 takes it back through the sameremoveDirectedParticipants, with the same writes and notices (the winner's position out of the next matchUp, the loser out of the seat their link fed, codes[], the score blanked), so it takes the removal's shape and its checks. Stay v1's: an exit carried across the loser link (provenance or a carried status in the target), a BYE gone through beside the loser, and side provenance on the matchUp itself.A single exit corrected on the
winnerroute is owned the same way. A stored WALKOVER, DEFAULTED or RETIRED, or a played result, may be re-entered, relabelled (a WALKOVER as a DEFAULTED, an exit as a played result, or the reverse) or given to the other side, as long as neither the stored result nor the new one carries anything on. v1 directs such an exit as it directs a played result, so the call takes S4's re-entered and changed-winner shapes. A status that changes is refreshed on the arrivals the first entry sent on (refreshArrivals), and an arrival records that status only beside a double exit's produced exit, where the target carries an exit and the call is v1's. Stay v1's: a loser the new exit carries across their link, a stored exit that carried (provenance or a carried status in a target), and a DEFAULTED underincompleteAssignmentsOnDefault.A double exit given a winner (the
winnerroute, a single exit or a played result) is v1's unwind followed by a first direction: v1 takes back what the double exit sent on as its clear does (removeDoubleExit, the path to the final written back to be played), then writes the result and directs it as a played result, so the winner arrives in the next matchUp the unwind has just left to be played. It is owned where that unwind is the plain one: the produced exit pending (not awarded), and its seats as the clear's unwind takes them back. Beside loser links the unwind withdraws the BYEs the double exit placed (its own loser seat and the one its produced exit left unfillable), as the clear does, and the direction then places the loser on their own seat, where the BYE stood: a plain arrival, carrying nothing, unseeded, behind a link with no condition. The notices follow v1's buffer: each matchUp at its last emission, so the next matchUp comes after the call's own result, named for the winner's arrival (assignMatchUpDrawPosition), while the in-context notices keep the order of the last score write of each matchUp; each structure's assignments are announced once, where the call first touches them (the seat the unwind visits), with the event and tournament of the loser's placement there (CURTIS: the Play Off's visit first, then the consolation's). A produced exit already awarded is released by the unwind as the clear releases it (the awardee's position taken back out of the round they went on to, S7), and the winner then arrives as above. An award made through a BYE beside it is released the same way; behind a loser link the double exit's own seat then stood in a double BYE (the paired matchUp's BYE loser beside it) that had sent the seat's own position on, so the loser, placed on the seat the unwind freed, goes on through the standing BYE into the matchUp still holding their position, which v1 announces as the loser's arrival there (assignMatchUpDrawPosition, with the event) and stamps: where the unwind withdrew that matchUp's BYE, or where it is the structure's last round (COMPASS's West: a BYE still, by the other standing BYE), or where it is a BYE still and the loser goes on through each BYE after it to the structure's last round, every matchUp passed announced and stamped the same way (COMPASS / OLYMPIC / FIRST_ROUND_LOSER_CONSOLATION 9 of 16: West's first round, West 2/2, West 3/1), or through each BYE to the passage's landing (C16,unwoundLanding): underdoubleExitPropagateBye: falsethe double exit's produced exit had been sent past those BYEs and stood pending where it landed, the unwind writes that landing back to be played with the carrier's position standing in it (unwoundPassage), and the loser arrives there, announced as above; the landing is read off the unwind's own ops, not the stored view, which still shows the carry (FIRST_ROUND_LOSER_CONSOLATION 11 of 16, census w2 9100153: Consolation 1/2, 2/1, into 3/1). Stay v1's: a convergence the unwind dissolves (the winner would be awarded the re-derived pending exit), a loser the new result would carry, a BYE that had gone on further than the next matchUp (FMLC's second round), and every seat shape the clear leaves to v1.A double exit asked for again (the
nooproute: the status it already holds, and no winner) is satisfied, not repeated: v1 writes, stamps and announces nothing, whatever score the call carries, and returns success (attemptToSetMatchUpStatus'salreadyInRequestedDoubleExit). v2 plans it as no ops, whatever the double exit sent on (BYEs on loser seats, a produced exit awarded on). The differential therefore predicts no notices for an empty plan, including withupdateInContextMatchUpsubscribed; it does not infer an announcement from the request alone.A result turned into a double exit (the
completed-to-double-exitroute: a played result, a WALKOVER or a DEFAULTED entered again as a DOUBLE_WALKOVER or DOUBLE_DEFAULT) is v1'sremoveDirectedParticipantsfollowed by a fresh double exit: the winner's position comes out of the next matchUp and the loser out of the seat their link fed, then the double exit is written and produces as on a matchUp holding no result. v2 composes the two plans it already has. S4's removal is planned on the draw as the call found it; the removal and the matchUp left with no result are then folded into the working view (§ 3.2), which is read again as a view of its own on the call's one hydration (RebuildView: the structural index re-indexed where the ops touched it), and S5's double exit is planned there. The write is the route's: a DOUBLE_WALKOVER blanks the score, a DOUBLE_DEFAULT keeps it (CA, 2026-10-02). The next matchUp is announced at the produced exit's score write (modifyMatchUpScore, with its event), not as the removal; a loser's matchUp recoded and then given a BYE, at the BYE (setMatchUpStatusBye); and each in-context notice at the matchUp's first score write. Stay v1's: a result in a group (its tally), in a WIN_RATIO structure, or carrying side provenance or an exit; a removal S4 leaves to v1 (a FIRST_MATCHUP link, a winner gone on, a loser who has played on or carried their exit across the link); and a double exit S5 leaves to v1 on the draw the removal leaves.A played result relabelled an exit its loser carries (the same winner, under
propagateExitStatus) directs nothing again: the winner already stands in the next matchUp and the loser on the seat their link fed. v1 carries the exit to the loser where they stand, as a fresh entry carries it: the loser's matchUp is written the carried status, awarded to the side opposite, with the carry's provenance (S5'scarriedOps), and its structure is stamped by that matchUp's notice, though nobody is placed in it. Planned on a fresh carry's terms, the seat held by the loser rather than free (relabelCarryReason). Stay v1's: the other side given the exit (its new loser carrying it), an exit withdrawn by a relabel (F2), and a carry meeting an exit already there.The reverse, an exit its loser carried relabelled a played result for the same winner (F2), takes the carry back: v1 writes the result, and the loser's matchUp is to be played again, with no winner, its carry provenance gone, its score as it was and its
scoredTimetaken by thereconcileScoredTimespass, under whose name it is announced (announcedAs; that pass announces no in-context matchUp). Planned where the carry is all that matchUp holds: this matchUp's provenance alone, nobody awarded it and gone on, and no loser link out of it (withdrawnReason). Stay v1's: a withdrawal the carry converged in (the matchUp re-derives to the exit kept), and a carry the loser took further.A single exit relabelled where its winner already stands (the
apply-valuesroute: the same winner, the winner's downstream active) is written as the route writes a played result (applyMatchUpValues: a WALKOVER's score blanked,scoredTimekept), and nothing is directed again. UnderpropagateExitStatus, with a loser link, the carry follows the label where the loser stands, as v1'srelabelWithoutDirectionsettles it: a played result relabelled an exit carries it onto the loser's matchUp as a fresh carry lands (the opponent standing there awarded it and sent on, as above); an exit relabelled a played result takes the carry back (the loser's matchUp to be played, announcedreconcileScoredTimes), and the opponent it had been awarded to comes back out of the matchUp they went on into (releaseAdvancedDrawPosition, with the event); one exit relabelled the other rewrites the carry where it stands (its status and the carrier's entry, the awardee re-announced where they stand); and the same exit entered again writes the matchUp alone, the carry as it was (on thewinnerroute too). Planned where the loser's matchUp holds nothing, or this matchUp's carry alone (loserMatchUpCarryHeld: awarded to the side opposite the carrier, this matchUp's entry its only provenance, no loser link out of it, nothing played on from it) and the awardee stands in a clean next matchUp or nowhere yet. A swap over an exit (the other side winning, withallowChangePropagation) is the swap above with the exit's write, and the same carry rule on the seat the old loser held, relabelled to the new loser: a played result swapped to an exit carries it there, one exit swapped to the other rewrites the carry where it stands, the same exit swapped to the other side leaves it (the entry is the seat's), and with no propagation the relabel and the write alone. Stay v1's: a carry the awardee or the carrier has played on from, a carry that converged or was carried past, a loser kept out of a feed, a DEFAULTED underincompleteAssignmentsOnDefault, a swap away from a carried exit (its withdrawal from the seat the new loser takes), and a swap whose seat holds anything but this matchUp's own carry. -
differential: v2 plans the whole call before v1 runs, then checks v1's result against it, and a disagreement throwsOutcomePipelineDivergencenaming the matchUp and both answers. The plan covers the refusal, the route, the write on the matchUp, the winner's direction, the loser's destination (including the propagated BYE for a loser an FMLC feed keeps out), the exit a loser carries, the exit a double exit produces, two exits converging, the swap, a decider's settlement, TEAM auto-calc and the direction of a dual its lines decide, and an exit that meets a BYE (none may be left labelled an exit beside it). A refusal v1 raises at the apply stage, where v2 does not reach (APPLY_STAGE_CODES:ERR_FORCED, andERR_MISSING_ASSIGNMENTS, a manual-scoring line's or a line's given a winner with no line-up assigned, deferred only where v2 abstains from the call: v1 raising it for a call v2 has a complete plan for is a divergence; the status checks a write makes are v2's own rows since S7, rows 6, 24 and 28; an assigned or occupied drawPosition inside the exit cascade is not one since S7: v1 no longer raises either after its first write, so one raised there is a divergence), is recorded as deferred rather than a divergence; so is a step v2 does not yet plan, such as a relabel whose loser stands past a BYE, or an exit carried into a swap.getDifferentialTally()counts compared and deferred decisions by route.
OUTCOME_PIPELINE=differential vitest run is the gate. It runs in CI for pull requests into master
and on master itself — every checkpoint — and nowhere else, so a test added since the last checkpoint
has never run under it until then: run OUTCOME_PIPELINE=differential TZ=UTC npx vitest run locally
before opening one (a plain green suite predicts nothing about it). Since 7.9.0 the view reads a
BYE-holder occupant's carry where it was written, a round on, so a withdrawn BYE's convergence is
planned as v1 writes it; and the exit-beside-a-BYE invariant holds under either doubleExitPropagateBye
setting. An exit arriving at a BYE in its structure's last round meets the exit held beside the BYE that fed
it, and v2 plans the two converging, as v1's settle step converges them (census run-17 baseline, DOUBLE_ELIMINATION
8/5 under doubleExitPropagateBye: false).
A carry past a BYE is recorded beside the BYE, in every round and in either entry order (F2, census A1, 2026-10-17). A participant carrying their own walkover or default into a seat beside a BYE goes through it, and v1 writes their carry entry (the exit and the matchUp it came from) on the side of the BYE matchUp they passed, as well as where they land. It does so whether the carrier was seated first and the BYE arrived after them, or the BYE stood there first; before this, the BYE-first order wrote the entry only in a structure's last round, so the same results entered in the two orders left two draws. v2 reads that entry on the BYE matchUp as an exit standing there, as it reads any carried entry, and plans a convergence with it when an arriving exit meets it. A BYE matchUp written before this, BYE first and outside the last round, holds only the BYE claim; for it v2 still reads the carry where the carrier landed, a round on. One carry counts once: an entry where the carrier landed that names an origin the BYE matchUp already records is not read a second time. An entry left beside a BYE whose carrier's seat has since gone to a BYE, because a correction made the carrier's origin a double exit, is not a held exit, and the settle step does not send it on; only that double exit's produced exit travels from there.
What a divergence leaves behind: nothing. An error changes nothing (2026-10-18; a refused call
stores none of a draw's missing edges either, § 6), and a divergence is an error raised after v1 has
written: v2 plans and never writes, v1 runs and writes, and only then does the comparison throw. So
before v1 runs, differential mode captures what the call can touch (the tournament record, the draw
and the event), the notice buffer and the mutation flag, and before the divergence leaves
setMatchUpStatus it writes them back into the same objects. The record is then exactly as it was
before the call, on every path:
- with or without
rollbackOnError, directly or insideexecutionQueue, and on the async engine; - the result is
{ error }carrying the divergence message, and nothing is notified; - the record is not stamped as modified (a state provider without the optional
setMutationStatushas its flag cleared instead, as a rollback clears it); - under
devContextthe divergence is rethrown, over the same unchanged record.
Pinned by divergenceLeavesBehind.test.ts. The capture is taken only in differential mode;
v1 and v2 take none. A divergence is still a failing signal, not a result to build on: the
suite's rethrowing provider fails the test, and the exit-propagation census records it as
NO_EXCEPTION_ESCAPES. Inside a bulkMatchUpStatusUpdate, the outcomes applied before the one
that diverged stay written unless the call asked for rollbackOnError, the same as for any refusal
a later outcome meets (§ 8).
A TEAM line is owned in two shapes (S7): a line's result that leaves its dual undecided, and one that decides it.
The line's result is any first result with a winner: scored, a winner alone (no score), or a single exit (WALKOVER,
DEFAULTED, RETIRED with its score), each counted for its winner in the dual's tally. A line's double exit
(DOUBLE_WALKOVER, DOUBLE_DEFAULT) is written as it stands (only-score): it counts for neither side, the dual is tallied
without it, and nothing is produced or carried (a line's targets are its dual's; v1's doubleExitAdvancement does not
run for it). v1 writes the line (as
any result: modifyMatchUpScore, its scoredTime), then updateTieMatchUpScore writes the dual:
- it ensures the dual's side line-ups;
- it copies the resolved tieFormat onto the dual;
- it tallies the dual's score from its lines;
- it derives the dual's status: COMPLETED with a winner, else IN_PROGRESS where
isActiveMatchUpreads it active, else TO_BE_PLAYED.
v2 plans the line's write and the dual's (setMatchUpResult with dualTally, no scoredTime):
- the projected score and status;
- the sides
ensuredDualSidesgives (the ruleensureSideLineUpswrites by, one function) and the copied tieFormat, each only where it changes the stored value. On a dual's first line both change, and the dual goes from TO_BE_PLAYED to IN_PROGRESS; a record that stored no tieFormat of its own takes it on the same way.
Both are announced as v1 announces them: each matchUp's modifyMatchUp and its in-context notice, the line's first. The
call returns the dual's write as tieMatchUpResult, as v1's directParticipants does. A line directs nothing of its
own: its targets are its dual's.
A line played on a dual already decided (the remaining lines of a COMPLETED dual) is written the same way: the line,
then the dual's tally, the dual staying COMPLETED and keeping its winner. Nothing is directed or carried again, since
the dual's winner does not change; the next dual is left as it is, played or not. A dual walked over with its lines
already at the value goal's edge is written the same way when a line takes it there (COMPLETED, its winner kept).
A line's double exit on a dual decided by its own call (an exit, or a winner alone) that directed its winner or its
loser (a next dual, a loser link), whose lines then project no winner, is not this shape: it names no winner, so it is not routed line-score, and v1 takes the dual's winner back out
of the next dual before it writes the line (attemptToSetMatchUpStatus's scoreModification). The planners abstain
(team). Where the dual directed nobody (a round robin's, a final's) the line and the tally are all, and are planned.
A line that decides its dual makes the dual's own call: v1's directParticipants writes the projected winner and
score onto the dual (COMPLETED) and directs the dual as any winner is directed. v2 plans that call as it plans any call,
from a view of the dual taken on the line's own index (no hydration): routed, written and directed by the same
functions a singles result is (decidedDualCall). Its write is the dual's tally (no status codes, no scoredTime, as
updateTieMatchUpScore writes it). Once the winner's position has joined the next dual, the winning team's line-up is
carried onto its side there (setSideLineUp, v1's propagateLineUp):
- the line-up the decided dual's winning side holds, without substitutions (
removeLineUpSubstitutions, which regroups each player's assignments); - on the side v1 reckons by roundPosition: a feed round's advancing team, or one advanced by position, is side 2.
The next dual is announced by directWinner, and the call's tieMatchUpResult carries the dual's winner. A final
carries nothing on.
Where a loser link sends the losing team on (a consolation, a compass direction), the loser is placed as any loser is,
and the losing team's line-up is carried onto its side of the dual it lands in (setSideLineUp, v1's
propagateLoserLineUp):
- the line-up the decided dual's losing side held before the line's write, every assignment kept (the winner's drops any that names no participant), without substitutions;
- on side
2 - (roundPosition % 2)of a first-round dual, by the decided dual's roundPosition; on side 1 of a later round's.
That dual is announced by directLoser. A loser kept out of a first-match feed (a BYE takes the seat) carries nothing.
A loser seated opposite a BYE carries its line-up onto the BYE matchUp as above and goes on through it into the dual
beyond, whose side takes the team's line-up as the draw holds it (setSideLineUp, v1's updateSideLineUp at the
loser's assignment), on the side holding the loser's drawPosition, announced updateSidLineUp before the BYE matchUp's
directLoser. A team the draw holds no line-up for takes none there, as v1 writes it.
A dual's own call given a winner (scored or not, or a single exit) is written and directed as any winner is
(directParticipants): the result with its status codes and scoredTime, the winner placed in the next dual (announced
assignMatchUpDrawPosition). Before the result v1 writes the dual's sides (ensureSideLineUps): setMatchUpResult
carries them as ensuredSides, where they change, and the call returns no tieMatchUpResult. Nothing is carried from
the dual: its winner's next dual takes no line-up. Where a loser link places the losing team, its assignment writes the
team's line-up as the draw holds it on its side of each dual it reaches (setSideLineUp, updateSideLineUp, announced
updateSidLineUp): past a BYE the dual beyond first, then the BYE matchUp. The loser's own dual is announced with no
event (assignTeamLineUp hands updateSideLineUp none).
A dual's own exit carried across its loser link (propagateExitStatus) is written on the dual it lands on as any
carried exit is, by that dual's own call (setMatchUpState), whose ensureSideLineUps first writes its sides with the
team arrived: the carried setMatchUpResult takes them as ensuredSides. That write comes after the team's line-up is
written there, so the dual is announced as the carried result is (modifyMatchUpScore, with its event). Past a BYE
(RULE 1, and its passage) the dual it lands on is the one beyond: the BYE dual keeps its BYE and takes the team's
line-up from the assignment, then records the carry beside its BYE, so it is announced as the carry is
(progressExitStatus, with its event), and the dual beyond is written with its sides ensured. Planned where the carry
lands on one dual, both its sides holding their drawPositions; a carry that goes on past the dual it lands on (its own
loser link, as COMPASS's West: the carrier placed again, whose assignment writes the line-up there), or onto a
DOUBLE_ELIMINATION losers' dual its arrival half places (hydrated unnumbered, read numbered by v1 after the arrival)
stays v1's.
A dual's own double exit (DOUBLE_WALKOVER or DOUBLE_DEFAULT, on a dual still to be played) is written and advanced
as any double exit is (doubleExitAdvancement): the exit it produces in the next dual, awarded to the side opposite or
waiting for it, and the BYEs on the seats its loser links feed. Its sides are written first, as for a winner
(ensuredSides). A double exit over a dual in progress stays v1's (§ 7.1's exit rules).
A dual's own call on a dual already decided (by its lines or by its own call) is planned as any decided matchUp's
is: its winner entered again stands where it stood, a changed winner is re-directed. Its sides are written first
(ensuredSides). A winner's assignment writes the team's line-up, as the draw holds it, on its side of the next dual
wherever that dual already sides its drawPosition (assignTeamLineUp → updateSideLineUp, a setSideLineUp announced
updateSidLineUp with no event): so a winner entered again replaces the line-up its deciding line carried there, and a
first entry writes none. A changed winner over a dual's own single exit stays v1's (settle).
A line's result removed, or a line cleared (remove-directed, clear-score), or corrected (winner over a
stored winner, either side), is written as a first result is: the line rewritten, then the dual's tally re-read from its remaining lines, where the dual's winner does not change (a dual
still undecided, or decided by its other lines) and the dual still holds a line's result. The line directs nothing, so
nothing is taken back from the next dual, and a correction is neither a re-entered nor a changed winner. v1 clears it through removeDirectedParticipants, which returns no
tieMatchUpResult, and neither does v2 (dualTally.unreturned).
A dual's own call that disables or enables auto-calc writes disableAutoCalc on the dual, or removes it, as v1's
handleTeamAutoCalc does (through setFirstClassOrExtension, a field of the dual's setMatchUpResult). Enabling also
takes the winner and score the dual's lines project (generateTieMatchUpScore), whatever winner the call names.
Not planned (they stayed v1's until batch 4b, which reads each off v1's whole write: "Recorded calls (batch 4b)", § 7.2):
- a dual's own call that enables auto-calc whose lines project no winner, a dual's exit carried on past the dual it reaches, through a BYE or onto a losers' dual half placed, a call on a dual holding no winner that is neither to be played nor in progress (a double exit), and a dual's own double exit once a line is played;
- a decided dual whose losing side held no line-up: v1 carries nothing, and the sides the loser's assignment wrote
(
updateSideLineUp, from the draw's line-ups) stand; - a removal or correction that un-decides its dual through the removal or correction route, and a line DEFAULTED under
a scoring policy's process codes (v1 writes the codes on the line,
exitReason); - a removal that leaves the dual holding no line's result:
updateTieMatchUpScoreremoves the dual's score, and its tieFormat where it equals the inherited one; - auto-calc off;
- a line's double exit that un-decides a dual decided by its own call (above);
- a line given a winner whose own sides do not both hold a participant (no line-up assigned): v1 refuses it
ERR_MISSING_ASSIGNMENTSbefore any write (directParticipants,attemptToModifyScore'svalidToScore, which lets through a scoring policy that does not require participants, and one side assigned where the line is ad hoc or a single exit), and v2 leaves the call, and the refusal, to v1; - a REPORTED score source (v1 returns before any tally).
A line that un-decides its dual (S7, the line-score route: a decided dual whose lines, with this one in place,
project no winner) is planned as v1 writes it (scoreModification): the dual's direction taken back first
(removeDirectedParticipants through the line: the winner's position out of the next dual, announced first), then the
line, then the dual's tally. The dual's part is the dual's own removal, planned from a view of the dual whose request is
its projected score with no winner (undecidedDualCall, routed remove-directed, vetted as any removal), and it returns
no tieMatchUpResult (dualTally.unreturned). The line may be its own single exit (WALKOVER, DEFAULTED or RETIRED with
a winner, as requested, on a line to be played: lineExitReason), which v1 writes as any line result, directing nothing
of the draw by it; and the dual may have been decided by its own single exit, which the tally overwrites as it leaves the
dual, in progress or to be played, the winner removed (clearedSingleExit for the dual's plan). In a WIN_RATIO structure
the dual's removal a line makes is not walled: v1's own removal (removeDirected) reports the playoff structures it
reaches (connectedStructures, a flag on the result) and v2 does not read them, but the line's path
(scoreModification) reports nothing and moves nobody in a positioned playoff, so the group's tally is re-read and the
playoff stands as v1 leaves it (S7, O12).
A dual in a round robin, and a line of one (S7), take their group's tally, as v1's updateTallyIfNeeded writes it
from the dual's score write: the group's duals alone (matchUpTypes: [TEAM]), tallied under the one dual tally format
(DUAL_TALLY_FORMAT), with the dual's result in place. A line runs no tally of its own: its group is its dual's, read off
the dual, since a line is hydrated in the container with no group (hydration OPEN-14, which is not changed); the dual is
tallied with the line's result in place among its lines, its score as hydration reads it (annotateScoreSets: a
tiebreak-only set read 1-0). A line that decides its dual hands the dual's own plan the same group.
A carry arriving after an unwind can announce a matchUp that the unwind already wrote quietly. The carry
recorded beside its BYE announces progressExitStatus, with the tournament and event, even though the earlier
score write announced neither (mergeSideExitProvenance.announcedAs). A later result write supersedes that
name again. The measured supported composition ends with this carry announcement; later writes to the same
matchUp require a separate captured ordering contract before extension. Deferred in-context payloads
independently follow the last score write: its captured tournament
determines whether participants are hydrated, so a quiet earlier write cannot strip a later evented result's
payload. The FIC_TO_SF 16/11 sequence Main 1/5 winner(2), Main 2/3 DOUBLE_WALKOVER, then Main 2/3 WALKOVER(1)
carried under policy off captures both contracts. Whole records, ordered notice payloads and results agree
under v1, v2 and subscribed differential; the existing refusal boundary is unchanged.
An unplaced deeper loser seat may be empty beside a standing propagated BYE (S7). Its exact original assignment
has neither occupant, qualifier, BYE nor propagation marker, and the canonical indexed activity read certifies it
inactive. The opposite raw assignment remains a marked BYE; its identity is preserved, not claimed by this unwind.
In the bounded first-round shape the empty seat already stands in the clean second-round matchUp beside an
independent position, and appears nowhere further; the opposite BYE appears nowhere later. The whole structure
holds no other result, exit provenance or BYE, has no outgoing link, and its winner edges remain inside it and move
forward. Clearing the empty assignment preserves that structural BYE advancement (advancedByOpponentsBye):
only the existing exact-seat withdrawal/assignment notice is planned, with no target result or new callback.
Other topology, active seats, orphan markers and conditioned unplaced links remain v1's.
A clear can withdraw a given award while preserving an independent pending foreign exit (S7). In the captured FIC_TO_SF 16/11 policy-off shape, the re-derived BYE also releases an indirect produced reservation: its successor release precedes the onward reset, and no stale relay advance follows. The complete unwind owns these two programs together; either program alone remains refused. Eight clear variants agree with v1 on whole records and ordered notices. The 32 winner corrections keep their existing fallback boundary.
An indirect reservation can also unwind beside an ordinary produced award (S7). This clear keeps the certified three-level path in one structure: the double exit, its award to the paired feeder’s winner, and the clean terminal matchUp holding that exact awardee. The retained ordinary-award descriptor binds the paired feeder’s winner edge, participant and position to the literal arrival origin; source and paired results remain scoreless and code-free. Only the source’s own validated two-position indirect reset program is admitted. The pending foreign-award projection still requires its companion indirect program; every other partial combination refuses. Existing ops release the successor before resetting the relay and remove the ordinary award’s origin through a real score write. The minimal shape announces twelve notices; the captured shape retaining another unfillable origin announces thirteen, using the existing late one-position relay advancement.
A bare winner can follow that same certified ordinary-award removal (S7). With no explicit status, score, format, schedule or notes, the source becomes COMPLETED. The shared removal program is folded into a working view before planning both directions; its actual own-level reset supplies the onward positions. A plain, unseeded loser arrives on the freed seat beside the retained foreign exit, with no conditioned link, opposite BYE or reservation. The real assignment awards the relay while preserving its absent score and exact foreign origin, then places that participant onward beside the reset's legitimate occupant. The source winner uses its re-planned ordinary placement. Successor release remains before the source score write; the three actual assignment notices precede the unchanged actual-score callbacks. The separate thirteen-notice shape retains its existing late one-position advancement. Explicit WALKOVER/DEFAULTED winner requests still refuse this composition; they require a distinct carried-convergence program. No new op field or callback is introduced.
An explicit WALKOVER or DEFAULTED winner can carry into that indirect relay (S7). The same certified ordinary-award removal is folded before reading either direction. Its loser meets the retained foreign single while that relay is pending, with no temporary winner. A separate pending-convergence reader binds the actual slot, original foreign origin and same-level onward reset. The relay becomes DOUBLE_DEFAULT only when both exits are defaults; otherwise it becomes DOUBLE_WALKOVER. Both forms receive the actual blank score of this captured writer and preserve the foreign-side codes while recording the new source. The resulting exit is awarded to the real paired feeder's winner already in the onward matchUp, using canonical source-relative sibling geometry and the existing produced-score/advance operations. That paired feeder's own provenance stays intact; only its literal current status is the new paired origin. The actual source, relay and onward writers give five deferred score callbacks together with the unwind, with fourteen ordered notices, or fifteen when the independent old one-position late advance remains. No operation field, eligibility flag, artificial intermediate award or synthetic callback is added.
A given winner over an FMLC round-two double exit can leave its loser out of the FIRST_MATCHUP feed (S7). Where that loser's qualifying win makes v1 restore the propagated BYE that the source's own unwind withdrew, the plan binds the exact own-level withdrawal and folds the complete unwind before checking the freed seat. The restored BYE keeps the original home positions. If an actual participant stood opposite it, that same program must have released the participant from the clean next matchUp; the complete folded view must still hold that participant at home and leave the next matchUp empty. Existing BYE, position and timestamp ops then restore the reservation and its real advancement. Deferred unwind announcements run before this restoration; rederived levels remain excluded. No advancement is invented when no opponent is present. A later restored BYE supersedes its earlier withdrawal notice; a later real advancement restores tournament identity after the quiet release, while retaining its absent event. Reverse operation order retains the later withdrawal or release. The captured program uses one actual source writer. A distinct program below preserves the reservation when both possible source participants already have qualifying wins. An explicit exit still carried by the existing settle boundary remains outside this restoration program.
A standing FIRST_MATCHUP reservation stays untouched when a round-two FMLC double exit is given a
winner (S7). v1's early reservationStands check calls firstRoundFeedersWon and skips the loser-target
block; it does not reach byeSeatStands or withdraw the BYE in this shape. The canonical first-round
filter and qualifying-win predicate are shared unchanged by v1 and the planner. COMPLETED without a
score still qualifies; the canonical query retains its existing empty-selection behavior.
The planner separately binds both actual source participants to distinct first-round winners, the
canonical marked BYE seat and its existing advance in a different structure. Its actual own-seat
program is empty, supplied before any withdrawal context is built, so the marker remains standing
through the complete early unwind. Every deeper level must have no loser seat; rederived, pending
removal and walked programs refuse. All actual resets, result writes, winner placement and deferred
announcements remain on the source structure. The entire consolation structure, including its
assignments and timestamps, stays unchanged. No BYE assignment, reannouncement, advancement or score
callback is invented there. Clear and double-exit correction routes receive no such program; TEAM,
group and uncertified custom geometry remain outside this bounded certificate. Independent material
controls also retain the neighboring restoration's actual BYE write and timestamp change, so the two
programs cannot become equivalent through a shared-predicate error. No operation or view field is added.
A produced exit can supersede its own stale relay after a given-winner unwind (S7). The original
loser home holds this source's propagated BYE beside a foreign double exit's origin. Its actual
own-seat program withdraws that BYE, and the rebuilt home holds the foreign single exit pending,
without a winner. The arriving carried WALKOVER or DEFAULTED genuinely converges with that opposite
origin. A source-bound Convergence program certifies the actual pending landing, canonical side,
collapsed status and projected codes; it carries the measured blank relay score, including for a
DOUBLE_DEFAULT. The generic convergence reader still requires its existing awarded-winner shape.
The produced target is a canonical nonfeed next matchUp with no positions, winner, reason codes,
BYE or loser link. Its sole origin stands on the produced arrival side and exactly matches the
foreign origin retained at the home, with both canonical producer edges bound. Original and folded
target status, positions, provenance, winner, score, codes and schedule agree. The undecided paired
feeder can hold positions; it has not delivered a winner into this empty target.
The existing convergence and produced-target operations write the real double exit, then replace the
target's same-side origin with this landing's produced exit. The target gains no scored time and
nothing advances or converges beyond it. The same actual program prevents only its own-level late
relay-copy reset from being generated, tied to the actual clear operation and exact home/target IDs;
other late reconciliation paths retain their order. Both canonical produced sides are captured,
with two legacy writers, thirteen ordered notices and five callbacks in v1. Independent controls
pin the relay's blank score, target origin and absent scored time, paired feeder and untouched onward
matchUp. Bare and clear requests receive no new program. TEAM, conditioned links and uncertified
origins or geometry remain outside this certificate. No operation or view field is added.
7.2 The plan as ops (S1)
A quiet produced-award placement can put back the exact position a preceding release removed. Its final notice is then the assignment's, while retaining its quiet identity. The notice projection derives this from the actual released position and later position-write data; a different position, withdrawal or BYE advance does not erase the release. Existing plain-placement precedence is unchanged.
A certified clear's position removal can withdraw an award while retaining the independent pending foreign exit
(setMatchUpDrawPositions.withdrawsPendingAward). The reducer removes only winningSide;
removedDrawPosition already deletes the score, and a separate setSideExitProvenance keeps the exact surviving
origin. Status and raw codes remain as stored and certified. This position writer supplies no actual-score callback;
its announcesContext: false matches the captured removal notice's absent event and tournament identity. It is not a
named settle score write. The clear-only per-level projection is separate from dissolved-convergence derivation, so
it does not change the unwind's unfillable-BYE reset index or create a settle reannouncement. The indirect produced
reservation's successor release precedes its onward reset, and that complete reset program is not followed by a stale
relay advance. The complete unwind admits this pending-award projection only with its validated indirect relay program.
An indirect program without that projection requires the separate ordinary-award clear certificate above; every
other partial combination refuses. Both absent preserves existing unwind paths. Coupling and late-write
suppression use the same actual level program, so another level's reset cannot satisfy the proof.
Winner corrections keep their prior fallback boundary.
v2 states a call's writes as ops, a closed vocabulary folded by one reducer (outcome/ops.ts) into a stored-shape
draw. The overlay, the differential shadow apply and, from S2, apply itself all use the same reducer, so what a plan
says and what lands are one thing. The reducer decides nothing and refuses nothing.
| op | what it writes |
|---|---|
setMatchUpResult | the matchUp's status, winner, score (as the call gave it, or blanked), a new format, status codes, and schedule.scoredTime by v1's rule: captured the first time the matchUp is scored, kept on corrections, removed with the score; left as it is where v1 writes the result outside setMatchUpState (stampsScoredTime: false: a double exit's produced exit); a TEAM dual's own call first writes the sides ensureSideLineUps gives (ensuredSides), as does a dual's exit carried onto the dual its losing team reaches; a dual's own call that disables or enables auto-calc writes or removes disableAutoCalc; a produced exit landed past a BYE-held matchUp beyond the first is announced with its tournament but read in context without it (inContextBare, v1's carryExitOnward); a TEAM line's write of its dual (dualTally) is returned as tieMatchUpResult but for a removal (unreturned); the call's notes, on its own matchUp (v1's addNotes inside modifyMatchUpScore; S7, notesReason); restoresNoticeIdentity on the last actual score writer explicitly restores its event/tournament envelope after a quiet unwind, retaining its deferred callback; retainedExitPlanned certifies a retained origin and its fully planned forward consequences independently of the notice writer; announcedAs also names a produced exit awarded on placement (assignMatchUpDrawPosition, without an in-context notice or scored-time stamp) and a stale relay copy reset by withdrawProducedExits; announcedAs: advanceWinner names a final empty-position reservation, preserving its earlier actual score callback without creating another |
setMatchUpDrawPositions | the positions placed in a matchUp, as v1 stores them: numbers, ascending (a winner's position joining the next matchUp, or taken back out of it: removedDrawPosition, whose result goes with the participant, as removeSubsequentRoundsParticipant takes it; with placedDrawPosition too when one write replaces a changed winner; advancesThroughBye for a position a double exit's BYE sends on, announced as advanceWinner and written with no score, as assignDrawPositionBye writes it (with announcesEvent where the advance is reconcileByeAdvancements' settle write, which names the event: a seat an unwind freed beside a standing BYE, S6 tail); releasedDrawPosition for a position taken back out of the matchUp it was sent on into, announced as releaseAdvancedDrawPosition, the score left as it is: a participant awarded a carried exit when a relabel withdraws the carry (with the event), or the position a withdrawn BYE had advanced that now leaves the matchUp empty (announcesContext: false, S6 tail); with clearsPendingExit beside withdrawnByePosition where the withdrawn BYE had carried the position into the passage's landing, the own carry pending there: the pending exit goes with the position, as v1's updateMatchUpStatusAfterRemoval takes it (to be played, provenance removed; a pending exit holds no winner, score or codes to take), announced removeDrawPosition-<that BYE's drawPosition> whether or not a position stays (S7); rederivesCodes beside placedDrawPosition where the placement seats a loser beside a carried exit that decides the matchUp for them, re-derived to it by the unwind: v1's assignDrawPosition re-derives its codes ([]) with the assignment and announces the matchUp as the assignment, with no in-context notice (S7, carrierSentOn)); withdrawsProducedExit resets an awarded produced relay copy to be played, removes its winner and provenance, and keeps its legitimate occupant and blank score (with withdrawnByePosition for the unwind's notice); withdrawsPendingAward removes only the winner of a certified pending foreign award, retaining its status, raw codes and separately planned provenance |
assignPosition | a participant on a structure's stored assignment for a drawPosition (a loser fed across a link) |
exchangeDrawPositions | a swap's relabel in a later round of its structure: the old winner's and the old loser's positions exchanged and sorted, a decided matchUp's winner carried across the re-sort with its score and side facts (v1's exchangeMatchUpPositions, the same function) |
relabelPosition | a swap's relabel downstream: a seat's occupant changes identity (the old winner's becomes the old loser's and the reverse), nothing else, announced and stamped by nothing, as v1's swapWinnerLoser writes it |
clearPosition | a structure's stored assignment for a drawPosition emptied, and the participant's seed entry there removed (a loser taken back out of the structure a link placed them in) |
setMatchUpStatusCodes | a matchUp's status codes, re-derived from its provenance (the matchUp a loser is taken back out of) |
mergeSideExitProvenance | a side's exit provenance merged into what a matchUp carries, through v1's mergeSideExitProvenance (a carried exit's entry on the side its carrier arrived at); announcedAs: 'progressExitStatus' marks a carry recorded beside a BYE, whose own evented notice supersedes any earlier quiet result notice |
setSideExitProvenance | a matchUp's exit provenance replaced by what an unwind leaves, through v1's setSideExitProvenance: absent, the field is removed (a cleared double exit's produced exit, its origin withdrawn) |
withdrawBye | an unwind's removeDirectedBye at a seat: the stored assignment's BYE and its propagation marker removed, where one stands; the structure's assignments announced with neither event nor tournament either way, but not at all with announcesAssignments: false (a BYE v1's round-1 loser cascade takes back, drawPositionRemovals, S6 tail) |
clearMatchUpBye | the matchUp a withdrawn BYE stood in, to be played again, announced as removeDrawPosition-<drawPosition> with neither event nor tournament; with rederived, re-derived instead to the carried exit standing on its other side (the exit's status, awarded to the side without it, the carrier's provenance kept: a structure's last round, S7); a retained produced exit is pending, so rederived.winningSide is optional and absent for that shape; retainedOnwardMatchUpId binds a converged-copy withdrawal to the exact onward matchUp whose foreign origin is retained; retainedCarriedAward separately certifies an occupied final's retained carrier, live origin and awarded status for a clear or certified plain given-winner arrival, whose reservation geometry is read on the rebuilt view |
announcePositionAssignments | Return-time assignment notice for an ordered BYE service. Its assignBye state op has announcesAssignments: false; parent state folds before children, while children announce before their parent. announcesEvent: false retains the eventless nested call. |
assignBye | a BYE on a structure's stored assignment for a drawPosition, marked byeFromPropagation (a FIRST_MATCHUP reservation; a double exit's loser seats, announcesEvent: false for one its produced exit leaves unfillable) |
setMatchUpBye | the reserved seat's matchUp a BYE, its score and winner removed (v1's setMatchUpStatusBYE) |
setSideLineUp | a team's line-up on its side of the dual it is directed into, as v1 writes it (the winning team's by propagateLineUp, the losing team's by propagateLoserLineUp and, its draw line-up where its assignment lands, on the loser's dual and past a BYE the dual beyond, and a winner entered again on the next dual, by updateSideLineUp, each announced by its writer, the loser's own dual with no event where v1 names none): the dual's sides made, numbered 1 and 2 in order, keeping what each held, and the line-up set on this one |
setMatchUpSchedule | the matchUp's whole stored schedule after the call's schedule is written, as v1's addMatchUpScheduleItems leaves it on a copy of the matchUp (S7: a date, a time, a court, a venue or a court order; any other attribute, or a schedule v1 refuses, stays v1's), written before the result so scoredTime is stamped onto it |
setOrderOfFinish | a TEAM dual's line's place in its collection's finishing order (orderOfFinish), or its removal: planned for each line whose number a line's write changes, after that line's result and before the dual's, as v1's modifyMatchUpScore writes it. A line played to a result (COMPLETED, RETIRED, or DEFAULTED with a scored value) that had no number finishes after the others, never past the lines that can still count; a line that stops counting loses its number and the later lines move up; a score edit or a winner corrected keeps it (v1 takes a corrected result off with its number kept, keepsFinishingOrder); announced as modifyMatchUpScore |
setParticipantResults | a round robin group's, or a one-round ad hoc structure's, tallies on its position assignments, after the call (writeAssignmentResults, v1's own writer); for ad hoc the assignments are first rebuilt, one per participant its matchUps hold, as updateTallyIfNeeded rebuilds them; the tally stamps every top-level structure, as v1's does |
clearMatchUpScoredTime | Delete only a stale schedule.scoredTime after the complete semantic plan. Final cleanup follows stored draw-map order, preserves its schedule object and other fields, stamps the matchUp/top-level structure/draw, and announces reconcileScoredTimes after ordinary and assignment notices without adding an in-context callback. All residual settle predicates must clear. |
replaceMatchUp | RECORDED (CA, 2026-11-16): a stored matchUp's own fields replaced by what v1's double-exit module and settle passes left on v2's working copy; a field they removed is removed. Its updatedAt is the one the copy was stamped with, and the call's stamp ledger is told. A dual's lines (tieMatchUps) are not among its own fields (batch 4b): the dual keeps the lines it holds, and a line that changed has an op of its own |
replaceStructureState | RECORDED: a structure's own fields (its position and seed assignments among them) replaced the same way; its matchUps and child structures are kept, and written by their own ops. A round robin's group is a structure of its own (batch 4b): its tally is among its fields |
replaceDrawState | RECORDED: the draw's own fields replaced the same way; its structures are kept |
announceRecorded | RECORDED: the notices the module and the passes buffered on the working copy, as data and in their order: topic, key, and the payload in v1's key order with the entity it carried left out. Writes nothing; apply raises each again carrying the stored entity |
stampUpdatedAt | one updatedAt per touched entity per call (F2 (i)): the call's captured instant, or the previous stamp + 1 ms when that is already as late |
Recorded cascades (CA, 2026-11-16). A first double exit whose loser seat or produced exit the planners do not
write shape by shape is not handed to v1. v2 folds the call's own write into a copy of the record, runs v1's
double-exit module (doubleExitAdvancement) on that copy as attemptToSetMatchUpStatus runs it after
scoreModification, then v1's settle passes (settleAfterWrite, the one sequence setMatchUpStatus runs on the stored
draw), and returns what changed as the four ops above (outcome/plan/recordedCascade.ts). The copy's writes announce
nothing and stamp nothing outside it (withDraftWrites). Apply leaves the copy's object graph on the stored draw, not only its values (outcome/recording.ts): an object v1 keeps is kept, one object written in two places stays one object, and keys keep v1's order; the working view and the shadow take the values as clones. An entity is recorded where its own fields read differently, a key holding undefined included, or where an object holding them is another (outcome/plan/recordedDiff.ts unchanged): v1 writes a new object where the old one says the same (removeDirectedLoser derives a loser target's status codes afresh, an empty array for the cleared fixture's shared empty one), and the new object is the one stored. The tournaments and topics the copy's writes marked modified are put back as they were found and marked again by apply, before the recorded notices. The plan is then held to the check every plan is: no settle pass has work left on the working view. A recording a predicate still finds work on is dropped whole, and the call is refused where it was before. It is refused, and the call stays v1's, where the module or a pass returns an error, the forward
settle is exhausted, anything outside the draw changes, or a notice is buffered that apply could not raise again. Not
recorded: a matchUp that already holds a result or an exit (v1 removes it first), a round robin group, a TEAM dual or
line, and a call with no captured clock (the cascade recorder; the whole-call recorder takes one, below). The module and the passes stay v1's code, used as a library until v3.
Under differential the same reads are therefore made twice, on the copy and by v1 on the stored draw;
verify:hydrations keeps the copy's out of its ceiling there and reports them apart. Under v2 a recorded call builds the map of its working copy besides the call's own, and the gate allows its worst call that one build more than v1's; the arm's total is held to v1's.
Recorded calls (batch 3). A call the planners abstain from for an exit, a cascade or a loser seat (exit,
cascade, loser) is not handed to v1 either, where it can be read whole. planOutcome (outcome/plan.ts
recordedWhole), once the planners and C27's whole-carry rule have answered, asks for the call's whole write: v2
copies the record and runs on the copy everything setMatchUpStatus does once a call is accepted (runV1, with the
call's own parameters): the draw's missing edges, setMatchUpState and all under it, exit propagation, the settle
passes and the edges' announcement. What that changed in the draw is the whole plan, as the four recorded ops
(outcome/plan/recordedCall.ts; the reading and the diff are the recorded cascade's, outcome/plan/recordedDiff.ts),
with no op before them, and it is the plan planOutcome returns: the one finalizePlan of the call folds it as it
folds any plan. The call returns what v1 returned on the copy, its warnings among them. The copy's writes announce
nothing and stamp nothing outside it, apply leaves the copy's object graph on the stored draw, and the marks are put
back and marked again, as for a recorded cascade. The planners' refusing lines stand as they were, and the abstention
tally counts only what is still v1's. It is asked once per call, of the call's own plan: planOutcome is entered once
per call, and a dual planned inside its line's plan (asDual) is never recorded.
The recording is held to the rule a recorded cascade is, whole or not at all: where a settle predicate still finds work
on what it leaves (predictSettleWork), it is dropped and the plan is the very abstention the planners returned. A call
whose PLANNED ops leave settle work (settle) was not recorded in batch 3 (batch 4a, below, records it). The recording
is not made, and the call stays v1's, for: a TEAM dual or line (batch 3 and 4a; batch 4b, below, records them); a call
with no captured clock; a call that names more than one tournament record. Nor is it asked for where the call is
refused: a refused call has no route, its refusal is its answer, and differential plans it only to set v1's refusal
against v2's. It is discarded where v1's run on the copy returns an error, throws, or stops its forward settle at the
bound (recorded since: batch 5, below); writes anything outside the draw; adds or moves a matchUp or a structure; writes a round robin group's own fields
(batch 3 and 4a; batch 4b, below, carries them); leaves a scored time on a matchUp with no score (the plan's own cleanup
would clear it); changes the call's own parameters (which are put back); buffers a notice apply could not raise again;
or returns a result that holds an object of the copy (batch 4b, below, returns the stored one where that is exact). A
call whose recording v1 refused is then run by v1 on the stored record, so v1 runs twice for it: what a v1 error leaves
written on the stored record today is observable, and only v1's own run leaves it.
v1's writers stay library code until v3: a recorded call is v2's because v2 decides it, applies it and announces it,
and v1 is not asked to write the stored record, but the write it applies is the one v1's code computed. Under
differential v1 therefore runs twice for a recorded call, on the copy and on the stored record; under v2 it runs
once, on the copy, and the call pays for the copy and the diff besides.
A recorded call draws once. v1 draws at random inside some calls: a qualifying final given a winner seats its
qualifier in a main draw qualifier seat picked at random (placeQualifier), and an id v1 mints is drawn too (UUID).
Every such draw is ambient (randomSource(): a seeded call's stream, the configured source or Math.random);
setMatchUpStatus hands v1 no random of the call's own, so there is no other stream to keep. One reader per call
(tools/replayedDraws.ts, made in setMatchUpStatus) stands between v1 and that source for every run v1 makes for the
call: the whole call on a copy (writeOnCopy), the recorded cascade's module and settle on a copy (recordDraws), and
v1 on the stored record where one follows (differential, or a recording refused, dropped or discarded). Each run reads
the call's draws from the first: those an earlier run took are handed back in order, a source that threw throws the
same error again, and the source itself is read only past their end. So v1 on the stored record makes the choices v1
made on the copy, the source is read exactly as often as v1 alone reads it, and what is drawn after the call is what
v1 alone leaves to be drawn, in v1, v2 and differential alike. Under v2 with the recording applied nothing more
is read. Under v1 no copy is made, nothing is kept, and v1 reads the source itself.
The reader is scoped as the call's stream and as the configured source both (withAmbientRandomSource), so it stands
whatever the state provider: one without the call-stream hooks reads the configured source, which is process-wide and
safe to replace here because every run is synchronous (the async engine awaits around setMatchUpStatus, never inside
it). Where a provider hands out a call stream it will not let be replaced, the reader cannot stand: the recorder
refuses before v1 runs on the copy, no recording is made, and the call is v1's, reading the provider's stream itself.
Each run reads through a function of its own, since UUID refuses an id one function mints twice; the ids a recorded
call mints are therefore not entered in the source's own repeat window (refuseRepeatedId), as a composed write's are
not (tools/composeThenWrite.ts).
Recorded calls (batch 4a). The whole-call recording answers five more of the planners' abstentions: a route or a
link they do not plan (route, link), the client's positional codes (status-codes), provenance on the call's
matchUp (provenance), and LEGACY or BRIDGE write mode (write-mode). It is asked for and made as above, under the
same refusals. team, edges, clock, competition, no-record, notes, schedule and tallied are not answered:
a call the planners abstain from for one of them stays v1's (batch 4b, below, answers tallied and team; clock and
edges are answered since: § 7.2, and below). The
planners name the first reason that holds, so a call recorded for one of the five may be one a later reason would have
held too: LEGACY or BRIDGE is asked ahead of a draw stored without its edges, a schedule, notes and a competition
policy, and what v1 does for those on the copy is recorded with the rest of its write, or the recording is discarded by
the recorder's own rules. The scored time those rules read (a matchUp with no result left holding one) is
schedule.scoredTime, where v1 stamps it in every write mode (measured 2026-11-17: LEGACY and BRIDGE write no timeItem
for it, whatever the write-mode row below says).
A call whose PLANNED ops leave settle work is recorded too. recordedWhole asks settles of the ops the planners
return: where a settle predicate finds work on the working view they leave (or they cannot be folded, or they leave a
stale scored time with no stamp ledger to order its cleanup), the call would abstain settle, and its whole write is
asked for instead, under every refusal above. Where the recording is not made, or is dropped, the planners' ops stand
and the call abstains settle as it did. The question costs a planned call no fold: the working view settles folds
the ops into, the settle sites it reads there, or the error the fold meets, are kept by the ops array itself
(outcome/decide.ts settleFolds) and taken by the call's one finalizePlan, which asks the predicates again only
where it appended its scored-time cleanup.
Recorded calls (batch 4b). A recording carries a round robin group's own fields. A group is a structure of its own
inside its container, and a result in it writes the group's tally among the group's fields
(updateAssignmentParticipantResults: each assignment's participantResults). The diff reads every structure of the
draw, a group after its container (outcome/plan/recordedDiff.ts drawStructures), and replaceStructureState names
either: folded, a group is found as a container is, and apply leaves the copy's object graph on it the same way. A run
that writes a group's fields is therefore recorded, where it was discarded; one that adds or moves a group is discarded
as one that adds or moves any structure. With the tally carried, tallied is answered: a call the planners abstain
from for a tally they do not write (a round robin group's, an ad hoc or lucky structure's) is read off v1's whole
write, under every refusal above. A recorded cascade (the double-exit module's) reads the same diff, so a group's
fields it changed would be carried too; it is still not asked for a call in a group.
A TEAM dual's call and a line's are recorded as any call is, and team is answered with every other reason a TEAM call
abstains for (exit, cascade, route, a plan that leaves settle work, and the rest). v1 writes the line, its dual's
tally (updateTieMatchUpScore: the sides and tieFormat it ensures, the score, the status), the dual's own direction
where the line decides or un-decides it, the line-ups it carries onto the sides of the duals a team goes on to, and the
draw's lineUps extension: all of it in the draw, so all of it recorded ops. Nothing in the recorder is TEAM's own but
this: a line is a matchUp of its own, stored inside its dual. replaceMatchUp carries a matchUp's own fields with its
tieMatchUps kept, as a structure's matchUps are kept; a line that changed has its own op, after its dual's; and a run
that replaces the list a dual holds its lines in is discarded, as one that adds or moves a matchUp. A dual's op that
carried its lines with it would write a line the op does not name: the line's stamp would not be told to the call's
ledger (a stamp is once per entity per engine call), and a later write of that line in the same engine call (an
executionQueue) would stamp it again, where v1 keeps the first. Apply leaves the copy's object graph across the dual
and its lines as across any entities: a line-up object v1 writes onto a side and into the draw's extension is one object
in both. A dual planned inside its line's plan (asDual) is still never recorded: the line's call is the one asked, and
is recorded whole where its dual's part is not planned.
Recorded calls (batch 5): the abstentions that were left. Each of the paragraphs below adds one reason to those a
whole-call recording answers (plan.ts RECORDED_WHOLE), under every refusal above. A call with no captured instant
(clock) is described under § 7.2's table.
Recorded calls: a draw stored without its edges. edges is answered. v1 writes a draw's missing edges before it
decides anything (ensureGoesTo: winnerMatchUpId, loserMatchUpId, and the finishing round and range addGoesTo
adds, onto every matchUp that has one), and a call that succeeds announces the draw once for them (announceGoesTo: one
modifyDrawDefinition, which stamps the draw and each of its structures, and no modifyMatchUp for a matchUp whose
only change is an edge). All of it is in the draw, so the copy's run carries it: a replaceMatchUp for each matchUp
given an edge, which keeps the updatedAt it had, as v1 leaves it; the structures' and the draw's stamps in their own
ops; the draw notice among the recorded notices. The recording is one op a matchUp at most (measured: 220 replaceMatchUp, one for
each matchUp of a FIRST_MATCH_LOSER_CONSOLATION 128 that holds an edge), made once: the draw stores its edges from then on. A refused call
has no route, is not asked for, and stores none of the edges, as before. edges is asked ahead of a schedule, notes,
the client's codes and a competition policy, so a call recorded for it may be one a later reason would have held too:
what v1 does for those on the copy is recorded with the rest, or the recording is discarded by the recorder's own
rules, as for write-mode above.
Recorded calls: a stored winner taken away. winner is answered. The planners plan a winner entered again, changed,
swapped, or cleared with its status. What is left abstained winner: a decided result re-scored as unfinished
(IN_PROGRESS, INCOMPLETE, AWAITING_RESULT, DEAD_RUBBER: v1 takes the winner back out of the next matchUp), and a decided
result corrected to a tie its format permits (COMPLETED with no winner). All of it is v1's write in the draw (the
matchUp's own fields, the next matchUp's position, a group's tally), so the recording carries it under every refusal
above.
Recorded calls: a per-matchUp competition policy. competition is answered. v1's score write brings the draw's
stored competition state up to date (processCompetitionMatchUp: re-derived from every result of the draw) and
announces the draw for it (announceDrawChange). The state is the draw's own field (competitionState, or its
extension), so the recording carries it in replaceDrawState, with the draw notice among the recorded notices. Nothing
is written outside the draw; a run that did would be discarded by the recorder's own rule.
Recorded calls: a schedule the planners do not write. schedule is answered. v1 writes a call's schedule onto its
matchUp as timeItems after the result, each stamped with the call's instant; the planners write what scheduleOps plans
and abstained from the rest (a start and an end time, a schedule on a double exit asked for again). The timeItems are
the matchUp's own field, so the recording carries them. A schedule v1 refuses is still refused before any plan (§ 2).
Recorded calls: notes the planners do not write. notes is answered. v1 writes a call's notes onto its matchUp
inside the score write (addNotes) and forwards the call's parameters, notes among them, to the exits a double exit
writes; the planners write notes on the call's own matchUp on the clean routes and abstained from the rest. Wherever v1
writes them the notes are a matchUp's own field, so the recording carries them.
Recorded calls: notes that are not data (CA, 2026-11-18). addNotes also stores the { testing: true } object a
test hands it, as it is: the stored matchUp holds the caller's very object, whatever its fields hold, a function among
them. Such a call was not recorded (a function cannot be copied, so no op could hold the matchUp), and stayed v1's. It
is recorded: v1's run on the copy is handed the call's own parameters, so the copy's matchUp holds the caller's object,
and apply leaves the copy's object graph on the stored matchUp (Recording.mirror: an object taken from the call is
taken as it is). The stored matchUp therefore holds the very object v1 stores, each function in it the one handed over.
The op's own copy of the matchUp, which the working view and the shadow fold, is a copy as far as one can be made
(tools/cloneState.ts cloneData: structuredClone, and only where that throws, every plain object and array copied
and whatever else is held kept by reference). The same copy is taken at three more places where v2 copies a stored
matchUp or a folded view that may hold such a field (the working view's copy on write, the recorded fold,
differential's kept view): before, a later call on a record holding such notes threw there under v2 and
differential (DataCloneError), and the two measured (a result on the matchUp that holds them, a double exit beside
it) now leave what v1 leaves. Other routes over such a record are not measured. differential compares the shadow with v1's record as text, which does not show a function; that
the stored object is v1's, object for object and function for function, is held by recordedNotesCall.test.ts.
Recorded calls: a forward settle stopped at its bound (CA, 2026-11-18). v1's forward settle acts on one owed
answer per pass and stops after its pass limit (§ 6: settleForwardConsequences, 64 passes). A call that stops there
succeeds: what the pass did not reach is left for the next call's settle, and the call returns a
FORWARD_SETTLE_EXHAUSTED warning naming a matchUp it did not reach. Such a run was discarded, and the call stayed
v1's. It is recorded as it stopped: the recorded ops are v1's write up to the bound and the passes that follow it, and
the call returns what v1 returned on the copy, the warning in it. The program's announceRecorded op says so
(forwardExhausted: true, plan/recordedCall.ts), and of such a program the forward pass's predicate is not asked
(settleWork.ts predictSettleWork): the work it would find is the work v1 leaves, stated in the warning, not work the
program misses. Every other predicate is asked, and where one finds work the recording is dropped: no proof is offered
for it (settledOnCopy would run the forward pass again and do the rest). The next call, v1's or v2's, finds the
remainder as v1 alone leaves it. Not this: a bounded loop that REFUSES at its bound (SETTLE_BOUND_REACHED, § 6) is
an error, and a call v1 refuses on the copy is still v1's.
Recorded calls: settled by proof (EXPLORATORY, not ruled; its own commit). A whole-call recording is v1's write
as its own settle passes left it, and a recording a has-work predicate still found work on was dropped. The predicates
approximate the passes, so where one finds work on a recording the passes themselves are asked
(plan/recordedCall.ts settledOnCopy): settleAfterWrite runs once more on the copy as v1's run left it, with the
readings taken of the copy as it then stands, as the next call's settle would take them. The recording is kept only if
that run changes nothing at all by the measure the recorder takes of a change (every entity's own fields and the
objects that hold them, so no field and no stamp; no notice buffered), returns no error and no warning, stops at no
bound, adds or moves no entity, writes nothing outside the draw or into the call's parameters, marks no tournament or
topic modified, and reads neither the clock nor the random source (it is handed neither: a read is answered with a
placeholder, counted, and fails the proof, so the instants and draws the copy's first run kept stay the call's). The
kept program's announceRecorded op says so (settledByProof: true), and settleSites asks no predicate of a program that
carries it: the passes' answer stands in the predicates' place, and the plan reports no settle work because the passes
have none. Anything else, and the recording is dropped as before.
Measured on the batch 5 ledger's settle family (22 calls): reconcileLinkAdvancements found work the pass does not
have (2 calls: a qualifier's removal held back by play downstream; a TEAM line in a dual won by WALKOVER whose winner
was fed on), and those are proved and owned. settleHeldExits found work the pass DOES have (20 calls: a double exit
beside a held exit, entered, asked for again, or made of a result): asked again, the pass leaves every value as it is
and announces the matchUps it visits, which a later call's settle does too, with their stamps. That is a change, so
those recordings are dropped and the calls stay v1's. With the readings v1's own run was handed, in place of fresh
ones, every one of the 22 answers the same.
What a recorded call returns. v1 on the copy returns objects of the copy where on the stored record it returns the
stored ones. A line's call returns its dual's tally (tieMatchUpResult), and where the dual's tieFormat declares its
score REPORTED nothing is derived from its lines and the tally is the dual's own stored score, the very object
(updateTieMatchUpScore). A recording whose result held an object of the copy was not made (batches 3 and 4a). Now the
result is given the stored objects (recordedCall.ts returnedOnStored): each object of the copy it holds is replaced,
in the objects the run itself made (the result, and what it built for it), by the stored object it was copied from
(cloneState keeps, for every copy, the object it copies). That is the object v1 holds there on the stored record,
since v1 does to the stored record what it did to the copy. An object the run made is left as it is: where v1 stores it
too (a derived tally's score), apply stores that very object, so the result and the record hold one object, as v1's do.
A stored object is returned only where it will read as the copy's does: it does already, and holds the stored
counterparts of what the copy's holds (the run wrote nothing in it); or the copy's is still in the draw, which the
recorded ops replace, so apply makes the stored object what the copy's is. Where neither holds the recording is not
made, as before: an object the run changed and took out of the draw, or one outside the draw that does not read as its
stored counterpart (the event and the tournament record hold the draw, so they read as changed wherever the draw is).
The call's own parameters are not copied, and are returned as v1 returns them.
Still v1's among TEAM calls, as among any: a call v1 refuses on the copy (ERR_MISSING_ASSIGNMENTS for a result entered
on a line with no line-up assigned), and a recording a settle predicate still finds work on. An exit entered on a dual
whose auto-calc the call turns on, its lines projecting no winner, is no longer one: it is row 6's fallthrough, refused
by both pipelines before anything is written (§ 2).
planOutcome returns a complete plan only when every write the call makes is an op; otherwise it abstains, naming
the first reason, and the call is v1's whole (fail-closed). S1 holds two shapes: the local write (the matchUp's own
result, no winner before or after) and the first direction (a played result naming a winner where none stood, whose
only consequence is the winner's position in the next matchUp of the same structure). The reasons are the work list of
the slices that follow:
| reason | the call | taken on by |
|---|---|---|
team | is a dual or one of its lines, but a line's first result leaving its dual undecided (S7) | S7; batch 4b: what S7 does not plan is read off v1's whole write (recordedWhole) |
schedule | carries a schedule | a later slice (§ 3.5.8 of the executor plan); what scheduleOps does not plan is read off v1's whole write (recordedWhole) |
notes | carries notes, but on the call's own matchUp on the winner, score-only, removal and clear routes, not TEAM, no double exit before or after (S7) | S7; deferred: TEAM (the dual's tally write), a double exit (v1 forwards the call's params, notes included, to the exits it writes: v2 would write them on the produced exit too), the { testing } fixture, every other route |
status-codes | carries the client's positional status codes, split into side codes at the write | S2 |
exit | has an exit status before or after, other than a single exit entered with a winner on a clean matchUp that carries nothing on, or carries it one level onto a clean seat | S5; the clean clears of a double or single exit, the clean single-exit corrections, a clean double exit given a winner, a double exit asked for again, a clean result turned into a double exit, a same-winner relabel its loser carries, or whose carry it withdraws S6 |
winner | takes away or changes a winner already stored, so what it directed is taken back | S4; what S4 does not plan is read off v1's whole write (recordedWhole) |
loser | has a loser link, so the loser goes somewhere | S3 |
link | sends its winner into another structure | S3 |
cascade | sends its winner to a matchUp holding a BYE, an exit or a result, so the winner goes on or meets it | S5 |
route | takes a route, or reaches a status, that S1 does not plan as ops | S2 |
provenance | is on a matchUp holding side-exit provenance the score write may clear or rescue | S5 |
tallied | is in a round-robin, ad hoc or lucky structure, whose tally the write updates | S3; batch 4b: read off v1's whole write where the planners do not write the tally (recordedWhole) |
no-record | has no supplied draw definition to apply the plan to | requires a draw; tournament containment is not required |
edges | is on a draw that stores no winner and loser edges, which v1 writes first (ensureGoesTo) | S2 (setEdges); until then read off v1's whole write (recordedWhole): the edges are among what the copy's run changed |
clock | has no existing captured instant; direct source reads, advancing values and throwing-write prefixes must remain ordered as in v1 | the ordered temporal executor, for the programs it certifies; every other is read off v1's whole write, with the instants it read (recordedWhole, below; CA, 2026-11-18) |
settle | leaves a settle pass work on the working view (S2's has-work predicates, settleWork.ts), leftover state included | batch 4a: read off v1's whole write where it can be (recordedWhole); otherwise none: S2 owns only a call no pass has work for |
write-mode | is made in LEGACY or BRIDGE write mode, where v1 writes scoredTime as a timeItem, which the reducer does not | a later slice (F6: BRIDGE in with its evidence) |
competition | names a winner where a per-matchUp competition policy applies: v1 updates ratings on the result (processCompetitionMatchUp) | a later slice; read off v1's whole write (recordedWhole): the competition state is the draw's own field |
Draw scope (D): a supplied draw can be owned with an existing captured instant even when no tournament record holds it. The shadow copies the exact supplied draw and its real optional event/tournament roots together, preserving shared references; it never fabricates a record or substitutes a same-ID draw from one. The view oracle hydrates that exact shadow draw with the supplied context. Notice expectations preserve absent event context and event identity retained from an earlier buffered notice. Every other shape guard still applies.
In differential, a complete plan is folded into the captured draw as it stood before v1 ran and compared with
v1's writes across the draw and every supplied context root, every updatedAt by value: within an existing capture,
v1 stamps each touched entity once per call, as v2 does (F2 (i), § 5 step 6). Uncaptured callers still abstain on
clock; wrapping them in a new capture would change their direct-read and throw-prefix contract. Their ordered
temporal path remains v2 work before v1 can be retired.
Recorded with no captured instant (CA, 2026-11-18: adopt the replay). A call made
outside an engine has no captured instant and no stamp ledger: each stamp v1 writes reads the source where it is
written, a source that advances gives each entity its own instant, and a source that fails leaves the writes made
before the read. Where the ordered temporal executor certifies the planned program it runs as above. Every other
program, and each abstention a recording answers (clock among them: a group's tally with no ledger), is asked for
whole (recordedWhole): v1 runs on a copy of the record and reads the source as it does on the stored record, the
recorded ops hold the instants it was given as data, and apply reads no clock. A reader (tools/replayedInstants.ts,
made in setMatchUpStatus beside replayedDraws) stands between v1 and the source for every run v1 makes for the
call: the copy's readings are kept and handed, in order, to v1's run on the stored record (differential, or a
recording refused, dropped or thrown out of), a reading the source refused is refused again at the same read, and only
past their end is the source read. So in every mode the source is read exactly as often, and in the same order, as v1
alone reads it; a failing source leaves v1's own partial write and v1's error, since the copy's run fails first, no
recording is made, and v1 replays the same readings on the stored record. Nothing is captured: no instant is fixed for
the call, no ledger is opened, and the caller's clock is not replaced. differential compares the shadow as for any
recorded call, every updatedAt by value, and diverges where v1's run on the stored record read the clock another
number of times than its run on the copy.
ONE DEPARTURE from the clock-phases standard (zero planning reads; each read made at the live writer's own phase),
ruled with it: a recorded uncaptured call takes its readings DURING PLANNING, while the copy is written and before the
first write to the stored record, not between the stored record's own writes. Their count, their order and their values
are v1's. Only a source that observes the stored record as it is read, or wall-clock time set against the record's own
state, could tell the two apart. A competition provider (setCompetitionClock), which nothing on this path reads, is
not replayed. Still clock: a certified program whose provider gives no notice snapshot, and whatever
a recording is refused for.
Until 2026-10-24 stamps were normalised there (structures left out, the draw and matchUps by presence), because v1
stamped at each notice and every top-level structure on each.
The working view (outcome/overlay.ts; executor plan § 3.2) is the draw as a plan's ops will leave it, read
without writing the record: what S2's has-work predicates for the settle passes read, where v1 reads the draw it has
written. A matchUp or structure an op writes gets a stored-shape working copy, the ops are folded into the copies by
the same reducer as the shadow apply, and the matchUps an op wrote, with those whose sides read a reassigned
drawPosition, are derived again from the copies by indexing again the top-level structures that hold them (below),
a TEAM draw included since S7. An assignment can affect a dual without writing its stored matchUp;
its tie lines are derived again too, since their sides read the dual's assignments. Each replaces
its entry in v2's copy of the view's draw.
The view oracle checks it in differential: after every complete plan, the working view, folded before v1 wrote,
is compared field by field (sides, status, winner, score, drawPositions, finishingPositionRange, feedRound and
hasFedDrawPosition, the edges and the exit records: what v2 reads) with one hydration of the shadow-applied record.
Until the view moved onto the index it also compared schedule, drawPositionsRange, preFeedRound, roundFactor
and readyToScore, which nothing in v2 reads; schedule.scoredTime is read from the stored matchUps. A difference is a
divergence keyed view:<field>. Measured 2026-10-24 over the exitPropagation and matchUps suites: 9,184 views
compared, none different; with re-derivation removed, 103 exitPropagation files fail. The oracle's own reads (the
shadow's hydration, a hydrated working view's projection, and the index oracle's hydration below) are test
instrumentation: verify:hydrations keeps them out of differential's ceiling and reports them apart (2,184 over its
census, when TEAM working views were still projected). Under v2, a hydrated working view's projection is the
pipeline's own work and counts; since S7 a TEAM view is indexed, not hydrated.
The structural index (buildStructuralIndex, src/query/matchUps/structuralIndex.ts; executor plan § 3.1.1, CA
2026-10-24: v2 decides on stored data and a structural index, never on a hydration) is one entry per matchUp in the
hydrated shape, carrying only what the outcome logic reads. A probe of every read v2's view, planners and settle
predicates make found that set to be the stored matchUp, its structure and round-robin container, the round profile's
feedRound and hasFedDrawPosition, the inherited matchUpType and matchUpFormat, and its sides' sideNumber,
drawPosition, participantId, bye and qualifier. A side's participant is read only as a presence test, so the
index carries { participantId } for a participant the tournament holds, as hydration carries the record. No participant
record, round name, schedule detail or policy is read. The sides and the round profile come from the functions
hydration calls (buildMatchUpSides, getRoundMatchUps), and a tiebreak-only or timed set is annotated as hydration
annotates it, so the two derive each field once.
A TEAM draw is indexed for the outcome view (S7; buildStructuralIndex({ team: true }), asked by the view and the
working view only, so the other callers of the index still hydrate a TEAM draw). A dual is indexed as any matchUp, and
its lines are nested in it (tieMatchUps) and listed beside it, each built through its dual as hydration builds it:
the dual's drawPositions, round number and finishing positions; the collection's matchUpType and format (the line's
own tieFormat, else the dual's resolved one); BYE where the dual is one, over the TO_BE_PLAYED a line is stored as;
sides from the dual's line-ups (getCollectionAssignment); and, in a round robin, the container as the line's
structure with no container of its own, as hydration places it. A dual carries no matchUpFormat.
The view decides on the index. buildOutcomeView builds it, not a hydration, and the working view and the settle
predicates read it, a TEAM draw included since S7. So under v2 a call costs v1's hydrations and nothing more
(verify:hydrations, every arm, TEAM included), and a call v2 refuses takes none. An index entry shares nested objects
(score, sideExitProvenance) with the stored matchUp, so the view is read before the call writes, never after.
The index oracle holds it to the hydration in differential: before v1 writes, the view's index of the draw as the
call found it is compared, field by field, with one hydration of the same draw taken for the purpose, after the view's
own step on a draw stored without its edges. A difference is a divergence keyed index:<field>. Measured 2026-10-24 over the
mutations suite: 66,154 calls, 1,873,656 entries compared, none different; 15,940 calls on TEAM draws were then tallied
as deferred. Since S7 a TEAM draw is compared too, collectionPosition and each dual's nested lines (tieMatchUps.<field>)
included: verify:team-arms under differential, 1,528 tests, none different. Measured against a full in-context hydration (median of 15): SINGLE_ELIMINATION 32 to 256 at 11–13%,
FEED_IN_CHAMPIONSHIP 64, ROUND_ROBIN 32, DOUBLE_ELIMINATION 64 and COMPASS 64 at 11–13%, linear in the draw.
v1's settle passes ask the index first (matchUpStatus/indexPrecheck.ts; the v1 win CA agreed 2026-10-24). Most
of v1's settle passes hydrate the whole draw on every call only to run a detector that usually finds nothing, and a
pass whose detector finds nothing writes nothing. So a pass first asks its own detector of the structural index, built
with what the pass hydrates with (the draw alone), and returns without hydrating when it finds no work; a TEAM draw
is indexed too since S7 (team: true). Measured on verify:hydrations' TEAM arm under v1: 1,767 hydrations over
228 calls before, 234 after (worst call 10 to 3). In differential the detector is asked of a hydration too, and a
disagreement is a divergence keyed precheck:<pass>, raised when the call is compared and the call restored: the index
oracle sees the draw as the call found it, this one each state a settle pass meets after the call's writes. Passes
move one at a time, each with its verify:hydrations v1 ceiling lowered. reconcileByeAdvancements first: about one
hydration a call fewer on every census arm (matrix BYE: DOUBLE_WALKOVER 1,735 → 1,536); over the mutations suite under
differential, no disagreement. settleHeldExits second, asking hasHeldExitWork (the predicate v2's has-work check
already uses) with the pass's own getMatchUpsMap, so no map is built twice: its three sub-passes each hydrated, and
the census arms fall 32–45% (matrix BYE: DOUBLE_WALKOVER 1,536 → 945; deep BYE: the route 2,636 → 1,442, 6.6 → 3.6 a
call). A detector forced idle is caught: 230 exit-propagation tests fail on precheck:settleHeldExits. settleForwardConsequences
third, asking hasForwardWork: about one hydration a call fewer again (deep BYE: the route 1,442 → 1,066, 2.7 a call);
forced idle, 100 tests fail on precheck:settleForwardConsequences. reconcileLinkAdvancements fourth, asking
getUnearnedLinkAdvancements: deep BYE: the route 1,066 → 756 (1.9 a call). The pass acts rarely, so a v1 test pins
it: a qualifier's main-draw seat is released when its qualifying final is cleared, and a detector forced idle leaves
the participant seated. reconcileStaleExitOrigins fifth, asking hasStaleExitOrigins of the
index: the pass already skipped its hydration unless stored data showed a candidate, and now skips it when the
candidate's links show nothing stale (deep BYE: the route 756 → 616, 1.5 a call); forced idle, 32 exit-propagation
tests fail under v1. reconcileProvenanceSides sixth, asking findMisplacedProvenance after the same
stored-data candidate check (matrix BYE: WALKOVER propagated 870 → 668); forced idle, 4 mutation tests fail under v1.
reconcileCarriesPastByes seventh, asking findOwedCarry once before its loop, after its cheap check for a BYE
matchUp recording a carried exit (matrix BYE: WALKOVER propagated 668 → 466); forced idle, 29 mutation tests fail
under v1. reconcileMissedLinkAdvancements eighth, asking findMissedLinkAdvancements (deep BYE:
the route 582 → 534, 1.3 a call); forced idle, 4 mutation tests fail under v1. reconcileConsolationReservations ninth, asking
findReservationWork (the fed seats whose FIRST_MATCHUP reservation the pass would place or withdraw); v2's has-work
predicate asks the same detector, exact where it was scope (any result in a round such a link reads); forced idle, 20
mutation tests fail under v1.
7.2.1 Where the plan lives
planOutcome and the dispatch (abstainReason, shapeReason, exitReason, recordReason, planOps,
recordedPlanOps, the TEAM line composition that re-enters planOps, and resultToDoubleExit) are
src/mutate/matchUps/outcome/plan.ts. Every shape family is a module under outcome/plan/, imported by plan.ts
and never the other way, in layers (lowest first):
- vocabulary:
planShared(the route and status sets, the index readers, the clean and scoreless predicates,seatByeandstructureStamps),resultOps(the call's own result write),tallyOps(a round robin group's tally); - readers:
producedTarget,byeChain,standingReservation,schedulePlan,directionOps,teamPlan,unwindSeats; - the S5 shapes:
convergence,producedExit,carriedExit; - the S3, S4 and S6 shapes:
directionReasons,exitCorrections,unwindPath(withunwoundView, the one "unwind, then re-plan" composition); - the given-winner families:
supersededRelay,terminalAward,standaloneIndirect, thengivenWinner.
The split was mechanical (2026-11-07, factory #6273 to #6278): every declaration kept its text and order, proven by a
plan-ops trace over the census in all three modes and the full gate. The module map, with the import graph and the
placement decisions, is Mentat planning/OUTCOME_V2_PLAN_MODULE_MAP.md. Where two shapes look like one rule in two
spellings, a debate ruled on merging them; the rulings are Mentat assessment/2026-11-07-outcome-refactor-debates.md
and each one that keeps shapes apart is repeated as a comment beside them.
8. What the corpus pins
setMatchUpStatus steps recorded | 50,559 (recorded tests, matrix, census, route flips, fixtures) |
| refusal codes observed | 18 (§ 2), none declared in the entry file |
setMatchUpState | exported as an engine method, eleven declared codes, no caller in the corpus: an internal that leaked onto the surface. Deprecated on the engine surface in 7.5.0 and removed at the next major; its internal callers keep it, and consumers call setMatchUpStatus |
bulkMatchUpStatusUpdate | 1 recorded step; its declared codes pinned by authored/outcome-pipeline/bulk-update-refusals: ERR_MISSING_VALUE for no outcomes, ERR_MISSING_TOURNAMENT for an unknown tournamentId, ERR_MISSING_EVENT_ID for an outcome without an eventId. Every outcome is located (tournament, event, draw, matchUp) before any is applied, so an outcome naming something not there is refused with its outcomeIndex in context and nothing is written; it used to be skipped while the call reported success (2026-10-18). A refusal setMatchUpStatus raises for a later outcome still leaves the earlier ones written unless the call asked for rollbackOnError. It forwards every per-call setMatchUpStatus option (the three flags of § 1 among them), set on the call or on one outcome, so a bulk entry follows the same rules as a single one |
| real-record do/undo | 9 of 11 probed fixtures restore the draw projection; 2 do not (§ 4). The same under v1, v2 and differential (2026-10-26) |
| authored scenarios | 13 (pnpm corpus:authored), one per rule above that the recorded sources did not reach: the flag precedence (§ 1, three scenarios), rows 5, 9, 10 and 14 of § 2 with every condition of row 9, the swap (§ 3), a double exit entered over a completed result (§ 4), the FMLC loser kept out and a decider's settlement (§ 5), the double-exit no-op (§ 6), two double exits converging, a TEAM dual handed back to auto-calc, the bulk refusals. Each asserts the result code of every step and, where a flag's effect is the claim, the state the patches rebuild |
9. Open questions — decided 2026-10-01 (CA)
- A clear keeps normalising: TO_BE_PLAYED and an empty score object are the canonical cleared
state. It keeps a matchUp-level
matchUpFormat: the format is a property of the match, not of its result. (§ 4; landed.) ERR_FORCEDis traced (2026-10-31): the error-path tests' forced cascade-write failure, not an engine code. (§ 2, row 19)setMatchUpStateleaves the governor; its internal callers keep it. (§ 8; deprecated in 7.5.0, removed at the next major)- The flags: the policy governs, both ways. (§ 1, landed with this revision)
Related
- exit propagation: what propagates, provenance, the guarantees on cascades.
- drawPositions: the rules direction relies on.
corpus/INVARIANTS.mdandcorpus/README.md: the properties and the scenarios that pin this page.
A removed loser held beside a structural BYE (C21)
A removal or changed winner can own the old loser's seat beside a BYE when that seat holds the old loser, has no result, codes or exit provenance, and its BYE passage stays in the same structure. Every relay is scoreless, has no winner or provenance, and holds that position opposite a BYE; the passage ends at a clean arrival or a last-round BYE. Conditional loser links and linked winner continuations keep their existing refusal boundaries.
Removing the old loser clears its assignment and derives status codes as v1 does, preserving the structural BYE placements. A correction announces the new loser's placement through the passage. When the new result is a double exit, its own result notice precedes the surviving loser-removal notice; the new exit's placements follow. A quiet produced write on the entry retains the event and tournament identity of that removal notice, while its deferred in-context read stays bare. Exact ordered notice pins enforce both policy settings.
For a fresh TEAM line undoing a decided dual, the entry side's old line-up is deleted. The
setSideLineUp op's explicit clearsLineUp mode deletes that property on the existing stored side,
without synthesizing sides, and announces removeDirectedLoser with the event and tournament.
The entry matchUp and its structure are stamped. A dual-own-call clear retains its earlier TEAM
refusal; corrections and line-driven undo use the certified passage.
A winner with no arrival to direct (C22)
A fresh WALKOVER or DEFAULTED can name the side that has not arrived. The certificate requires TO_BE_PLAYED, no stored winner, score value, exit provenance, carry or codes, and exactly the opposite side holding a participant. The winner has no participant to send onward. The source result is written normally; any loser direction passes its existing arrival/exit/BYE walls. The unused winner target does not need to be empty, because no winner arrives there yet.
A lucky pre-feed round defers both directions, including an existing loser link, until lucky selection resolves the round. Its result is local. A propagating exit may still meet the later conservative settle wall, which remains owed. No feeder-win rule changes.
AD_HOC without a winner or loser direction needs no group certificate for the direction itself. A missing required tally frame still refuses at the tally wall; that write remains owed.
A bare half-arrived TEAM decision under the default scoring policy can reach v1's late MISSING_ASSIGNMENTS check after side preparation has written metadata and stamps. V2 must not accept it as a completed result. That control retains v1's prefix and error until a typed v2 refusal program owns the same writes, notices and terminal error. It is explicitly unfinished v2 work, and must be owned before v1 retirement. The requireParticipantsForScoring=false policy remains accepted and owned. A clean early error would not preserve the captured prefix.
A TEAM arrival keeps the identity of its assignment notice (C24N)
When a losing team takes an exit already awarded to its seat, the assignment announces the matchUp with its event. The later default-lineup write is named updateSidLineUp and omits the event argument, but keyed notice coalescing retains the earlier event identity. The standingAwardArrival certificate therefore keeps event scope on that final notice. Other own-seat lineup notices retain their existing quiet scope. No result, record or admission changes; the plan describes the notice a subscriber actually receives.
A corrected result refreshes its recorded arrival (C23)
A source relabelled beneath an active onward matchUp refreshes the arrival origin that names its earlier result. For native non-TEAM matchUps in the same flat structure, certify stored non-BYE arrivals whose previousMatchUpStatus still equals the source's stored status. After the source result, merge only the changed previousMatchUpStatus, preserve the rest of each entry, and stamp the arrival and its structure. Announce as refreshArrivals on apply-values, or refreshArrivalsFrom on a swap, with the event and tournament. No score, codes or positions are rewritten by the refresh. Foreign, nested, stale or BYE arrivals remain owed.
The existing carry, withdrawal and swap-path certificates still apply. Admission past the arrival-label wall does not own a call that reaches a later refusal. Refused TEAM winner changes can differ in their mutation prefix before CANNOT_CHANGE_WINNING_SIDE; they join the explicit terminal-error program obligation before v1 retirement.
A played source relabel carries past its loser's held BYE (C24)
On apply-values with the same winner, a native COMPLETED source may become a propagated WALKOVER, DEFAULTED, or RETIRED carried as WALKOVER while its loser already stands beyond a BYE. Certify that the loser holds the entry seat opposite that BYE, with no carried exit, codes or provenance, and that the existing same-structure passage ends in a clean landing. Reuse the carried-exit program: merge the carrier's provenance on each BYE without changing its status, score or codes, announce progressExitStatus and stamp it; write the landing's carried result, provenance and onward placements under the ordinary carry certificates. A retirement without retirement propagation changes the played source alone.
This admission does not include swaps, existing-carry corrections, TEAM, or a passage without a later non-BYE standing matchUp. The feed-eligibility refusal still precedes admission. Those shapes remain obligations before v1 can be retired.
Correcting a carry past a held loser BYE (C25)
A native same-winner apply-values correction can relabel or withdraw an exit already
carried past the loser's BYE passage. Each relay must still hold that participant,
its BYE and exactly one direct carried origin from the source. The same-structure
passage ends at a scoreless single carried award, with no other provenance or codes.
The stored origin supplies the carry flavor: a propagating retirement can retain a
DEFAULTED carry, and a non-propagating completion can leave either carry in place.
A source currently marked COMPLETED therefore still requires carry reconciliation.
Re-entering the same carry, or a propagating retirement, leaves the carry unchanged.
Changing WALKOVER to DEFAULTED or the reverse writes the new carried origin on every
BYE, announced as progressExitStatus, and rewrites the landing's award, codes and
scored time. A WALKOVER blanks the landing's score. The relabel returns the empty
direction context that v1's carry returns.
A played result, bare winner or non-propagating retirement withdraws the carry. Every
BYE keeps its result, positions, score and codes; setSideExitProvenance removes the
origin and announces relabelLoserExit. The landing becomes TO_BE_PLAYED, loses its
winner and provenance, retains its score and has its scored time reconciled, announced
as reconcileScoredTimes. A clean onward position awarded by the carry is released
first; for a relabel it is placed back and announced after the landing. All touched
matchUps, the target structure and draw receive their required stamps.
A changing or withdrawn carry must have no further loser link, and any awardee's next matchUp must satisfy the existing clean-release certificate. Convergences, deeper linked carries, a downstream BYE withdrawal, TEAM and enabling a fresh carry after an already recorded non-carrying exit remain separate owed shapes. The retained-COMPLETED check runs before the source-status shortcut, so an uncertified retained carry is never silently treated as a source-only write.
A loser BYE beside a standing carried award (C26)
With double-exit BYE propagation on, a free, unconditioned loser seat can hold an award to its empty arriving side, opposite one participant carrying WALKOVER or DEFAULTED. Exactly one provenance entry names that carrier's single-exit origin; the home is scoreless, has no codes, BYE or further loser link. A retained carry still counts when its origin has since become COMPLETED.
The seat takes a propagated BYE and the home becomes BYE. A terminal home keeps its original provenance. Otherwise the carrier advances into a clean matchUp of the same structure. Reconciliation records the carried flavor at both home and landing, normalizing a RETIRED previous status to WALKOVER. The landing receives the carried result, award to the opposite side, empty codes and scored time; WALKOVER blanks its score. TEAM landing sides use ensuredDualSides with structurally projected positions, retaining edited lineups by drawPosition across side renumbering.
An opponent actually present at the landing advances to a clean next matchUp; an empty fed reservation does not. If the other unfillable-seat BYE has already placed a position there, the later awardee placement keeps it. Only that shared clean onward placement is joined; overlapping home/landing writes are excluded. The later ordinary assignment supplies its notice context and full identity even after an earlier quiet BYE advance. Each touched matchUp and structure is stamped.
A home with scoredTime is reconciled last, removing that time and announcing reconcileScoredTimes. Without a prior scoredTime, a nonterminal home's provenance write is announced as progressExitStatus before the landing. Exact ordered notice payloads, including event and tournament, follow v1 in both cases.
The carrier can have passed existing BYEs before reaching the home. Each earlier relay must hold that one carrier and origin, with no score, codes, scored time or loser link. Reconciliation starts at the first eligible BYE in stored order and replays its path through the home: provenance is merged, each relay is stamped, and progressExitStatus is announced. If the home is stored first, earlier relays are not revisited. A terminal home causes no carry replay.
Policy-off convergence, linked carry withdrawals, overlapping BYE relays, deeper onward chains and dirty landings remain owed writers before v1 retirement.