{ "contract": "event-resolution", "version": 2, "templates": [ { "id": "instant-and-turn-boundary", "title": "an instant is one simultaneous moment", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "events at one moment {{instance}} treats as simultaneous, including a turn boundary where the adoption has one", "when": [ "the moment is resolved" ], "then": [ "all events belong to one instant and follow one lifecycle", "a constructed turn boundary is handled as an instant like any other. Where no turn boundary exists, this test checks nothing about turn boundaries." ], "diagnostics": [ "{{instance}}-instant-trace" ] }, "text": "An instant is one moment the game treats as simultaneous. A turn boundary the adoption can construct is an instant like any other. Where there is no turn boundary, this test checks nothing about turn boundaries." }, { "id": "waiting-active-and-first-boundary", "title": "waiting and active events are distinguishable", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "an accepted event before and during resolution", "when": [ "the event enters the waiting set and is selected" ], "then": [ "before selection it is recorded as a waiting event that has not begun", "during ordered effect application it is recorded as the active event", "the active event visits an effect boundary before its first effect" ], "diagnostics": [ "{{instance}}-waiting-set", "{{instance}}-event-trace" ] }, "text": "A waiting event is accepted but has not begun. An active event is applying ordered effects. Every active event visits an effect boundary before its first effect." }, { "id": "ending-event-records-nothing", "title": "ending events record no outcome while resolving", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "each ending event the adoption can construct whose effects make an ending condition hold", "when": [ "the ending event resolves and the instant later reaches settlement" ], "then": [ "resolving the ending event records no match outcome", "an outcome is recorded only after the waiting set is empty at step 15", "the ending record distinguishes event resolution from outcome recording", "where no ending event exists, this test checks nothing" ], "diagnostics": [ "{{instance}}-event-trace", "{{instance}}-ending-record" ] }, "text": "Each ending event the adoption can construct follows the ordinary event lifecycle but records no outcome when it resolves. Only step 15 records an outcome, after the waiting set is empty. Where no ending event exists, this test checks nothing." }, { "id": "file-order-never-decides-resolution", "title": "container order never decides event resolution", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "two equivalent {{instance}} adoption documents whose container order or document order differs, with the same recorded random inputs where a declared random order is used", "when": [ "the same instant is resolved from the same pre-instant state under each document" ], "then": [ "the two runs select and resolve the same events in the same declared order", "no event order is taken from container order or document order" ], "diagnostics": [ "{{instance}}-order-trace", "{{instance}}-settlement-report" ] }, "text": "Changing container order or document order without changing declarations never changes event resolution. Rank, a rank tie, and within-class order decide the sequence; document order never does. Step 5 says container order in the adoption file never selects an event." }, { "id": "rejection-case-nothing-changes", "title": "{{row.id}} refuses the proposal with nothing-changes", "type": "scenario", "expand": "per-row", "collection": "rejection-cases", "when": { "row": { "result": [ "nothing-changes" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "a proposal that meets the refusal case at {{row.declared-in}}", "when": [ "the proposal is checked from a recorded pre-attempt state" ], "then": [ "the proposal ends without creating an event", "no game state changes, no cost is spent, and no clock advances because of the refusal", "the proposal log distinguishes this refusal from an accepted action that later produces no effect" ], "diagnostics": [ "{{instance}}-proposal-log", "{{instance}}-state-before-after" ] }, "text": "{{row.id}} overrides or repeats the default answer with nothing-changes: it creates no event, changes no game state, spends no cost, and advances no clock because of the refusal. {{row.declared-in}} identifies the case; the test names the address and restates nothing from it." }, { "id": "rejection-case-cost-taken", "title": "{{row.id}} refuses the proposal with cost-taken", "type": "scenario", "expand": "per-row", "collection": "rejection-cases", "when": { "row": { "result": [ "cost-taken" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "a proposal that meets the refusal case at {{row.declared-in}} with a distinguishable complete declared cost", "when": [ "the proposal is checked" ], "then": [ "the proposal ends without creating an event", "the complete declared cost is applied once, no action effect is produced, and no clock advances because of the refusal", "the proposal log distinguishes refusal with cost from acceptance followed by failure" ], "diagnostics": [ "{{instance}}-proposal-log", "{{instance}}-cost-log" ] }, "text": "{{row.id}} refuses the proposal and applies the complete declared cost once, creates no event, produces no action effect, and advances no clock because of the refusal. {{row.declared-in}} identifies the case; the test names the address and restates nothing from it." }, { "id": "rejection-case-clock-advances", "title": "{{row.id}} refuses the proposal and advances its cited clock", "type": "scenario", "expand": "per-row", "collection": "rejection-cases", "when": { "row": { "result": [ "clock-advances" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "a proposal that meets the refusal case at {{row.declared-in}} and a distinguishable clock state governed at {{row.clock-rule-declared-in}}", "when": [ "the proposal is checked" ], "then": [ "the proposal ends without creating an event", "the clock selected by {{row.clock-rule-declared-in}} advances once, no cost is applied, and no action effect is produced", "the proposal log distinguishes this advance, which the refusal causes, from time that advances independently" ], "diagnostics": [ "{{instance}}-proposal-log", "{{instance}}-clock-trace" ] }, "text": "{{row.id}} refuses the proposal, spends no cost, produces no action effect, and advances once the clock selected by {{row.clock-rule-declared-in}}. The test demands that observable consequence, names the address, and restates nothing from it or {{row.declared-in}}." }, { "id": "rejection-case-cost-and-clock", "title": "{{row.id}} refuses the proposal with its cost and cited clock advance", "type": "scenario", "expand": "per-row", "collection": "rejection-cases", "when": { "row": { "result": [ "cost-and-clock" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "a proposal that meets the refusal case at {{row.declared-in}}, its complete declared cost, and a distinguishable clock state governed at {{row.clock-rule-declared-in}}", "when": [ "the proposal is checked" ], "then": [ "the proposal ends without creating an event", "the complete declared cost is applied once and the clock selected by {{row.clock-rule-declared-in}} advances once", "no action effect is produced and the proposal log distinguishes refusal from acceptance" ], "diagnostics": [ "{{instance}}-proposal-log", "{{instance}}-cost-log", "{{instance}}-clock-trace" ] }, "text": "{{row.id}} refuses the proposal, applies the complete declared cost once, advances once the clock selected by {{row.clock-rule-declared-in}}, and produces no action effect. The test names both addresses and restates nothing from them." }, { "id": "rejection-case-derates-and-enters-lifecycle", "title": "{{row.id}} accepts a scaled action", "type": "scenario", "expand": "per-row", "collection": "rejection-cases", "when": { "row": { "result": [ "derate" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "a proposal that meets the case at {{row.declared-in}} and can be scaled by {{row.scale-rule-declared-in}}", "when": [ "the proposal is checked and the accepted event settles" ], "then": [ "the scale rule at {{row.scale-rule-declared-in}} produces the action's complete scaled effect and cost", "the proposal is recorded as accepted, not refused, creates one payload once, and continues through the event lifecycle", "the proposal log distinguishes the accepted scaled action from a refused action" ], "diagnostics": [ "{{instance}}-proposal-log", "{{instance}}-event-trace", "{{instance}}-cost-log" ] }, "text": "{{row.id}} accepts a scaled action and does not refuse it. {{row.scale-rule-declared-in}} supplies the scale; the accepted action creates one payload once and continues through the event lifecycle. The test names both addresses and restates nothing from them." }, { "id": "rejection-default-applies-without-row", "title": "the default answer to rejected-action-effect governs cases without rows", "type": "scenario", "expand": "once", "when": { "flag": { "rejected-action-effect": [ "nothing-changes", "cost-taken", "not-applicable" ] } }, "bindings": { "result": { "flag": "rejected-action-effect", "map": { "nothing-changes": "each such proposal ends without an event, changes no state, spends no cost, and advances no clock because of the refusal. The proposal log distinguishes refusal from ordinary acceptance. Where no such refused proposal exists, this test checks nothing.", "cost-taken": "each such proposal ends without an event, applies its complete declared cost once, produces no effect, and advances no clock because of the refusal. The proposal log distinguishes refusal from ordinary acceptance. Where no such refused proposal exists, this test checks nothing.", "not-applicable": "no proposal that this adoption covers has a refusal branch; every proposal is admitted and the proposal log records each as an ordinary acceptance" } }, "given": { "flag": "rejected-action-effect", "map": { "nothing-changes": "each refused proposal that matches no rejection-cases row", "cost-taken": "each refused proposal that matches no rejection-cases row", "not-applicable": "each proposal this adoption governs" } }, "text": { "flag": "rejected-action-effect", "map": { "nothing-changes": "For every refused proposal with no matching rejection-cases row, the default answer applies once: the proposal ends without an event, changes no state, spends no cost, and advances no clock because of the refusal. Where no such refused proposal exists, this test checks nothing.", "cost-taken": "For every refused proposal with no matching rejection-cases row, the default answer applies once: the proposal ends without an event, applies its complete declared cost once, produces no effect, and advances no clock because of the refusal. Where no such refused proposal exists, this test checks nothing.", "not-applicable": "No proposal that this adoption covers has a refusal branch: every proposal is admitted, and the proposal log records each as an ordinary acceptance." } } }, "test": { "type": "scenario", "given": "{{bind:given}}", "when": [ "the proposal is checked" ], "then": [ "{{bind:result}}" ], "diagnostics": [ "{{instance}}-proposal-log", "{{instance}}-cost-log", "{{instance}}-clock-trace" ] }, "text": "{{bind:text}}" }, { "id": "rejection-is-repeatable-from-identical-state", "title": "a refused proposal is repeatable from identical state", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "two executions of each refused proposal the adoption can construct from identical recorded pre-attempt states", "when": [ "the proposal is checked in each execution" ], "then": [ "both executions produce the same refusal result and the same recorded cost and clock consequence", "the comparison starts from identical pre-attempt state rather than the state left by the first execution", "where no refused proposal exists, this test checks nothing" ], "diagnostics": [ "{{instance}}-proposal-log", "{{instance}}-state-before-after" ] }, "text": "The same proposal refused from an identical pre-attempt state produces the same result. The comparison resets the whole pre-attempt state; it does not repeat from state changed by an earlier attempt." }, { "id": "accepted-proposal-creates-one-event", "title": "an accepted proposal commits once and creates one event", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "a valid proposal with distinguishable payload values, event class, due instant, and an ordinary cost where its Fixed rule declares one", "when": [ "the proposal is accepted and its event is admitted", "where the adoption can construct later source loss, the source becomes unavailable before a captured value is used" ], "then": [ "where an ordinary cost is declared, it is committed once at the point its Fixed game rule names. Otherwise this test checks nothing about the cost.", "one event payload is created once and enters its declared event class at its due instant", "the payload contains every value that must stay available after a later loss of the source, while uncaptured state is read only when an effect resolves", "where later source loss cannot be constructed, this test checks nothing about the values that must stay available after source loss" ], "diagnostics": [ "{{instance}}-proposal-log", "{{instance}}-cost-log", "{{instance}}-waiting-set", "{{instance}}-event-trace" ] }, "text": "An accepted proposal creates one payload once and enters its declared event class at its due instant. Where it has an ordinary cost, that cost commits once at the point its rule names. Otherwise this test checks nothing about the cost. The payload captures every value that must stay available after a later loss of the source. Where no such loss can occur, this test checks nothing about those values." }, { "id": "new-event-uses-one-admission-path", "title": "a new event uses the interrupt path or caused-event path", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "events created after an instant opens, including valid declared interrupts and other new events where the adoption can construct them", "when": [ "each new event is admitted" ], "then": [ "an event backed by a valid interrupts row enters only through the interrupt path and is governed by interrupt-entry", "every other new event due now follows caused-events", "For a branch that the adoption cannot construct, this test checks nothing. No event uses both paths." ], "diagnostics": [ "{{instance}}-proposal-log", "{{instance}}-interrupt-report", "{{instance}}-caused-event-report" ] }, "text": "After an instant opens, a valid declared interrupt enters only through the interrupt path. Every other newly created event due now follows caused-events. For a branch that the adoption cannot construct, this test checks nothing. No event uses both paths." }, { "id": "lowest-eligible-rank-resolves-first", "title": "the lowest eligible rank resolves first", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "each instant the adoption can construct with eligible waiting events from at least two declared ranks", "when": [ "the next waiting event is selected repeatedly" ], "then": [ "each selection comes from the lowest rank that is eligible at that selection", "selection does not change the selected event's payload", "where no instant has two eligible ranks, this test checks nothing about the order of ranks" ], "diagnostics": [ "{{instance}}-waiting-set", "{{instance}}-order-trace" ] }, "text": "At every selection, the lowest eligible rank resolves first without changing the selected event's payload. Where no instant has two eligible ranks, this test checks nothing about the order of ranks. Step 4 selects the lowest eligible rank; step 5 selects within the class without changing the payload." }, { "id": "event-class-never-passes-lower-rank", "title": "{{row.id}} at rank {{row.rank}} never passes a lower rank", "type": "scenario", "expand": "per-row", "collection": "event-classes", "bindings": {}, "test": { "type": "scenario", "given": "an eligible {{row.id}} event and an eligible event of a lower declared rank in the same instant", "when": [ "the waiting set is selected" ], "then": [ "the lower-rank event is selected before the {{row.id}} event", "where no lower-rank event is eligible with {{row.id}}, this test checks nothing" ], "diagnostics": [ "{{instance}}-waiting-set", "{{instance}}-order-trace" ] }, "text": "An event of {{row.id}} at rank {{row.rank}} never resolves before an eligible lower-rank event in the same instant. Where the adoption cannot construct that pairing, this test checks nothing." }, { "id": "within-class-stable-index", "title": "{{row.class-id}} uses stable index order", "type": "scenario", "expand": "per-row", "collection": "within-class-rules", "when": { "row": { "order": [ "stable-index" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "two eligible {{row.class-id}} events with different {{row.index-name}} values, plus equal first values where the row names a second index and the adoption can construct them", "when": [ "their within-class order is selected" ], "then": [ "the event with the lower {{row.index-name}} resolves first", "where the row names a second index, equal first numbers resolve by the lower second number; otherwise equal first numbers cannot arise or cannot change the result", "the order trace distinguishes selection by stable index from selection by rank or container order" ], "diagnostics": [ "{{instance}}-order-trace" ] }, "text": "Within {{row.class-id}}, lower {{row.index-name}} resolves first. Where the row names a second index, equal first numbers resolve by it; otherwise equal first numbers cannot arise or cannot change the result." }, { "id": "within-class-arrival-order", "title": "{{row.class-id}} uses stable arrival order", "type": "scenario", "expand": "per-row", "collection": "within-class-rules", "when": { "row": { "order": [ "arrival-order" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "two eligible {{row.class-id}} events admitted at distinguishable times in one instant", "when": [ "their within-class order is selected more than once during the instant" ], "then": [ "the earlier admitted event resolves first", "admission order remains stable for the complete instant and never changes with container order" ], "diagnostics": [ "{{instance}}-proposal-log", "{{instance}}-order-trace" ] }, "text": "Within {{row.class-id}}, earlier admission resolves first, and admission order remains stable for the complete instant." }, { "id": "within-class-map-reading-order", "title": "{{row.class-id}} follows its cited map reading order", "type": "scenario", "expand": "per-row", "collection": "within-class-rules", "when": { "row": { "order": [ "map-reading-order" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "eligible {{row.class-id}} events in different rows and columns of the grid cited at {{row.grid-declared-in}}", "when": [ "their within-class order is selected" ], "then": [ "the event in the grid's own first row resolves first and, within one row, the event in its own first column resolves first", "the order trace attributes the result to map reading order rather than container order" ], "diagnostics": [ "{{instance}}-order-trace" ] }, "text": "Within {{row.class-id}}, the grid at {{row.grid-declared-in}} supplies its own first row and first column. The first row resolves first, then the first column. The test names the address and restates nothing from it." }, { "id": "within-class-clockwise-order", "title": "{{row.class-id}} follows its cited clockwise order", "type": "scenario", "expand": "per-row", "collection": "within-class-rules", "when": { "row": { "order": [ "clockwise" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "eligible {{row.class-id}} events around the center and first direction of the grid at {{row.grid-declared-in}}, including equal angle and distance", "when": [ "their within-class order is selected" ], "then": [ "events resolve by clockwise angle from the grid's center and first direction", "equal angle and distance resolve by lower {{row.index-name}}", "the order trace attributes the result to clockwise order and its stable-index tie-break" ], "diagnostics": [ "{{instance}}-order-trace" ] }, "text": "Within {{row.class-id}}, the grid at {{row.grid-declared-in}} supplies the center, first direction, and clockwise sense. Clockwise angle orders the events, and lower {{row.index-name}} decides between events at an equal angle and distance. The test names the address and restates nothing from it." }, { "id": "within-class-no-visible-order", "title": "{{row.class-id}} exposes no within-class order", "type": "scenario", "expand": "per-row", "collection": "within-class-rules", "when": { "row": { "order": [ "no-visible-order" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "every permitted execution order of eligible {{row.class-id}} events from the same pre-instant state", "when": [ "the instant settles under each permitted order" ], "then": [ "no {{row.class-id}} event observes another event of that class during the instant", "every permitted order produces the same game state and player-facing result", "where two such events cannot be ready together, this test checks nothing" ], "diagnostics": [ "{{instance}}-order-trace", "{{instance}}-settlement-report" ] }, "text": "{{row.class-id}} exposes no within-class order: no event observes another of that class, and every permitted order yields the same game state and player-facing result. If two such events cannot be ready together, this test checks nothing." }, { "id": "within-class-declared-random-order", "title": "{{row.class-id}} uses its cited random order", "type": "scenario", "expand": "per-row", "collection": "within-class-rules", "when": { "row": { "order": [ "declared-random" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "eligible {{row.class-id}} events and recorded random inputs for the rule at {{row.rule-declared-in}}", "when": [ "the rule produces their within-class order" ], "then": [ "one total order is produced for the instant and the events resolve in it", "container order never selects or changes the result", "the order trace records the cited rule and the order it produced" ], "diagnostics": [ "{{instance}}-order-trace", "{{instance}}-random-record" ] }, "text": "Within {{row.class-id}}, the random rule at {{row.rule-declared-in}} produces one total order for the instant; container order never decides it. The test demands the produced order and restates nothing from the cited rule." }, { "id": "within-class-game-rule-order", "title": "{{row.class-id}} uses its cited game rule order", "type": "scenario", "expand": "per-row", "collection": "within-class-rules", "when": { "row": { "order": [ "game-rule" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "eligible {{row.class-id}} events whose order is governed at {{row.rule-declared-in}}", "when": [ "their within-class order is selected" ], "then": [ "the cited rule produces one total deterministic order and the events resolve in it", "container order never selects or changes the result", "the order trace records the cited rule and produced order" ], "diagnostics": [ "{{instance}}-order-trace" ] }, "text": "Within {{row.class-id}}, {{row.rule-declared-in}} produces one total deterministic order; container order never decides it. The test demands the produced order and restates nothing from the cited rule." }, { "id": "rank-tie-stable-index", "title": "{{row.id}} orders its tied classes by stable index", "type": "scenario", "expand": "per-row", "collection": "rank-ties", "when": { "row": { "tie-break": [ "stable-index" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "eligible events of the classes listed by {{row.class-ids}} at shared rank {{row.rank}} with different {{row.index-name}} values, plus equal first values where the row names a second index", "when": [ "the shared-rank order is selected" ], "then": [ "one total order over all events of all listed classes is produced with lower {{row.index-name}} first", "where the row names a second index, equal first numbers resolve by the lower second number; otherwise equal first numbers cannot arise or cannot change the result", "the order trace distinguishes the rank tie from ordinary within-class selection" ], "diagnostics": [ "{{instance}}-order-trace" ] }, "text": "At rank {{row.rank}}, {{row.id}} produces one total order over {{row.class-ids}} with lower {{row.index-name}} first. Where the row names a second index, equal first numbers resolve by it; otherwise equal first numbers cannot arise or cannot change the result." }, { "id": "rank-tie-arrival-order", "title": "{{row.id}} orders its tied classes by stable arrival", "type": "scenario", "expand": "per-row", "collection": "rank-ties", "when": { "row": { "tie-break": [ "arrival-order" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "events of the classes listed by {{row.class-ids}} admitted at distinguishable times at shared rank {{row.rank}}", "when": [ "the shared-rank order is selected" ], "then": [ "one total order over all events of all listed classes is produced with earlier admission first", "admission order remains stable for the complete instant" ], "diagnostics": [ "{{instance}}-proposal-log", "{{instance}}-order-trace" ] }, "text": "At rank {{row.rank}}, {{row.id}} produces one total order over {{row.class-ids}} with earlier admission first, and admission order stays stable for the instant." }, { "id": "rank-tie-map-reading-order", "title": "{{row.id}} follows its cited map reading order", "type": "scenario", "expand": "per-row", "collection": "rank-ties", "when": { "row": { "tie-break": [ "map-reading-order" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "eligible events of {{row.class-ids}} in different rows and columns of the grid at {{row.grid-declared-in}}", "when": [ "the shared-rank order is selected" ], "then": [ "one total order over all events of all listed classes follows the grid's own first row and then its own first column", "the order trace distinguishes the rank tie from container order" ], "diagnostics": [ "{{instance}}-order-trace" ] }, "text": "For {{row.id}}, the grid at {{row.grid-declared-in}} supplies its own first row and first column and produces one total order over {{row.class-ids}}. The test names the address and restates nothing from it." }, { "id": "rank-tie-clockwise-order", "title": "{{row.id}} follows its cited clockwise order", "type": "scenario", "expand": "per-row", "collection": "rank-ties", "when": { "row": { "tie-break": [ "clockwise" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "eligible events of {{row.class-ids}} around the center and first direction of {{row.grid-declared-in}}, including equal angle and distance", "when": [ "the shared-rank order is selected" ], "then": [ "one total order over all events of all listed classes follows clockwise angle from the grid's center and first direction", "equal angle and distance resolve by lower {{row.index-name}}" ], "diagnostics": [ "{{instance}}-order-trace" ] }, "text": "For {{row.id}}, {{row.grid-declared-in}} supplies the center, first direction, and clockwise sense for one total order over {{row.class-ids}}; lower {{row.index-name}} decides between events at an equal angle and distance. The test names the address and restates nothing from it." }, { "id": "rank-tie-no-visible-order", "title": "{{row.id}} exposes no shared-rank order", "type": "scenario", "expand": "per-row", "collection": "rank-ties", "when": { "row": { "tie-break": [ "no-visible-order" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "every permitted total order of eligible events from {{row.class-ids}} at rank {{row.rank}}", "when": [ "the instant settles under each permitted order" ], "then": [ "no event in the tied classes observes another tied event during the instant", "every permitted total order produces the same game state and player-facing result", "where events from two listed classes cannot be ready together, this test checks nothing about that pair of classes" ], "diagnostics": [ "{{instance}}-order-trace", "{{instance}}-settlement-report" ] }, "text": "For {{row.id}}, any total order over {{row.class-ids}} is permitted only because no tied event observes another and every permitted order yields the same state and player-facing result. For a pair of classes whose events cannot be ready together, this test checks nothing." }, { "id": "rank-tie-declared-random-order", "title": "{{row.id}} uses its cited random order", "type": "scenario", "expand": "per-row", "collection": "rank-ties", "when": { "row": { "tie-break": [ "declared-random" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "eligible events of {{row.class-ids}} and recorded random inputs for {{row.rule-declared-in}}", "when": [ "the shared-rank order is selected" ], "then": [ "the cited rule produces one total order over all listed classes for the instant and the events resolve in it", "container order never selects or changes the result" ], "diagnostics": [ "{{instance}}-order-trace", "{{instance}}-random-record" ] }, "text": "For {{row.id}}, the random rule at {{row.rule-declared-in}} produces one total order over {{row.class-ids}}; container order never decides it. The test demands the produced order and restates nothing from the cited rule." }, { "id": "rank-tie-game-rule-order", "title": "{{row.id}} uses its cited game rule order", "type": "scenario", "expand": "per-row", "collection": "rank-ties", "when": { "row": { "tie-break": [ "game-rule" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "eligible events of {{row.class-ids}} governed at {{row.rule-declared-in}}", "when": [ "the shared-rank order is selected" ], "then": [ "the cited rule produces one total deterministic order over all listed classes and the events resolve in it", "container order never selects or changes the result" ], "diagnostics": [ "{{instance}}-order-trace" ] }, "text": "For {{row.id}}, {{row.rule-declared-in}} produces one total deterministic order over {{row.class-ids}}; container order never decides it. The test demands the produced order and restates nothing from the cited rule." }, { "id": "general-within-class-order", "title": "the default answer to within-class-order covers classes without another order", "type": "scenario", "expand": "once", "when": { "flag": { "within-class-order": [ "stable-index", "arrival-order", "map-reading-order", "clockwise", "no-visible-order", "declared-random" ] } }, "bindings": { "order": { "flag": "within-class-order", "map": { "stable-index": "the default answer has no named data to compare for such a class, so two ready events cannot arise or cannot change the result", "arrival-order": "earlier admission resolves first and admission order remains stable for the instant", "map-reading-order": "the default answer has no named data to compare for such a class, so two ready events cannot arise or cannot change the result", "clockwise": "the default answer has no named data to compare for such a class, so two ready events cannot arise or cannot change the result", "no-visible-order": "no event observes another of its class and every permitted order produces the same game state and player-facing result", "declared-random": "the default answer has no named data to compare for such a class, so two ready events cannot arise or cannot change the result" } } }, "test": { "type": "scenario", "given": "each event class with no within-class-rules row and no shared rank", "when": [ "two events of that class are ready together where the adoption can construct them" ], "then": [ "{{bind:order}}", "where no such class or pair exists, this test checks nothing" ], "diagnostics": [ "{{instance}}-order-trace", "{{instance}}-settlement-report" ] }, "text": "For every class without a class row and without a shared rank, {{bind:order}}. Where no such class or pair exists, this test checks nothing." }, { "id": "presentation-never-holds-event", "title": "{{row.event-class}} never waits for {{row.presentation-cue}}", "type": "scenario", "expand": "per-row", "collection": "presentation-driven-events", "when": { "flag": { "presentation-timing": [ "never" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "a selected {{row.event-class}} event while {{row.presentation-cue}} is unfinished", "when": [ "presentation waiting is checked" ], "then": [ "the event is admitted immediately and never waits for the cue", "the instant's order and game timing are unchanged by that cue" ], "diagnostics": [ "{{instance}}-order-trace", "{{instance}}-presentation-trace" ] }, "text": "{{row.event-class}} events never wait for {{row.presentation-cue}}. {{row.declared-in}} names the cue rule; the test names the address and restates nothing from it." }, { "id": "presentation-delay-holds-following-events", "title": "{{row.event-class}} waits for {{row.presentation-cue}} without reordering", "type": "scenario", "expand": "per-row", "collection": "presentation-driven-events", "when": { "flag": { "presentation-timing": [ "may-delay" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "a selected {{row.event-class}} event with unfinished {{row.presentation-cue}} and a later eligible event", "when": [ "the cue remains unfinished and then finishes under {{row.declared-in}}" ], "then": [ "the selected event and every event behind it remain held until the cue finishes", "no later event passes it, and the held event then resumes with its original payload", "the instant remains open while the event is held" ], "diagnostics": [ "{{instance}}-waiting-set", "{{instance}}-presentation-trace", "{{instance}}-order-trace" ] }, "text": "An unfinished {{row.presentation-cue}} holds {{row.event-class}} and every event behind it until the cue finishes; none passes it, and the instant cannot close. {{row.declared-in}} names the cue rule; the test names the address and restates nothing from it." }, { "id": "presentation-delay-skips-only-held-event", "title": "{{row.event-class}} may be passed while {{row.presentation-cue}} is unfinished", "type": "scenario", "expand": "per-row", "collection": "presentation-driven-events", "when": { "flag": { "presentation-timing": [ "may-delay-and-reorder" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "a selected {{row.event-class}} event with unfinished {{row.presentation-cue}} and a later eligible event", "when": [ "presentation waiting skips the selected event and the cue later finishes under {{row.declared-in}}" ], "then": [ "only the held event is skipped and selection returns to the waiting set", "the later eligible event resolves before it, while the held event keeps its original payload", "the held event becomes eligible when the cue finishes and the instant remains open until it resolves" ], "diagnostics": [ "{{instance}}-waiting-set", "{{instance}}-presentation-trace", "{{instance}}-order-trace" ] }, "text": "While {{row.presentation-cue}} is unfinished, only the selected {{row.event-class}} event is skipped; later eligible events pass it, its original payload remains, and the instant cannot close. {{row.declared-in}} names the cue rule; the test names the address and restates nothing from it." }, { "id": "unnamed-event-has-no-presentation-wait", "title": "events with no presentation row wait for no cue of their own", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "each selected event class not named by a presentation-driven-events row", "when": [ "presentation waiting is checked" ], "then": [ "the event never waits for a cue of its own; where the adoption answers may-delay and it is behind a held event in the order, it waits with that event; otherwise it is admitted immediately", "where every selected class is named by a presentation row, this test checks nothing" ], "diagnostics": [ "{{instance}}-presentation-trace", "{{instance}}-order-trace" ] }, "text": "A selected event named by no presentation-driven-events row never waits for a cue of its own; where the adoption answers may-delay and it is behind a held event in the order, it waits with that event; otherwise it is admitted immediately. Where every selected class has a row, this test checks nothing. This follows the presentation-timing option semantics and step 6." }, { "id": "terminal-collision-rows-cover-ending-pairs", "title": "declaration check: terminal-collision rows cover every ending pair", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the ending pairs its Fixed rules can construct, not the running game", "when": [ "a reviewer compares every pair with terminal-collisions" ], "then": [ "a terminal-collisions row exists for every pair that can produce a win and a loss at the same instant", "the terminal-collisions when-empty sentence states what holds when no row exists", "When a pair that can be constructed has no row, the adoption is invalid, and this test fails. Where no win and loss can become true at one instant, this test checks nothing." ], "diagnostics": [ "{{instance}}-declaration-record", "{{instance}}-ending-record" ] }, "text": "This declaration check reads the adoption and its Fixed ending rules, not the running game. A terminal-collisions row must exist for every pair of a win and a loss that can become true at one instant. The when-empty sentence of the row set states what holds when no row exists. When a pair that can be constructed has no row, the adoption is invalid, and this test fails. Where no win and loss can become true at one instant, this test checks nothing." }, { "id": "same-target-rows-cover-removal-collisions", "title": "declaration check: same-target rows cover every removal collision", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the target-removal cases its Fixed rules can construct, not the running game", "when": [ "a reviewer compares every target kind with same-target-cases and same-target-exceptions" ], "then": [ "a same-target-cases or same-target-exceptions row exists for every target kind for which two events can each remove one target at one instant", "the when-empty sentences of the two row sets state what holds when no row exists", "When a target kind whose collision can be constructed has no row, the adoption is invalid, and this test fails. Where no such collision can occur, this test checks nothing." ], "diagnostics": [ "{{instance}}-declaration-record", "{{instance}}-collision-report" ] }, "text": "This declaration check reads the adoption and its Fixed removal rules, not the running game. A same-target-cases or same-target-exceptions row must exist for every target kind with a same-instant removal collision. The when-empty sentences of the two row sets state what holds when no row exists. When a target kind whose collision can be constructed has no row, the adoption is invalid, and this test fails. Where no such collision can occur, this test checks nothing. This test says nothing about a shared target with no removal." }, { "id": "caused-event-rows-cover-due-now-causes", "title": "declaration check: caused-event rows cover every cause of an event that is due now", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the causes of non-interrupt events that its Fixed rules can construct, not the running game", "when": [ "a reviewer compares every kind of newly caused event that is due now with caused-event-kinds" ], "then": [ "a caused-event-kinds row exists for every non-interrupt event that is caused and is due in the same instant", "the caused-event-kinds when-empty sentence states what holds when no row exists", "When a caused event that is due now and can be constructed has no row, the adoption is invalid, and this test fails. Where no such event exists, this test checks nothing." ], "diagnostics": [ "{{instance}}-declaration-record", "{{instance}}-caused-event-report" ] }, "text": "This declaration check reads the adoption and its Fixed cause rules, not the running game. A caused-event-kinds row must exist for every non-interrupt event that is caused and is due in the same instant. The when-empty sentence of the row set states what holds when no row exists. When a caused event that is due now and can be constructed has no row, the adoption is invalid, and this test fails. Where no such event exists, this test checks nothing." }, { "id": "interrupt-rows-cover-stops-and-replacements", "title": "declaration check: interrupt rows cover every stop and replacement", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the event interactions its Fixed rules can construct after resolution starts, not the running game", "when": [ "a reviewer compares every stopping or replacement interaction with interrupts" ], "then": [ "an interrupts row exists for every event that stops or replaces another after selection, including before its first effect", "the interrupts when-empty sentence states what holds when no row exists", "When a stopping or replacement interaction that can be constructed has no row, the adoption is invalid, and this test fails. Where no such interaction exists, this test checks nothing." ], "diagnostics": [ "{{instance}}-declaration-record", "{{instance}}-interrupt-report" ] }, "text": "This declaration check reads the adoption and its Fixed interaction rules, not the running game. An interrupts row must exist for every event that stops or replaces another after selection, including before its first effect. The when-empty sentence of the row set states what holds when no row exists. When a stopping or replacement interaction that can be constructed has no row, the adoption is invalid, and this test fails. Where no such interaction exists, this test checks nothing." }, { "id": "same-target-general-resolution", "title": "{{row.target-kind}} uses the default answer to two-events-one-target", "type": "scenario", "expand": "per-row", "collection": "same-target-cases", "when": { "flag": { "two-events-one-target": [ "only-first-resolves", "all-resolve-one-ending", "all-resolve-each-ending" ] } }, "bindings": { "result": { "flag": "two-events-one-target", "map": { "only-first-resolves": "the first ordered event applies to the target and removes it; every later group member applies nothing to that target", "all-resolve-one-ending": "all group members apply to the target in order, removal waits until the complete group ends, and one removal consequence is recorded", "all-resolve-each-ending": "all group members apply in order and each records its own declared removal consequence, even after an earlier member recorded one" } } }, "test": { "type": "scenario", "given": "two events in one instant that can each remove one {{row.target-kind}} under {{row.declared-in}}", "when": [ "their collision group resolves" ], "then": [ "{{bind:result}}", "the collision report distinguishes this result from an orphan result or an ordinary event with no effect" ], "diagnostics": [ "{{instance}}-collision-report", "{{instance}}-event-trace" ] }, "text": "For {{row.target-kind}}, {{bind:result}}. {{row.declared-in}} identifies the collision case; the test names the address and restates nothing from it." }, { "id": "same-target-exception-resolution", "title": "{{row.target-kind}} uses its collision exception", "type": "scenario", "expand": "per-row", "collection": "same-target-exceptions", "when": { "row": { "resolution": [ "only-first-resolves", "all-resolve-one-ending", "all-resolve-each-ending" ] } }, "bindings": { "result": { "row_field": "resolution", "map": { "only-first-resolves": "the first ordered event applies to the target and removes it; every later group member applies nothing to that target", "all-resolve-one-ending": "all group members apply to the target in order, removal waits until the complete group ends, and one removal consequence is recorded", "all-resolve-each-ending": "all group members apply in order and each records its own declared removal consequence, even after an earlier member recorded one" } } }, "test": { "type": "scenario", "given": "two events in one instant that can each remove one {{row.target-kind}} under {{row.declared-in}}", "when": [ "their collision group resolves" ], "then": [ "{{bind:result}}", "this row replaces the default answer only for {{row.target-kind}}", "the collision report distinguishes this result from an orphan result" ], "diagnostics": [ "{{instance}}-collision-report", "{{instance}}-event-trace" ] }, "text": "{{row.target-kind}} is an exception: {{bind:result}}. The row replaces the default answer only for this target kind. {{row.declared-in}} identifies the collision; the test names the address and restates nothing from it." }, { "id": "collision-precedes-orphan-check", "title": "same-target grouping precedes the orphan check", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "each same-target collision group the adoption can construct, plus each non-member event that can resolve before deferred removal", "when": [ "the group is settled and source and target availability are checked" ], "then": [ "the same-target decision is settled before the general orphan check", "removal inside the group never turns another group member into an orphan", "under all-resolve-one-ending, the target remains live for group members and any non-member that resolves before the group ends", "where no such group or no such non-member exists, this test checks nothing about that case" ], "diagnostics": [ "{{instance}}-collision-report", "{{instance}}-orphan-report", "{{instance}}-event-trace" ] }, "text": "For each same-target collision group the adoption can construct, grouping settles before the orphan check and removal inside the group never makes another member an orphan. Under all-resolve-one-ending, the target stays live for members and for a non-member that resolves before the group ends. For a case that the adoption cannot construct, this test checks nothing." }, { "id": "orphan-override-resolves-what-remains", "title": "{{row.id}} resolves what remains", "type": "scenario", "expand": "per-row", "collection": "orphan-cases", "when": { "row": { "resolution": [ "resolves-what-remains" ] } }, "bindings": { "object": { "row_field": "missing", "map": { "source": "source", "target": "target", "source-or-target": "source or target" } } }, "test": { "type": "scenario", "given": "a waiting and then active {{row.event-class}} event whose required {{bind:object}} becomes unavailable under {{row.declared-in}}", "when": [ "availability is checked before the first effect and at every later effect boundary" ], "then": [ "the event keeps its captured payload and skips only effects requiring the missing object", "every independent remaining effect resolves in declared order", "the orphan report distinguishes this route from cancellation and from an event that independently had no applicable effect" ], "diagnostics": [ "{{instance}}-orphan-report", "{{instance}}-event-trace" ] }, "text": "For {{row.id}}, a missing {{bind:object}} leaves the captured payload in place. Only effects needing that object are skipped; every independent effect resolves. {{row.declared-in}} identifies the case; the test names the address and restates nothing from it." }, { "id": "orphan-override-is-canceled", "title": "{{row.id}} is canceled", "type": "scenario", "expand": "per-row", "collection": "orphan-cases", "when": { "row": { "resolution": [ "is-canceled" ] } }, "bindings": { "object": { "row_field": "missing", "map": { "source": "source", "target": "target", "source-or-target": "source or target" } } }, "test": { "type": "scenario", "given": "waiting and active {{row.event-class}} events whose required {{bind:object}} becomes unavailable under {{row.declared-in}}", "when": [ "availability is checked before the first effect and at every later effect boundary" ], "then": [ "a waiting event is removed and an active event discards every remaining effect", "no committed cost or effect is restored", "the orphan report distinguishes cancellation from resolving what remains and from an event that independently produced no effect" ], "diagnostics": [ "{{instance}}-orphan-report", "{{instance}}-event-trace", "{{instance}}-cost-log" ] }, "text": "For {{row.id}}, losing the required {{bind:object}} removes a waiting event or discards an active event's remaining effects. Committed costs and effects remain. {{row.declared-in}} identifies the case; the test names the address and restates nothing from it." }, { "id": "orphan-default-row", "title": "{{row.id}} uses the default answer to orphaned-events", "type": "scenario", "expand": "per-row", "collection": "orphan-cases", "when": { "flag": { "orphaned-events": [ "resolves-what-remains", "is-canceled" ] }, "row": { "resolution": [ "default" ] } }, "bindings": { "object": { "row_field": "missing", "map": { "source": "source", "target": "target", "source-or-target": "source or target" } }, "result": { "flag": "orphaned-events", "map": { "resolves-what-remains": "keeps its captured payload, skips only effects requiring the missing object, and resolves every independent remaining effect", "is-canceled": "is removed while waiting or discards every remaining effect while active, without restoring committed cost or effects" } } }, "test": { "type": "scenario", "given": "a waiting and then active {{row.event-class}} event whose required {{bind:object}} becomes unavailable under {{row.declared-in}}", "when": [ "availability is checked before the first effect and at every later effect boundary" ], "then": [ "the event {{bind:result}}", "the orphan report identifies use of the default answer and distinguishes its observable result from the other route" ], "diagnostics": [ "{{instance}}-orphan-report", "{{instance}}-event-trace", "{{instance}}-cost-log" ] }, "text": "{{row.id}} selects the default answer for a missing {{bind:object}}: the event {{bind:result}}. {{row.declared-in}} identifies the case; the test names the address and restates nothing from it." }, { "id": "undeclared-orphan-is-invalid", "title": "declaration check: an undeclared missing object has no implied result", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "each event that can lose a required source or target while waiting or resolving", "when": [ "a reviewer compares that case with orphan-cases before the build is audited" ], "then": [ "every such case has a matching orphan-cases row", "a missing object outside those rows is an invalid adoption and receives no implied cancellation or remaining-effects result", "When a case is not declared, the adoption is invalid, and this test fails. Where no event can lose a required object, this test checks nothing." ], "diagnostics": [ "{{instance}}-orphan-report", "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption, not the running game. Every event that can lose a required source or target has an orphan-cases row. When an event outside those rows can lose a required object, no result is implied. The adoption is then invalid, and this test fails. Where no event can become an orphan, this test checks nothing." }, { "id": "active-event-commits-effects-in-order", "title": "an active event commits each effect before the next boundary", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "an eligible event with two or more ordered effects where the adoption can construct one", "when": [ "the event becomes active and applies its effects" ], "then": [ "the event visits the boundary before its first effect", "effects are applied in the order stated by the event's Fixed game rule", "each effect commits before the next declared boundary is visited", "where no event with two or more effects exists, this test checks nothing about the boundary between effects" ], "diagnostics": [ "{{instance}}-event-trace", "{{instance}}-interrupt-report" ] }, "text": "An active event visits the boundary before its first effect, applies effects in its Fixed rule's order, and commits each effect before the next boundary. If no event with two or more effects exists, this test checks nothing about the boundary between effects." }, { "id": "interrupt-stops-original", "title": "{{row.id}} enters and stops the original event", "type": "scenario", "expand": "per-row", "collection": "interrupts", "when": { "flag": { "interrupt-entry": [ "before-next-effect", "after-current-effect", "at-normal-rank" ] }, "row": { "result": [ "stop-original" ] } }, "bindings": { "entry": { "flag": "interrupt-entry", "map": { "before-next-effect": "enters before the next effect, including before the first effect", "after-current-effect": "enters after the just-finished effect has committed", "at-normal-rank": "joins this instant when its class is current or has not passed, otherwise joins the next instant, and selection returns to step 4" } }, "result": { "flag": "interrupt-entry", "map": { "before-next-effect": "after it resolves, every remaining original effect is discarded while committed effects and costs remain", "after-current-effect": "after it resolves, every remaining original effect is discarded while committed effects and costs remain", "at-normal-rank": "where the interrupt joins the current instant, every remaining original effect is discarded while committed effects and costs remain; where its class has already passed and it joins the next instant, the active event finishes unchanged in this instant and the interrupt stops only events of {{row.active-class}} still waiting or active when it resolves" } } }, "test": { "type": "scenario", "given": "an active {{row.active-class}} event whose {{row.boundary-granularity}} boundaries are named at {{row.declared-in}}, and a valid {{row.interrupt-class}} interrupt offered at one of them", "when": [ "the valid interrupt is discovered, selected, and resolved" ], "then": [ "one interrupt event is created through the interrupt path and {{bind:entry}}", "where the interrupt enters at a boundary of the active event: when several interrupts are valid, event rank, the shared-rank order, and then within-class order select one; the active event advances only to boundaries {{row.declared-in}} permits while it waits; and the interrupt passes through presentation waiting, collision grouping, orphan checks, and its own boundaries before changing that event", "where the interrupt joins the next instant instead, the active event runs to completion in this one", "{{bind:result}}", "only one selected interrupt resolves at a time and the report distinguishes a valid interrupt from an invalid offer", "where presentation skips the interrupt, control returns to the interrupted event's boundary rather than step 4. Where no such skip is possible, this test checks nothing about a skip." ], "diagnostics": [ "{{instance}}-interrupt-report", "{{instance}}-event-trace", "{{instance}}-cost-log" ] }, "text": "For an active {{row.active-class}} event whose {{row.boundary-granularity}} boundaries are named at {{row.declared-in}}, {{row.id}} creates one valid {{row.interrupt-class}} interrupt offered at a named boundary and {{bind:entry}}. Where the interrupt enters at a boundary of the active event, event order selects one valid interrupt, the active event advances only to permitted boundaries while it waits, and the interrupt passes through steps 6 to 11 before changing that event; where it joins the next instant instead, the active event runs to completion in this one. Then {{bind:result}}. A presentation skip returns to the interrupted boundary. Where no skip is possible, this test checks nothing about a skip. {{row.declared-in}} supplies validity and the finite chain; the test names the address and restates nothing from it." }, { "id": "interrupt-replaces-remaining-effects", "title": "{{row.id}} enters and replaces the remaining effects", "type": "scenario", "expand": "per-row", "collection": "interrupts", "when": { "flag": { "interrupt-entry": [ "before-next-effect", "after-current-effect", "at-normal-rank" ] }, "row": { "result": [ "replace-remaining-effects" ] } }, "bindings": { "entry": { "flag": "interrupt-entry", "map": { "before-next-effect": "enters before the next effect, including before the first effect", "after-current-effect": "enters after the just-finished effect has committed", "at-normal-rank": "joins this instant when its class is current or has not passed, otherwise joins the next instant, and selection returns to step 4" } }, "result": { "flag": "interrupt-entry", "map": { "before-next-effect": "after it resolves, every remaining original effect is discarded and the complete replacement at {{row.replacement-declared-in}} is installed in its stated order while committed effects and costs remain", "after-current-effect": "after it resolves, every remaining original effect is discarded and the complete replacement at {{row.replacement-declared-in}} is installed in its stated order while committed effects and costs remain", "at-normal-rank": "where the interrupt joins the current instant, every remaining original effect is discarded and the complete replacement cited at {{row.replacement-declared-in}} is installed in its stated order while committed effects and costs remain; where its class has already passed and it joins the next instant, the active event finishes unchanged in this instant and the interrupt replaces only events of {{row.active-class}} still waiting or active when it resolves" } } }, "test": { "type": "scenario", "given": "an active {{row.active-class}} event whose {{row.boundary-granularity}} boundaries are named at {{row.declared-in}}, and a valid {{row.interrupt-class}} interrupt offered at one of them", "when": [ "the valid interrupt is discovered, selected, and resolved" ], "then": [ "one interrupt event is created through the interrupt path and {{bind:entry}}", "where the interrupt enters at a boundary of the active event: when several interrupts are valid, event rank, the shared-rank order, and then within-class order select one; the active event advances only to boundaries {{row.declared-in}} permits while it waits; and the interrupt passes through presentation waiting, collision grouping, orphan checks, and its own boundaries before changing that event", "where the interrupt joins the next instant instead, the active event runs to completion in this one", "{{bind:result}}", "only one selected interrupt resolves at a time, and the report distinguishes replacement from an invalid offer", "where presentation skips the interrupt, control returns to the interrupted event's boundary rather than step 4. Where no such skip is possible, this test checks nothing about a skip." ], "diagnostics": [ "{{instance}}-interrupt-report", "{{instance}}-event-trace", "{{instance}}-cost-log" ] }, "text": "For an active {{row.active-class}} event whose {{row.boundary-granularity}} boundaries are named at {{row.declared-in}}, {{row.id}} creates one valid {{row.interrupt-class}} interrupt offered at a named boundary and {{bind:entry}}. Where the interrupt enters at a boundary of the active event, event order selects one valid interrupt, the active event advances only to permitted boundaries while it waits, and the interrupt passes through steps 6 to 11 before changing that event; where it joins the next instant instead, the active event runs to completion in this one. Then {{bind:result}}. A presentation skip returns to the interrupted boundary. Where no skip is possible, this test checks nothing about a skip. The test names both addresses and restates nothing from them." }, { "id": "invalid-interrupt-does-not-enter", "title": "{{row.id}} refuses an invalid interrupt offer", "type": "scenario", "expand": "per-row", "collection": "interrupts", "when": { "flag": { "interrupt-entry": [ "before-next-effect", "after-current-effect", "at-normal-rank" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "an interrupt of {{row.interrupt-class}} offered outside the validity window named at {{row.declared-in}}, or at a point that is not one of the {{row.boundary-granularity}} boundaries", "when": [ "the interrupt offer is checked" ], "then": [ "no interrupt event is created", "the active {{row.active-class}} event advances unchanged", "the interrupt report distinguishes an invalid offer from a valid interrupt that was not selected", "where the adoption cannot construct an invalid offer, this test checks nothing" ], "diagnostics": [ "{{instance}}-interrupt-report", "{{instance}}-event-trace" ] }, "text": "An interrupt of {{row.interrupt-class}} offered outside the validity window named at {{row.declared-in}}, or at a point that is not one of the {{row.boundary-granularity}} boundaries, creates no interrupt event. The active {{row.active-class}} event advances unchanged, and the interrupt report distinguishes the invalid offer from a valid interrupt that was not selected. Where the adoption cannot construct an invalid offer, this test checks nothing." }, { "id": "caused-event-follows-declared-route", "title": "{{row.id}} creates one caused event on its declared route", "type": "scenario", "expand": "per-row", "collection": "caused-event-kinds", "when": { "flag": { "caused-events": [ "resolves-now", "waits-for-its-place", "next-instant" ] } }, "bindings": { "route": { "flag": "caused-events", "map": { "resolves-now": "resolves at the current effect boundary before the active event continues", "waits-for-its-place": "joins its declared class's place in the current instant when that class is current or has not passed, and otherwise joins the next instant", "next-instant": "joins the next instant and none of its effects resolves in the instant that created it" } } }, "test": { "type": "scenario", "given": "an effect that causes {{row.id}} due now under the finite chain rule at {{row.declared-in}}", "when": [ "the causing effect commits and the caused event is admitted" ], "then": [ "one caused event of class {{row.event-class}} is created once and {{bind:route}}", "no chain runs past the bound named at {{row.declared-in}}", "the caused-event report distinguishes this accepted route from refusal and from an interrupt" ], "diagnostics": [ "{{instance}}-caused-event-report", "{{instance}}-event-trace", "{{instance}}-waiting-set" ] }, "text": "{{row.id}} creates one caused event of class {{row.event-class}} once; it {{bind:route}}, and no chain runs past the bound named at {{row.declared-in}}. The test names the address and restates nothing from it." }, { "id": "active-event-finishes-and-loop-continues", "title": "a finished event returns resolution to the waiting set", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "each active event, including a collision-group member where the adoption can construct one", "when": [ "the active event finishes" ], "then": [ "any deferred target removal due at that point is applied and each selected consequence is recorded once", "the event is removed from the waiting set and selection returns to step 4", "the instant continues until the waiting set is empty, waiting for a cited cue when only presentation-held events remain", "where no deferred removal or no held event exists, this test checks nothing about that case" ], "diagnostics": [ "{{instance}}-event-trace", "{{instance}}-waiting-set", "{{instance}}-collision-report" ] }, "text": "Finishing an active event applies any due deferred removal, records each selected consequence once, removes the event, and returns to step 4. The instant continues until the waiting set is empty and waits for any held cue. For a branch that the adoption cannot construct, this test checks nothing." }, { "id": "single-ending-records-after-waiting-set-empties", "title": "a single ending records from final settled state", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "each instant the adoption can construct whose final settled state makes one ending hold outside every declared terminal collision", "when": [ "the waiting set becomes empty and step 15 runs" ], "then": [ "the game's cited ending rule records that ending once from final settled state", "no earlier ending-event resolution or class rank records or overrides it", "where no such single ending can hold, this test checks nothing" ], "diagnostics": [ "{{instance}}-waiting-set", "{{instance}}-ending-record" ] }, "text": "After the waiting set is empty, a single ending that holds in final settled state is recorded once through the game's cited ending rule. Earlier ending-event resolution and class rank do not record or override it. If no single ending can hold, this test checks nothing." }, { "id": "terminal-collision-follows-precedence", "title": "{{row.id}} records its selected ending result", "type": "scenario", "expand": "per-row", "collection": "terminal-collisions", "when": { "flag": { "terminal-precedence": [ "loss-only", "win-only", "both-recorded" ] } }, "bindings": { "ending": { "flag": "terminal-precedence", "map": { "loss-only": "records only the loss and does not record the win", "win-only": "records only the win and does not record the loss", "both-recorded": "records both the win and the loss" } } }, "test": { "type": "scenario", "given": "an instant whose final settled state makes {{row.win-condition}} and {{row.loss-condition}} both hold under {{row.declared-in}}", "when": [ "the waiting set becomes empty and step 15 reads the pair" ], "then": [ "the lifecycle {{bind:ending}}", "the result is unchanged by event rank or the order in which the two conditions were detected", "the ending record distinguishes this terminal collision from single-ending recording" ], "diagnostics": [ "{{instance}}-ending-record", "{{instance}}-settlement-report" ] }, "text": "When {{row.win-condition}} and {{row.loss-condition}} both hold in final settled state, {{row.id}} {{bind:ending}}, regardless of rank or detection order. {{row.declared-in}} identifies the pair; the test names the address and restates nothing from it." }, { "id": "instant-commits-state-and-next-waiting-set-together", "title": "the instant commits state and next-instant work together", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "an instant with distinguishable final state and next-instant waiting events where the adoption can construct them", "when": [ "step 16 closes the instant" ], "then": [ "the final state and next-instant waiting set commit together", "no event from the closed instant later re-enters it", "where no next-instant event exists, this test checks nothing about the members of the next-instant waiting set" ], "diagnostics": [ "{{instance}}-instant-trace", "{{instance}}-waiting-set" ] }, "text": "Step 16 commits final state and the next-instant waiting set together. No event from a closed instant can re-enter it. Where there is no next-instant event, this test checks nothing about the members of the next-instant waiting set." }, { "id": "settlement-report-carries-lifecycle-fields", "title": "each settlement report carries the lifecycle record", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "each event settled by {{instance}}, with optional tie, interrupt, replacement, caused event, removal, and terminal result where present", "when": [ "its settlement report is read" ], "then": [ "the report carries instant, event id, class, rank, tie-break when used, within-class order, source and target availability, effects applied, interrupt and replacement when present, caused-event destination, removal result, and terminal result when present", "for an optional circumstance that the adoption cannot construct, this test checks nothing" ], "diagnostics": [ "{{instance}}-settlement-report" ] }, "text": "Every settlement report carries the instant, event id, class, rank, tie-break when used, within-class order, source and target availability, applied effects, interrupt and replacement when present, caused-event destination, removal result, and terminal result when present. For an optional circumstance that the adoption cannot construct, this test checks nothing." }, { "id": "within-class-row-class-join", "title": "declaration check: {{row.class-id}} names an existing event class", "type": "scenario", "expand": "per-row", "collection": "within-class-rules", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption document, not the running game", "when": [ "a reviewer compares {{row.class-id}} with event-classes ids" ], "then": [ "{{row.class-id}} names exactly one event-classes row in this adoption. In any other case, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption, not the running game. {{row.class-id}} must name exactly one event class in this adoption. In any other case, the adoption is invalid, and this test fails." }, { "id": "presentation-row-class-join", "title": "declaration check: {{row.event-class}} names an existing event class", "type": "scenario", "expand": "per-row", "collection": "presentation-driven-events", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption document, not the running game", "when": [ "a reviewer compares {{row.event-class}} with event-classes ids" ], "then": [ "{{row.event-class}} names exactly one event-classes row in this adoption. In any other case, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption, not the running game. {{row.event-class}} must name exactly one event class in this adoption. In any other case, the adoption is invalid, and this test fails." }, { "id": "caused-row-class-join", "title": "declaration check: {{row.event-class}} names an existing event class", "type": "scenario", "expand": "per-row", "collection": "caused-event-kinds", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption document, not the running game", "when": [ "a reviewer compares {{row.event-class}} with event-classes ids" ], "then": [ "{{row.event-class}} names exactly one event-classes row in this adoption. In any other case, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption, not the running game. {{row.event-class}} must name exactly one event class in this adoption. In any other case, the adoption is invalid, and this test fails." }, { "id": "orphan-row-class-join", "title": "declaration check: {{row.event-class}} names an existing event class", "type": "scenario", "expand": "per-row", "collection": "orphan-cases", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption document, not the running game", "when": [ "a reviewer compares {{row.event-class}} with event-classes ids" ], "then": [ "{{row.event-class}} names exactly one event-classes row in this adoption. In any other case, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption, not the running game. {{row.event-class}} must name exactly one event class in this adoption. In any other case, the adoption is invalid, and this test fails." }, { "id": "interrupt-active-class-join", "title": "declaration check: {{row.active-class}} names an existing event class", "type": "scenario", "expand": "per-row", "collection": "interrupts", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption document, not the running game", "when": [ "a reviewer compares {{row.active-class}} with event-classes ids" ], "then": [ "{{row.active-class}} names exactly one event-classes row in this adoption. In any other case, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption, not the running game. {{row.active-class}} must name exactly one event class in this adoption. In any other case, the adoption is invalid, and this test fails." }, { "id": "interrupt-class-join", "title": "declaration check: {{row.interrupt-class}} names an existing event class", "type": "scenario", "expand": "per-row", "collection": "interrupts", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption document, not the running game", "when": [ "a reviewer compares {{row.interrupt-class}} with event-classes ids" ], "then": [ "{{row.interrupt-class}} names exactly one event-classes row in this adoption. In any other case, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption, not the running game. {{row.interrupt-class}} must name exactly one event class in this adoption. In any other case, the adoption is invalid, and this test fails." }, { "id": "rank-tie-rows-match-shared-ranks", "title": "declaration check: shared ranks and rank-tie rows match exactly", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption document, not the running game", "when": [ "a reviewer groups event-classes rows by rank and compares the groups with rank-ties rows" ], "then": [ "every rank shared by two or more event classes has exactly one rank-ties row, and every rank-ties row names a rank shared by at least two event classes", "each rank-ties class-ids string lists every event-classes id at that rank and no other id; the class-ids description requires each id to be listed once", "In any other case, the adoption is invalid, and this test fails. When no rank is shared and no rank-ties row exists, this test checks nothing." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption, not the running game. Shared ranks and rank-ties rows must match exactly: one row for each shared rank, and one shared rank for each row. Each comma-separated class-ids string lists every event class at that rank and no other class; the class-ids description requires each id to be listed once. In any other case, the adoption is invalid, and this test fails. With no shared rank and no row, this test checks nothing." }, { "id": "tied-classes-have-no-within-class-row", "title": "declaration check: tied classes have no class-specific order row", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption document, not the running game", "when": [ "a reviewer compares every class named by rank-ties with within-class-rules class-id fields" ], "then": [ "no event class named by a rank-ties row has a within-class-rules row", "When a tied class has a within-class-rules row, that row has no effect. The adoption is then invalid, and this test fails. With no rank tie, this test checks nothing." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption, not the running game. A class already ordered by a rank-ties row must have no within-class-rules row. When such a class has one, that row has no effect. The adoption is then invalid, and this test fails. With no rank tie, this test checks nothing." }, { "id": "same-target-kinds-do-not-overlap", "title": "declaration check: collision cases and exceptions do not overlap", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption document, not the running game", "when": [ "a reviewer compares target-kind across same-target-cases and same-target-exceptions" ], "then": [ "no target kind is named in both row sets", "When a target kind is named in both row sets, the adoption is invalid, and this test fails. When either set is empty, this test checks nothing." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption, not the running game. same-target-cases and same-target-exceptions must not name the same target kind. When a target kind is named in both row sets, the adoption is invalid, and this test fails. With either set empty, this test checks nothing." }, { "id": "only-first-needs-visible-order", "title": "declaration check: only-first collisions have a visible order", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption document, not the running game", "when": [ "a reviewer finds every event class that can supply two events to a collision resolved by only-first-resolves through the default answer to two-events-one-target or a same-target-exceptions row" ], "then": [ "every such class has a visible order: a within-class-rules row whose order is not no-visible-order, a rank-ties row whose tie-break is not no-visible-order, or a default answer to within-class-order other than no-visible-order", "In any other case, the adoption is invalid, and this test fails. Where no target kind is resolved by only-first-resolves, this test checks nothing." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption, not the running game. Every event class that can supply two events to a collision resolved by only-first-resolves, through the default answer to two-events-one-target or a same-target-exceptions row, must have a visible order from its class row, its rank tie, or the default answer to within-class-order. When such a class has no visible order, the adoption is invalid, and this test fails. Where no target kind uses only-first-resolves, this test checks nothing. The only-first-resolves semantics states this duty." }, { "id": "same-target-exception-differs-from-general", "title": "declaration check: each same-target exception differs from the default answer", "type": "scenario", "expand": "once", "when": { "flag": { "two-events-one-target": [ "only-first-resolves", "all-resolve-one-ending", "all-resolve-each-ending" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption document, not the running game", "when": [ "a reviewer compares every same-target-exceptions resolution with the default answer to two-events-one-target" ], "then": [ "no same-target-exceptions row names the same resolution as the default answer", "When an exception row repeats the default answer, that row has no effect. The adoption is then invalid, and this test fails. With no exception row, this test checks nothing." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption, not the running game. No same-target-exceptions row may repeat the default answer to two-events-one-target. When a row repeats it, that row has no effect. The adoption is then invalid, and this test fails. With no exception row, this test checks nothing. The same-target-exceptions description states this duty." }, { "id": "stable-index-second-index-duty", "title": "declaration check: stable indexes settle equal first numbers", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption document and its Fixed event rules, not the running game", "when": [ "a reviewer checks every within-class-rules row and every rank-ties row using stable-index" ], "then": [ "every such row either names a second index or belongs to a class or tied group that cannot produce equal first numbers that change the result", "In any other case, the adoption is invalid, and this test fails. With no stable-index row, this test checks nothing." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and its Fixed event rules, not the running game. Every stable-index class row or rank tie must name a second index or belong to a class or tied group that cannot produce equal first numbers that change the result. In any other case, the adoption is invalid, and this test fails. With no stable-index row, this test checks nothing." }, { "id": "visible-tie-needs-class-row", "title": "declaration check: visible ties have class rows when named data is needed", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption document and the event classes its Fixed rules can tie visibly, not the running game", "when": [ "a reviewer compares each such class outside a rank tie with within-class-rules and the default answer to within-class-order" ], "then": [ "every class that can have a visible tie and is not in a rank tie has a within-class-rules row when the default answer needs named data: stable-index, map-reading-order, clockwise, or declared-random", "In any other case, the adoption is invalid, and this test fails. Where the default answer is arrival-order or no-visible-order, or no such class exists, this test checks nothing." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and its Fixed event rules, not the running game. A class that can have a visible tie outside a rank tie must have a within-class-rules row when the default answer is stable-index, map-reading-order, clockwise, or declared-random. In any other case, the adoption is invalid, and this test fails. For arrival-order or no-visible-order, or with no such class, this test checks nothing." }, { "id": "rejection-default-citations-have-rows", "title": "declaration check: a default answer that needs a citation has a row for every case", "type": "scenario", "expand": "once", "when": { "flag": { "rejected-action-effect": [ "derate", "clock-advances", "cost-and-clock" ] } }, "bindings": { "duty": { "flag": "rejected-action-effect", "map": { "derate": "a scale-rule-declared-in citation", "clock-advances": "a clock-rule-declared-in citation", "cost-and-clock": "a clock-rule-declared-in citation" } } }, "test": { "type": "scenario", "given": "the {{instance}} adoption document and every proposal case that can take the default answer, not the running game", "when": [ "a reviewer compares those cases with rejection-cases rows" ], "then": [ "every case that can take the default answer has a rejection-cases row carrying {{bind:duty}}", "When a row or its citation is missing, the adoption is invalid, and this test fails. Where no case can take the default answer, this test checks nothing." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption, not the running game. Every case that can take this default answer must have a rejection-cases row carrying {{bind:duty}}. When a row or its citation is missing, the adoption is invalid, and this test fails. If no case can take the default answer, this test checks nothing." }, { "id": "event-class-list-is-complete", "title": "declaration check: event-classes covers every event due at an instant", "type": "scenario", "expand": "once", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and its Fixed event rules, not the running game", "when": [ "a reviewer compares every event due at an instant with event-classes" ], "then": [ "every event due at an instant belongs to exactly one event-classes row", "a game whose source convention is higher-first has inverted its authored numbers once in event-classes rather than reversing them at runtime", "When an event class is omitted, or a list of simulation stages is presented as classes, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and its Fixed event rules, not the running game. event-classes must cover every event due at an instant exactly once, must name event classes rather than simulation stages, and must invert authored numbers once when the game's source convention is higher-first. When a class is omitted, when simulation stages are presented as classes, or when the numbers are reversed at runtime, the adoption is invalid, and this test fails." }, { "id": "event-class-citation-states-membership", "title": "declaration check: the citation for {{row.id}} names its class and members", "type": "scenario", "expand": "per-row", "collection": "event-classes", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the prose at {{row.declared-in}}, not the running game", "when": [ "a reviewer checks the citation's meaning" ], "then": [ "{{row.declared-in}} names {{row.id}}, labeled {{row.label}} in the game's own words, and the events belonging to it", "When the citation means something else, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and {{row.declared-in}}, not the running game. The citation must name {{row.id}}, labeled {{row.label}} in the game's own words, and the events belonging to it. When the citation means something else, the adoption is invalid, and this test fails. The test names the address and restates nothing from it." }, { "id": "within-class-grid-citation-duty", "title": "declaration check: the grid citation for {{row.id}} supplies what its order needs from the grid", "type": "scenario", "expand": "per-row", "collection": "within-class-rules", "when": { "row": { "order": [ "map-reading-order", "clockwise" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the prose at {{row.grid-declared-in}}, not the running game", "when": [ "a reviewer checks the cited Grid and direction rule" ], "then": [ "the citation supplies the row's required first row and first column, or center, first direction, and clockwise sense", "When the citation does not meet this requirement, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and {{row.grid-declared-in}}, not the running game. The citation must supply what the order selected by {{row.id}} needs from the grid: the first row and first column, or the center, first direction, and clockwise sense. When the citation does not meet this requirement, the adoption is invalid, and this test fails. The test names the address and restates nothing from it." }, { "id": "within-class-rule-citation-duty", "title": "declaration check: the rule citation for {{row.id}} supplies one total order", "type": "scenario", "expand": "per-row", "collection": "within-class-rules", "when": { "row": { "order": [ "declared-random", "game-rule" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the prose at {{row.rule-declared-in}}, not the running game", "when": [ "a reviewer checks the cited random or custom order rule" ], "then": [ "the citation supplies the complete draw or deterministic rule that produces one total order for the instant and never points back to this row", "When the citation does not meet this requirement, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and {{row.rule-declared-in}}, not the running game. The citation must supply one complete total-order rule and never point back to this row. When the citation does not meet this requirement, the adoption is invalid, and this test fails. The test names the address and restates nothing from it." }, { "id": "rank-tie-grid-citation-duty", "title": "declaration check: the grid citation for {{row.id}} supplies what its order needs from the grid", "type": "scenario", "expand": "per-row", "collection": "rank-ties", "when": { "row": { "tie-break": [ "map-reading-order", "clockwise" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the prose at {{row.grid-declared-in}}, not the running game", "when": [ "a reviewer checks the cited Grid and direction rule" ], "then": [ "the citation supplies the row's required first row and first column, or center, first direction, and clockwise sense", "When the citation does not meet this requirement, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and {{row.grid-declared-in}}, not the running game. The citation must supply what the order selected by {{row.id}} needs from the grid: the first row and first column, or the center, first direction, and clockwise sense. When the citation does not meet this requirement, the adoption is invalid, and this test fails. The test names the address and restates nothing from it." }, { "id": "rank-tie-rule-citation-duty", "title": "declaration check: the rule citation for {{row.id}} supplies one total order", "type": "scenario", "expand": "per-row", "collection": "rank-ties", "when": { "row": { "tie-break": [ "declared-random", "game-rule" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the prose at {{row.rule-declared-in}}, not the running game", "when": [ "a reviewer checks the cited random or custom order rule" ], "then": [ "the citation supplies the complete draw or deterministic rule that produces one total order for the instant and never points back to this row", "When the citation does not meet this requirement, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and {{row.rule-declared-in}}, not the running game. The citation must supply one complete total-order rule and never point back to this row. When the citation does not meet this requirement, the adoption is invalid, and this test fails. The test names the address and restates nothing from it." }, { "id": "rejection-scale-citation-duty", "title": "declaration check: the scale citation for {{row.id}} covers effect and cost", "type": "scenario", "expand": "per-row", "collection": "rejection-cases", "when": { "row": { "result": [ "derate" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the prose at {{row.scale-rule-declared-in}}, not the running game", "when": [ "a reviewer checks the cited scale rule" ], "then": [ "the citation supplies how the complete effect and cost are scaled", "When the citation does not meet this requirement, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and {{row.scale-rule-declared-in}}, not the running game. The citation must scale the complete effect and cost. When the citation does not meet this requirement, the adoption is invalid, and this test fails. The test names the address and restates nothing from it." }, { "id": "rejection-clock-citation-duty", "title": "declaration check: the clock citation for {{row.id}} names one advance", "type": "scenario", "expand": "per-row", "collection": "rejection-cases", "when": { "row": { "result": [ "clock-advances", "cost-and-clock" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the prose at {{row.clock-rule-declared-in}}, not the running game", "when": [ "a reviewer checks the cited clock or turn rule" ], "then": [ "the citation names exactly one clock advance caused by this refusal", "When the citation does not meet this requirement, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and {{row.clock-rule-declared-in}}, not the running game. The citation must name exactly one advance caused by this refusal. When the citation does not meet this requirement, the adoption is invalid, and this test fails. The test names the address and restates nothing from it." }, { "id": "presentation-cue-citation-duty", "title": "declaration check: the presentation citation for {{row.id}} supplies a finite cue", "type": "scenario", "expand": "per-row", "collection": "presentation-driven-events", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the prose at {{row.declared-in}}, not the running game", "when": [ "a reviewer checks the cited presentation rule" ], "then": [ "{{row.declared-in}} relates the game timing of {{row.event-class}} to {{row.presentation-cue}} and shows the cue finishes in finite game or real time, which is what keeps an instant from waiting forever", "When the citation does not meet this requirement, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and {{row.declared-in}}, not the running game. The citation must relate the game timing of {{row.event-class}} to {{row.presentation-cue}} and show that the cue finishes in finite game or real time, keeping an instant from waiting forever. When the citation does not meet this requirement, the adoption is invalid, and this test fails. The test names the address and restates nothing from it." }, { "id": "caused-event-citation-duty", "title": "declaration check: the caused-event citation for {{row.id}} supplies its bound", "type": "scenario", "expand": "per-row", "collection": "caused-event-kinds", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the prose at {{row.declared-in}}, not the running game", "when": [ "a reviewer checks the cited caused-event rule" ], "then": [ "{{row.declared-in}} names the cause, the new {{row.event-class}} event, and the finite bound on repeated caused events", "When the citation does not meet this requirement, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and {{row.declared-in}}, not the running game. The citation must name the cause, the new {{row.event-class}} event, and the finite bound on repeated caused events. When the citation does not meet this requirement, the adoption is invalid, and this test fails. The test names the address and restates nothing from it." }, { "id": "interrupt-citation-duty", "title": "declaration check: the interrupt citation for {{row.id}} supplies its entry rule", "type": "scenario", "expand": "per-row", "collection": "interrupts", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the prose at {{row.declared-in}}, not the running game", "when": [ "a reviewer checks the cited interrupt rule" ], "then": [ "{{row.declared-in}} names the validity window, the {{row.boundary-granularity}} effect boundaries, and the stop result", "When the citation does not meet this requirement, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and {{row.declared-in}}, not the running game. The citation must name the validity window, the {{row.boundary-granularity}} effect boundaries, and the stop result. When the citation does not meet this requirement, the adoption is invalid, and this test fails. The test names the address and restates nothing from it." }, { "id": "interrupt-replacement-citation-duty", "title": "declaration check: the replacement citation for {{row.id}} supplies every effect in order", "type": "scenario", "expand": "per-row", "collection": "interrupts", "when": { "row": { "result": [ "replace-remaining-effects" ] } }, "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the prose at {{row.replacement-declared-in}}, not the running game", "when": [ "a reviewer checks the cited replacement rule" ], "then": [ "{{row.replacement-declared-in}} states every replacement effect and its order", "When the citation does not meet this requirement, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and {{row.replacement-declared-in}}, not the running game. The citation must state every replacement effect and its order. When the citation does not meet this requirement, the adoption is invalid, and this test fails. The test names the address and restates nothing from it." }, { "id": "orphan-case-citation-duty", "title": "declaration check: the orphan citation for {{row.id}} supplies its case", "type": "scenario", "expand": "per-row", "collection": "orphan-cases", "bindings": {}, "test": { "type": "scenario", "given": "the {{instance}} adoption and the prose at {{row.declared-in}}, not the running game", "when": [ "a reviewer checks the cited orphan rule" ], "then": [ "{{row.declared-in}} identifies the case, when it applies, the captured payload, and the source or target requirement", "When the citation does not meet this requirement, the adoption is invalid, and this test fails." ], "diagnostics": [ "{{instance}}-declaration-record" ] }, "text": "This declaration check reads the adoption and {{row.declared-in}}, not the running game. The citation must identify the case, when it applies, the captured payload, and the source or target requirement. When the citation does not meet this requirement, the adoption is invalid, and this test fails. The test names the address and restates nothing from it." }, { "id": "resolution-holds", "title": "event resolution holds for the whole run", "type": "general", "expand": "once", "bindings": {}, "test": { "type": "general", "holds": "for every instant of the audited run that this adoption alone governs, every event resolved at or after every eligible lower-rank event; every rank tie and within-class selection followed its declared order; every refusal followed its matching case or the default answer; every accepted proposal created one payload once; every valid interrupt entered at its declared point and took effect; every caused event was created once and followed its route; every orphan followed its row; every ending was recorded once at step 15; for an instant shared with another adoption, this test checks nothing; for a case the adoption cannot construct, this test checks nothing", "seeds": "{{inputs:seeds}}", "scope": "{{inputs:scope}}", "diagnostics": [ "{{instance}}-instant-trace", "{{instance}}-proposal-log", "{{instance}}-order-trace", "{{instance}}-collision-report", "{{instance}}-orphan-report", "{{instance}}-interrupt-report", "{{instance}}-ending-record", "{{instance}}-settlement-report", "{{instance}}-first-ordering-violation" ] }, "text": "Across {{inputs:scope}}, lower eligible ranks never resolve late, each tie and within-class order holds, each proposal follows its case or the default answer, each accepted proposal creates one payload, each valid interrupt takes effect at its entry point, each caused event follows its route, each orphan follows its row, and each ending records once at step 15. For an instant shared with another adoption, this test checks nothing. For a case that the adoption cannot construct, this test checks nothing.", "inputs": { "scope": { "default": "every instant of the audited run that this adoption owns in full" }, "seeds": { "default": [ "audit-a", "audit-b" ] } } } ] }