Soulslike action buffer

soulslike-action-buffer · an adoption of Input forgiveness, version 2

Tests included

Use in your package

The first button opens the authoring tool with these answers and numbers already filled in. You still add the rules and tuning of your own game.

Open in the authoring tool Download zip file

What is in the zip file

The zip file holds the adoption and its acceptance tests. In the authoring tool, choose Add contract and pick this zip file. If you edit your package outside the authoring tool, unpack the zip file in your package folder. The files of the zip file go into contracts/.

Download adoption JSON · Download verification pack

The contract that this adoption uses

This contract covers inputs accepted just before the game allows the action, just after it stops allowing it, or near a target moment such as a beat or impact. It records which game actions receive that help, what arms each case (makes it ready to accept or save an input), and when a saved action fires (becomes ready for the game to try). This contract does not cover physical controls, ordinary action rules, or small position corrections such as corner correction. The Control options contract covers physical controls.

Read the full Input forgiveness contract →

Questions

The supplied answer is marked on each question. Pick other answers to see what changes. Nothing is saved here: the zip file and the authoring tool use the supplied answers.

Show exact wording for builders

Several inputs that receive this help become ready at the same moment. Which ones does the game try?

Asked when: the late input windows list has at least one row, or the input buffers list has at least one row, or the target moment windows list has at least one row.
If not asked: No forgiveness row can make an input ready.

All ready actions	The game tries every helped input that becomes ready. A twin-stick hero may dodge and shoot at the same moment. Every ready forgiven input is submitted once as an action proposal. Event resolution owns their order and the game rules may still refuse incompatible actions.
Declared prioritySupplied answer	The game tries only one ready input. A fixed priority in your game's rules chooses it. A farm tool may water, and not plant, when both become ready. Exactly one ready forgiven input is submitted. The matching competition-rules row supplies one total priority over every input that can be ready in that situation.
Cannot coincide	Two helped inputs can never become ready at the same moment. A one-button rhythm lane has at most one note action at a beat. The adoption guarantees that no reachable game state presents two ready forgiven inputs at one moment. Reaching such a state invalidates the design claim.

Why this is asked

A landing, beat, or recovery end can make several helped inputs ready. The game must decide which ones to try.

Numbersno numbers

This contract has no numbers to set.

Rulesno rules

A rule is a check between the numbers. Validation reports a rule that fails.

This contract has no rules between its numbers.

Lists4 lists

Each list holds the rows this adoption supplies. A list can be empty.

Late input windows

late-input-windows

This adoption declares no late input windows.

Input buffers

input-buffers

Id	Action	Action declared in	Arms when declared in	Window declared in	Fires when declared in	Cancels when declared in	Waiting press	Held after fire
`dodge-during-recovery`	`dodge`	`combat.dodge-action`	`combat.dodge-input-during-recovery`	`combat.dodge-recovery-buffer`	`combat.dodge-first-ready-moment`	`combat.dodge-buffer-cancellation`	`first-press-stays`	`fresh-press-required`
`light-attack-during-recovery`	`light-attack`	`combat.light-attack-action`	`combat.light-attack-input-during-recovery`	`combat.light-attack-recovery-buffer`	`combat.light-attack-first-ready-moment`	`combat.light-attack-buffer-cancellation`	`latest-press-replaces`	`hold-can-repeat`
`item-during-recovery`	`use-item`	`combat.use-item-action`	`combat.item-input-during-recovery`	`combat.item-recovery-buffer`	`combat.item-first-ready-moment`	`combat.item-buffer-cancellation`	`latest-press-replaces`	`fresh-press-required`

Target moment windows

target-moment-windows

This adoption declares no target moment windows.

Competition rules

competition-rules

Id	Declared in
`recovery-end-actions`	`combat.recovery-end-input-priority`

Test inputsscope and seeds

Some tests need a scope or seeds from the adoption before they can run.

This adoption supplies no test inputs. Every test uses its default inputs.

Acceptance tests48 tests apply

The contract comes with 49 tests. A test that runs once per row is counted once for each row. Tests that do not apply to these answers are still listed, with the reason.

forgiveness-vocabulary-and-openness

input forgiveness uses the mapped action input and cited openness

scenarioonce

Applies to soulslike-action-buffer.

For a declared row, an action input is the event that the game receives after Control options maps a physical control; device identity does not change settlement. Ordinary permission is the action's legal state before forgiveness, and a press uses the edge named by the cited action rule. Openness comes from the agreeing Timed window adoption where one exists, otherwise from the cited Fixed timing rule. Where this adoption has no row in a row set, this test checks nothing for that row set.

Test steps and diagnostics

Given: a physical control mapped through Control options to an action input that reaches a declared forgiveness row
When: the row reads ordinary permission, its input edge, and whether its window instance is open
Then: the action input is the event that the game receives after mapping, independent of physical device identity
ordinary permission is the action's legal state before forgiveness
the press arrives on the edge named by the cited action rule, including a release edge where that rule names one
openness comes from the agreeing Timed window adoption where one exists and otherwise from the row's cited Fixed timing rule
an accepted late or target input, or a saved press whose firing event has arrived, is one ready forgiven input
where this adoption has no row in a row set, this test checks nothing for that row set
Diagnostics: soulslike-action-buffer-input-receipt
soulslike-action-buffer-window-instances
soulslike-action-buffer-ready-set

unmatched-input-receives-no-forgiveness

an unmatched action input receives no forgiveness

scenarioonce

Applies to soulslike-action-buffer.

An action input with no matching row in the current situation receives no forgiveness. Ordinary permission alone decides whether the action is submitted.

Test steps and diagnostics

Given: an action input with no matching late-input-windows, input-buffers, or target-moment-windows row in the current situation
When: the game receives that action input
Then: ordinary permission alone decides whether the action is submitted
the adoption creates no ready forgiven input, saved press, or target grade for it
Diagnostics: soulslike-action-buffer-input-receipt
soulslike-action-buffer-ready-set
soulslike-action-buffer-waiting-press-state

empty-row-families-create-no-forgiveness

empty row sets create no forgiveness state

scenarioonce

Applies to soulslike-action-buffer.

An empty late-input-windows set keeps no action available after ordinary permission ends; an empty input-buffers set means no early press waits for an action to become ordinarily permitted; an empty target-moment-windows set forgives no input near a target moment; and an empty competition-rules set declares no priority. Where a named set has a row, this test checks nothing for that set. If all three forgiveness row sets are empty, no forgiveness row can make an input ready and the competition-rules description allows no competition rows; any competition row then makes the adoption invalid, and this test fails. Where any forgiveness row set has a row, this test checks nothing for that last case.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption document and its row sets
When: each empty row set's declared consequence is read
Then: where late-input-windows is empty, no action remains available through forgiveness after ordinary permission ends; where a row exists, this test checks nothing in this line
where input-buffers is empty, no early press waits for an action to become ordinarily permitted; where a row exists, this test checks nothing in this line
where target-moment-windows is empty, no input is forgiven because it arrives near a target moment; where a row exists, this test checks nothing in this line
where competition-rules is empty, no competition priority rule is declared; where a row exists, this test checks nothing in this line
where all three forgiveness row sets are empty, no forgiveness row can make an input ready; where any of them has a row, this test checks nothing in this line
where all three forgiveness row sets are empty, competition-rules has no rows; any row in it then makes the adoption invalid, and this test fails; where any forgiveness row set has a row, this test checks nothing in this line
Diagnostics: soulslike-action-buffer-declaration-record

late-window-arms-on-cited-event

`Row.id` arms one late window on its cited event

scenarioper late-input-windows row

Does not apply to soulslike-action-buffer: late-input-windows has no rows.

target-instance-arms-on-cited-event

`Row.id` creates one instance for each cited target

scenarioper target-moment-windows row

Does not apply to soulslike-action-buffer: target-moment-windows has no rows.

buffer-arms-on-qualifying-press · dodge-during-recovery

`dodge-during-recovery` creates no instance before its qualifying press

scenarioper input-buffers row

Applies to the dodge-during-recovery row.

dodge-during-recovery has no window instance before a qualifying press. When a qualifying press named by combat.dodge-input-during-recovery is stored, it creates one per-press instance under combat.dodge-recovery-buffer at that input moment.

Test steps and diagnostics

Given: the early state and matching action input named by combat.dodge-input-during-recovery
When: the early state begins and then the qualifying press is stored
Then: no dodge-during-recovery per-press window instance exists merely because the early state began
storing the qualifying press creates one dodge-during-recovery instance at that press's input moment under combat.dodge-recovery-buffer
Diagnostics: soulslike-action-buffer-arming-log
soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-window-instances

buffer-arms-on-qualifying-press · light-attack-during-recovery

`light-attack-during-recovery` creates no instance before its qualifying press

scenarioper input-buffers row

Applies to the light-attack-during-recovery row.

light-attack-during-recovery has no window instance before a qualifying press. When a qualifying press named by combat.light-attack-input-during-recovery is stored, it creates one per-press instance under combat.light-attack-recovery-buffer at that input moment.

Test steps and diagnostics

Given: the early state and matching action input named by combat.light-attack-input-during-recovery
When: the early state begins and then the qualifying press is stored
Then: no light-attack-during-recovery per-press window instance exists merely because the early state began
storing the qualifying press creates one light-attack-during-recovery instance at that press's input moment under combat.light-attack-recovery-buffer
Diagnostics: soulslike-action-buffer-arming-log
soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-window-instances

buffer-arms-on-qualifying-press · item-during-recovery

`item-during-recovery` creates no instance before its qualifying press

scenarioper input-buffers row

Applies to the item-during-recovery row.

item-during-recovery has no window instance before a qualifying press. When a qualifying press named by combat.item-input-during-recovery is stored, it creates one per-press instance under combat.item-recovery-buffer at that input moment.

Test steps and diagnostics

Given: the early state and matching action input named by combat.item-input-during-recovery
When: the early state begins and then the qualifying press is stored
Then: no item-during-recovery per-press window instance exists merely because the early state began
storing the qualifying press creates one item-during-recovery instance at that press's input moment under combat.item-recovery-buffer
Diagnostics: soulslike-action-buffer-arming-log
soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-window-instances

receipt-maps-before-settlement

input receipt maps the control before reading forgiveness

scenarioonce

Applies to soulslike-action-buffer.

Control options maps a physical control before forgiveness reads ordinary permission and matching rows. Device identity does not change settlement. A control already held when a late or target row arms creates no action input unless its cited action rule defines one; where the adoption has neither a late row nor a target row, this test checks nothing about that control.

Test steps and diagnostics

Given: two physical devices mapped by Control options to the same action input, plus a control already held when a late or target row arms where the adoption can construct one
When: the game receives each mapped input and observes the already-held control
Then: both mapped action inputs read the same ordinary permission and matching rows regardless of device identity
the already-held control creates no action input at arming unless the cited action rule explicitly defines one
where the adoption has no late or target row, this test checks nothing about the control that is already held
Diagnostics: soulslike-action-buffer-input-receipt
soulslike-action-buffer-arming-log

receipt-family-order

target, late, buffer, and ordinary receipt keep their fixed order

scenarioonce

Applies to soulslike-action-buffer.

A receipt evaluates target rows first whether ordinary permission exists or not. If none accepts and permission exists, it submits the ordinary attempt without forgiveness. Without permission, late rows run next and a buffer captures only if neither a target row nor a late row accepts. Where this adoption has no row in a row set, this test checks nothing for that row set.

Test steps and diagnostics

Given: action-input receipts that exercise every forgiveness row set in which the soulslike-action-buffer adoption has a row
When: ordinary permission is present in one receipt and absent in another
Then: every matching target row is evaluated regardless of ordinary permission before any late or buffer row
ordinary permission prevents late and buffer evaluation but does not prevent target evaluation
if no target row accepts and ordinary permission exists, the ordinary attempt is submitted without forgiveness and the receipt ends
with no ordinary permission, late rows run before buffer rows, and a buffer captures only if neither a target row nor a late row accepts
where this adoption has no row in a row set, this test checks nothing for that row set
Diagnostics: soulslike-action-buffer-input-receipt
soulslike-action-buffer-submission-log
soulslike-action-buffer-waiting-press-state

target-input-accepts-and-grades

`Row.id` accepts and grades only an open, otherwise-legal attempt

scenarioper target-moment-windows row

Does not apply to soulslike-action-buffer: target-moment-windows has no rows.

late-input-accepts-only-while-open

`Row.id` accepts through its cited last moment and not later

scenarioper late-input-windows row

Does not apply to soulslike-action-buffer: late-input-windows has no rows.

buffer-captures-one-press · dodge-during-recovery

`dodge-during-recovery` stores one press and follows `first-press-stays`

scenarioper input-buffers row

Applies to the dodge-during-recovery row.

While combat.dodge-input-during-recovery holds, dodge-during-recovery stores one qualifying press of an action this row covers (dodge), its input moment, and one instance under combat.dodge-recovery-buffer. If another matching press arrives, the later matching press is ignored and the first press, its input moment, and its original window instance remain. The row holds at most one press; a press outside the cited early state is not saved. For a named action, this test checks nothing about a press of a different action; for the reserved all-actions spelling, the contract makes a press of any covered action a matching press, so it follows the repeated-press rule above.

Test steps and diagnostics

Given: a press of an action this row covers (dodge) for which no target or late row accepts, plus a second matching press while one already waits and a separate press while combat.dodge-input-during-recovery does not hold
When: the first press arrives while combat.dodge-input-during-recovery holds, the repeated press arrives, and the separate outside-state press is received
Then: the first qualifying press stores its action, input moment, and one per-press instance under combat.dodge-recovery-buffer
the later matching press is ignored and the first press, its input moment, and its original window instance remain
the row holds at most one saved press
the outside-state press is not saved by dodge-during-recovery
where this row's action is the reserved all-actions spelling, a press of any covered action is a matching press of this row and follows the repeated-press line above; for a named action, this test checks nothing about a press of a different action
Diagnostics: soulslike-action-buffer-input-receipt
soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-window-instances
soulslike-action-buffer-clearing-log

buffer-captures-one-press · light-attack-during-recovery

`light-attack-during-recovery` stores one press and follows `latest-press-replaces`

scenarioper input-buffers row

Applies to the light-attack-during-recovery row.

While combat.light-attack-input-during-recovery holds, light-attack-during-recovery stores one qualifying press of an action this row covers (light-attack), its input moment, and one instance under combat.light-attack-recovery-buffer. If another matching press arrives, the earlier press and its window instance are cleared, and the later press, its input moment, and one new window instance replace them. The row holds at most one press; a press outside the cited early state is not saved. For a named action, this test checks nothing about a press of a different action; for the reserved all-actions spelling, the contract makes a press of any covered action a matching press, so it follows the repeated-press rule above.

Test steps and diagnostics

Given: a press of an action this row covers (light-attack) for which no target or late row accepts, plus a second matching press while one already waits and a separate press while combat.light-attack-input-during-recovery does not hold
When: the first press arrives while combat.light-attack-input-during-recovery holds, the repeated press arrives, and the separate outside-state press is received
Then: the first qualifying press stores its action, input moment, and one per-press instance under combat.light-attack-recovery-buffer
the earlier press and its window instance are cleared, and the later press, its input moment, and one new window instance replace them
the row holds at most one saved press
the outside-state press is not saved by light-attack-during-recovery
where this row's action is the reserved all-actions spelling, a press of any covered action is a matching press of this row and follows the repeated-press line above; for a named action, this test checks nothing about a press of a different action
Diagnostics: soulslike-action-buffer-input-receipt
soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-window-instances
soulslike-action-buffer-clearing-log

buffer-captures-one-press · item-during-recovery

`item-during-recovery` stores one press and follows `latest-press-replaces`

scenarioper input-buffers row

Applies to the item-during-recovery row.

While combat.item-input-during-recovery holds, item-during-recovery stores one qualifying press of an action this row covers (use-item), its input moment, and one instance under combat.item-recovery-buffer. If another matching press arrives, the earlier press and its window instance are cleared, and the later press, its input moment, and one new window instance replace them. The row holds at most one press; a press outside the cited early state is not saved. For a named action, this test checks nothing about a press of a different action; for the reserved all-actions spelling, the contract makes a press of any covered action a matching press, so it follows the repeated-press rule above.

Test steps and diagnostics

Given: a press of an action this row covers (use-item) for which no target or late row accepts, plus a second matching press while one already waits and a separate press while combat.item-input-during-recovery does not hold
When: the first press arrives while combat.item-input-during-recovery holds, the repeated press arrives, and the separate outside-state press is received
Then: the first qualifying press stores its action, input moment, and one per-press instance under combat.item-recovery-buffer
the earlier press and its window instance are cleared, and the later press, its input moment, and one new window instance replace them
the row holds at most one saved press
the outside-state press is not saved by item-during-recovery
where this row's action is the reserved all-actions spelling, a press of any covered action is a matching press of this row and follows the repeated-press line above; for a named action, this test checks nothing about a press of a different action
Diagnostics: soulslike-action-buffer-input-receipt
soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-window-instances
soulslike-action-buffer-clearing-log

late-window-clears-on-four-ends

`Row.id` ends on execution, permission, close, or early clearing

scenarioper late-input-windows row

Does not apply to soulslike-action-buffer: late-input-windows has no rows.

buffer-fires-or-clears-at-first-boundary · dodge-during-recovery

`dodge-during-recovery` fires once at its first cited event or clears without firing

scenarioper input-buffers row

Applies to the dodge-during-recovery row.

If neither clearing path arrives first, dodge-during-recovery fires once at the first event named by combat.dodge-first-ready-moment, with no later poll or extra delay. A prior close at combat.dodge-recovery-buffer or early event at combat.dodge-buffer-cancellation clears it without firing. The records distinguish firing from each clearing path.

Test steps and diagnostics

Given: three otherwise identical waiting dodge-during-recovery saved presses
When: the first ordinary permission event at combat.dodge-first-ready-moment arrives before clearing in one trial, combat.dodge-recovery-buffer closes before firing in another, and the event at combat.dodge-buffer-cancellation occurs before firing in the third
Then: the first trial makes the saved press ready exactly once at that firing event with no later input poll or extra delay
the window-close trial clears the saved press and submits nothing from it
the early-clearing trial clears the saved press and submits nothing from it
the firing, window-close, and early-clearing records distinguish the three results
Diagnostics: soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-ready-set
soulslike-action-buffer-clearing-log
soulslike-action-buffer-submission-log

buffer-fires-or-clears-at-first-boundary · light-attack-during-recovery

`light-attack-during-recovery` fires once at its first cited event or clears without firing

scenarioper input-buffers row

Applies to the light-attack-during-recovery row.

If neither clearing path arrives first, light-attack-during-recovery fires once at the first event named by combat.light-attack-first-ready-moment, with no later poll or extra delay. A prior close at combat.light-attack-recovery-buffer or early event at combat.light-attack-buffer-cancellation clears it without firing. The records distinguish firing from each clearing path.

Test steps and diagnostics

Given: three otherwise identical waiting light-attack-during-recovery saved presses
When: the first ordinary permission event at combat.light-attack-first-ready-moment arrives before clearing in one trial, combat.light-attack-recovery-buffer closes before firing in another, and the event at combat.light-attack-buffer-cancellation occurs before firing in the third
Then: the first trial makes the saved press ready exactly once at that firing event with no later input poll or extra delay
the window-close trial clears the saved press and submits nothing from it
the early-clearing trial clears the saved press and submits nothing from it
the firing, window-close, and early-clearing records distinguish the three results
Diagnostics: soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-ready-set
soulslike-action-buffer-clearing-log
soulslike-action-buffer-submission-log

buffer-fires-or-clears-at-first-boundary · item-during-recovery

`item-during-recovery` fires once at its first cited event or clears without firing

scenarioper input-buffers row

Applies to the item-during-recovery row.

If neither clearing path arrives first, item-during-recovery fires once at the first event named by combat.item-first-ready-moment, with no later poll or extra delay. A prior close at combat.item-recovery-buffer or early event at combat.item-buffer-cancellation clears it without firing. The records distinguish firing from each clearing path.

Test steps and diagnostics

Given: three otherwise identical waiting item-during-recovery saved presses
When: the first ordinary permission event at combat.item-first-ready-moment arrives before clearing in one trial, combat.item-recovery-buffer closes before firing in another, and the event at combat.item-buffer-cancellation occurs before firing in the third
Then: the first trial makes the saved press ready exactly once at that firing event with no later input poll or extra delay
the window-close trial clears the saved press and submits nothing from it
the early-clearing trial clears the saved press and submits nothing from it
the firing, window-close, and early-clearing records distinguish the three results
Diagnostics: soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-ready-set
soulslike-action-buffer-clearing-log
soulslike-action-buffer-submission-log

target-instance-stops-accepting

`Row.id` accepts nothing after close, settlement, or early clearing

scenarioper target-moment-windows row

Does not apply to soulslike-action-buffer: target-moment-windows has no rows.

ready-input-exists-once

each ready forgiven input exists once

scenarioonce

Applies to soulslike-action-buffer.

A stored press or accepted input contributes one ready forgiven input, and repeated updates create no copy. If two adoptions produce ready inputs at one moment, each settles independently and both selected sets are submitted together; where that case cannot occur, this test checks nothing about it.

Test steps and diagnostics

Given: a stored press or accepted input that becomes ready, plus two adoptions producing ready inputs at one moment where the game can construct that case
When: the game updates the ready state repeatedly and settles the moment
Then: the same stored press or accepted input contributes exactly one ready forgiven input
a repeated update creates no copy
where two adoptions contribute, each settles independently and the inputs selected by both are submitted together
where two adoptions can never produce ready inputs at one moment, this test checks nothing about that case
Diagnostics: soulslike-action-buffer-ready-set
soulslike-action-buffer-submission-log

all-ready-actions-submit-every-input

all-ready-actions submits every ready input once

scenarioonce

Does not apply to soulslike-action-buffer: ready together is declared priority, not all ready actions.

declared-priority-submits-one-winner

declared-priority submits one input by a stable priority

scenarioonce

Applies to soulslike-action-buffer.

Under declared-priority, the one matching competition row supplies a priority that stays stable for the settlement moment. Exactly its highest-priority ready input is submitted once, and every lower-priority ready input is cleared without submission.

Test steps and diagnostics

Given: two or more ready forgiven inputs in a situation covered by its one matching competition-rules row
When: the adoption settles their competition
Then: the cited priority remains stable for the whole settlement moment
exactly the highest-priority input is submitted once
every lower-priority ready input is cleared without submission
Diagnostics: soulslike-action-buffer-ready-set
soulslike-action-buffer-submission-log
soulslike-action-buffer-clearing-log

cannot-coincide-invalidates-two-ready-inputs

cannot-coincide allows no reachable pair of ready inputs

scenarioonce

Does not apply to soulslike-action-buffer: ready together is declared priority, not cannot coincide.

selected-inputs-stop-at-proposal-boundary

selected inputs become proposals at this moment

scenarioonce

Applies to soulslike-action-buffer.

A selected input becomes an action proposal at the current game moment. Event resolution owns same-moment proposal order, and the action's Fixed rules own cost, effect, and refusal. This contract stops at submission and does not force a conflicting action to succeed.

Test steps and diagnostics

Given: one or more inputs selected for submission
When: input forgiveness submits them
Then: each selected input enters Event resolution as an action proposal at the current game moment
the input-forgiveness trace performs no ordering of proposals that share the moment
cost, effect, refusal because of a conflict, and proposal order are absent from input-forgiveness settlement and remain owned by the cited action rules and Event resolution
Diagnostics: soulslike-action-buffer-submission-log
soulslike-action-buffer-ready-set

buffer-clears-after-submission · dodge-during-recovery

`dodge-during-recovery` clears after submission

scenarioper input-buffers row

Applies to the dodge-during-recovery row.

A selected dodge-during-recovery saved press clears immediately on submission.

Test steps and diagnostics

Given: one ready dodge-during-recovery saved press selected for submission
When: the selected press is submitted
Then: the selected saved press clears immediately on submission
Diagnostics: soulslike-action-buffer-submission-log
soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-clearing-log

buffer-clears-after-submission · light-attack-during-recovery

`light-attack-during-recovery` clears after submission

scenarioper input-buffers row

Applies to the light-attack-during-recovery row.

A selected light-attack-during-recovery saved press clears immediately on submission.

Test steps and diagnostics

Given: one ready light-attack-during-recovery saved press selected for submission
When: the selected press is submitted
Then: the selected saved press clears immediately on submission
Diagnostics: soulslike-action-buffer-submission-log
soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-clearing-log

buffer-clears-after-submission · item-during-recovery

`item-during-recovery` clears after submission

scenarioper input-buffers row

Applies to the item-during-recovery row.

A selected item-during-recovery saved press clears immediately on submission.

Test steps and diagnostics

Given: one ready item-during-recovery saved press selected for submission
When: the selected press is submitted
Then: the selected saved press clears immediately on submission
Diagnostics: soulslike-action-buffer-submission-log
soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-clearing-log

buffer-clears-after-competition-loss · dodge-during-recovery

`dodge-during-recovery` clears when its input is not selected

scenarioper input-buffers row

Applies to the dodge-during-recovery row.

When a ready forgiven input from a different row is selected, the saved press of a ready dodge-during-recovery input that is not selected clears immediately without submission.

Test steps and diagnostics

Given: one ready dodge-during-recovery input at a settlement moment that also carries a ready forgiven input from a different row
When: the other input is selected and the dodge-during-recovery input is not selected
Then: the saved press that was not selected clears immediately without submission
Diagnostics: soulslike-action-buffer-submission-log
soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-clearing-log

buffer-clears-after-competition-loss · light-attack-during-recovery

`light-attack-during-recovery` clears when its input is not selected

scenarioper input-buffers row

Applies to the light-attack-during-recovery row.

When a ready forgiven input from a different row is selected, the saved press of a ready light-attack-during-recovery input that is not selected clears immediately without submission.

Test steps and diagnostics

Given: one ready light-attack-during-recovery input at a settlement moment that also carries a ready forgiven input from a different row
When: the other input is selected and the light-attack-during-recovery input is not selected
Then: the saved press that was not selected clears immediately without submission
Diagnostics: soulslike-action-buffer-submission-log
soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-clearing-log

buffer-clears-after-competition-loss · item-during-recovery

`item-during-recovery` clears when its input is not selected

scenarioper input-buffers row

Applies to the item-during-recovery row.

When a ready forgiven input from a different row is selected, the saved press of a ready item-during-recovery input that is not selected clears immediately without submission.

Test steps and diagnostics

Given: one ready item-during-recovery input at a settlement moment that also carries a ready forgiven input from a different row
When: the other input is selected and the item-during-recovery input is not selected
Then: the saved press that was not selected clears immediately without submission
Diagnostics: soulslike-action-buffer-submission-log
soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-clearing-log

late-window-clears-after-submission

`Row.id` clears on submission

scenarioper late-input-windows row

Does not apply to soulslike-action-buffer: late-input-windows has no rows.

late-window-survives-competition-loss

`Row.id` does not end when its input is not selected

scenarioper late-input-windows row

Does not apply to soulslike-action-buffer: late-input-windows has no rows.

target-input-after-submission

`Row.id` leaves no saved press after submission

scenarioper target-moment-windows row

Does not apply to soulslike-action-buffer: target-moment-windows has no rows.

target-instance-after-competition-loss

`Row.id` remains open when its input is not selected, until settled or closed

scenarioper target-moment-windows row

Does not apply to soulslike-action-buffer: target-moment-windows has no rows.

held-control-after-buffer-fire · dodge-during-recovery

`dodge-during-recovery` follows `fresh-press-required` after its action fires

scenarioper input-buffers row

Applies to the dodge-during-recovery row.

The contract starts held-input handling only after dodge-during-recovery's action fires and its saved press has been cleared. Then the uninterrupted held state creates no press; the new qualifying press creates one saved press, which becomes ready once at the firing event. The course reads the arming condition at combat.dodge-input-during-recovery, the window at combat.dodge-recovery-buffer, and the firing event at combat.dodge-first-ready-moment. At most one press waits. The test reads both waiting state and submissions so renewal and a new physical press remain distinguishable.

Test steps and diagnostics

Given: dodge-during-recovery has submitted its saved press, the action fires, and the physical control remains held
When: the control remains held through a later accepted early state, is then released and pressed again while that state holds, and the firing event arrives
Then: held-input handling begins only after the action fires and the saved press has been cleared
the uninterrupted held state creates no press; the new qualifying press creates one saved press, which becomes ready once at the firing event
at most one press waits in dodge-during-recovery
the waiting-press state and submission log distinguish renewal from a new physical press
Diagnostics: soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-submission-log
soulslike-action-buffer-clearing-log

held-control-after-buffer-fire · light-attack-during-recovery

`light-attack-during-recovery` follows `hold-can-repeat` after its action fires

scenarioper input-buffers row

Applies to the light-attack-during-recovery row.

The contract starts held-input handling only after light-attack-during-recovery's action fires and its saved press has been cleared. Then the uninterrupted hold creates one new press when the arming condition next holds; window close clears it and creates one new waiting press immediately, which becomes ready once at the firing event. The course reads the arming condition at combat.light-attack-input-during-recovery, the window at combat.light-attack-recovery-buffer, and the firing event at combat.light-attack-first-ready-moment. At most one press waits. The test reads both waiting state and submissions so renewal and a new physical press remain distinguishable.

Test steps and diagnostics

Given: light-attack-during-recovery has submitted its saved press, the action fires, and the physical control remains held
When: the control remains held as the arming condition next holds, the cited window later closes while both still hold, and the firing event arrives after renewal
Then: held-input handling begins only after the action fires and the saved press has been cleared
the uninterrupted hold creates one new press when the arming condition next holds; window close clears it and creates one new waiting press immediately, which becomes ready once at the firing event
at most one press waits in light-attack-during-recovery
the waiting-press state and submission log distinguish renewal from a new physical press
Diagnostics: soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-submission-log
soulslike-action-buffer-clearing-log

held-control-after-buffer-fire · item-during-recovery

`item-during-recovery` follows `fresh-press-required` after its action fires

scenarioper input-buffers row

Applies to the item-during-recovery row.

The contract starts held-input handling only after item-during-recovery's action fires and its saved press has been cleared. Then the uninterrupted held state creates no press; the new qualifying press creates one saved press, which becomes ready once at the firing event. The course reads the arming condition at combat.item-input-during-recovery, the window at combat.item-recovery-buffer, and the firing event at combat.item-first-ready-moment. At most one press waits. The test reads both waiting state and submissions so renewal and a new physical press remain distinguishable.

Test steps and diagnostics

Given: item-during-recovery has submitted its saved press, the action fires, and the physical control remains held
When: the control remains held through a later accepted early state, is then released and pressed again while that state holds, and the firing event arrives
Then: held-input handling begins only after the action fires and the saved press has been cleared
the uninterrupted held state creates no press; the new qualifying press creates one saved press, which becomes ready once at the firing event
at most one press waits in item-during-recovery
the waiting-press state and submission log distinguish renewal from a new physical press
Diagnostics: soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-submission-log
soulslike-action-buffer-clearing-log

rejected-proposal-restores-nothing

a refused proposal restores no forgiveness state

scenarioonce

Applies to soulslike-action-buffer.

Refusing a submitted action proposal restores no cleared forgiveness state. A new attempt needs a new qualifying arming event or press. The consequences of the refusal belong to Event resolution, and this test checks nothing about them.

Test steps and diagnostics

Given: a submitted forgiven action proposal after the submission-time clearing for its row set
When: the cited action rule or Event resolution refuses the proposal
Then: the cleared forgiveness state remains absent
a new attempt appears only after a new qualifying arming event or press
this test checks nothing about the consequences of the refusal
Diagnostics: soulslike-action-buffer-submission-log
soulslike-action-buffer-clearing-log
soulslike-action-buffer-window-instances
soulslike-action-buffer-waiting-press-state

forgiveness-authority-order

a later step of the forgiveness order never rewrites earlier moments

scenarioonce

Applies to soulslike-action-buffer.

Arming, input mapping, ordinary permission, target acceptance, late acceptance, buffer capture, repeated-press choice, open and early-clearing state, firing, competition, Event resolution order, action rules, clearing, and held-input renewal remain in that order. No later step rewrites an earlier input moment or target moment. Where a step does not occur in the case, this test checks nothing for that step.

Test steps and diagnostics

Given: a receipt and settlement trace with distinguishable arming, mapped input, ordinary permission, acceptance or capture, open state, firing, competition, submission, action result, clearing, and held-input records where those steps occur
When: the trace is compared with the mechanism's order of the steps
Then: each step reads the result of every earlier applicable step in the listed order
no later step rewrites an earlier input moment or target moment
where a step does not occur in the constructed case, this test checks nothing for that step
Diagnostics: soulslike-action-buffer-input-receipt
soulslike-action-buffer-arming-log
soulslike-action-buffer-ready-set
soulslike-action-buffer-submission-log
soulslike-action-buffer-clearing-log

row-families-do-not-overlap

declaration check: no row set has two rows matching one input

scenarioonce

Applies to soulslike-action-buffer.

This declaration check reads the adoption and its cited prose, not the running game. The contract makes two rows of one row set matching one input in the same situation an invalid adoption rather than an implicit choice. An overlapping pair makes the adoption invalid, and this test fails. For a row set with fewer than two rows, this test checks nothing for that row set.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and its cited prose, not the running game
When: a reviewer compares every pair of rows within late-input-windows, input-buffers, and target-moment-windows
Then: no two rows in one row set can match one action input in the same situation
an overlapping pair makes the adoption invalid, and this test fails; for a row set with fewer than two rows, this test checks nothing for that row set
Diagnostics: soulslike-action-buffer-declaration-record

declared-priority-has-one-matching-rule

declaration check: declared-priority has one matching competition row

scenarioonce

Applies to soulslike-action-buffer.

This declaration check reads the adoption and its cited prose, not the running game. The contract requires exactly one matching competition-rules row for every situation where forgiven inputs can be ready together under declared-priority. A missing match, or more than one match, makes the adoption invalid, and this test fails. Where no such situation exists, this test checks nothing.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and its cited prose, not the running game
When: a reviewer lists every situation where forgiven inputs can be ready together and compares the list with competition-rules
Then: every listed situation has exactly one matching competition-rules row
a missing row, or more than one matching row, makes the adoption invalid, and this test fails; where no situation can make inputs ready together, this test checks nothing
Diagnostics: soulslike-action-buffer-declaration-record

non-priority-answers-have-no-competition-rows

declaration check: non-priority answers declare no competition rows

scenarioonce

Does not apply to soulslike-action-buffer: ready together is declared priority, not all ready actions or cannot coincide.

no-external-rule-promises-forgiveness

declaration check: unmatched actions have no external forgiveness promise

scenarioonce

Applies to soulslike-action-buffer.

This declaration check reads the adoption and its cited prose, not the running game. The contract says no cited game rule outside these rows promises forgiveness for an unmatched action or input. Any such promise makes the adoption invalid, and this test fails.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and all prose it cites, not the running game
When: a reviewer searches outside these rows for a promise that an unmatched action or input receives forgiveness
Then: no cited game rule outside these rows promises forgiveness for an unmatched action or input
any such promise makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

late-action-citation-duty

declaration check: `Row.id`'s action citation states its duty

scenarioper late-input-windows row

Does not apply to soulslike-action-buffer: late-input-windows has no rows.

late-arming-citation-duty

declaration check: `Row.id`'s arming citation states its duty

scenarioper late-input-windows row

Does not apply to soulslike-action-buffer: late-input-windows has no rows.

late-window-citation-duty

declaration check: `Row.id`'s window citation states its duty

scenarioper late-input-windows row

Does not apply to soulslike-action-buffer: late-input-windows has no rows.

late-cancellation-citation-duty

declaration check: `Row.id`'s cancellation citation states its duty

scenarioper late-input-windows row

Does not apply to soulslike-action-buffer: late-input-windows has no rows.

buffer-action-citation-duty · dodge-during-recovery

declaration check: `dodge-during-recovery`'s action citation states its duty

scenarioper input-buffers row

Applies to the dodge-during-recovery row.

This declaration check reads the adoption and combat.dodge-action, not the running game. The action-declared-in description requires the citation to identify dodge as the row's action scope and name ordinary permission and the complete effect; for the reserved all-actions spelling, it names these for every action in the set. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.dodge-action, not the running game
When: a reviewer checks the citation's meaning
Then: combat.dodge-action identifies the row's action scope and names ordinary permission and the complete effect; for the reserved all-actions spelling, it names these for every action in the set, as the action-declared-in description requires
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

buffer-action-citation-duty · light-attack-during-recovery

declaration check: `light-attack-during-recovery`'s action citation states its duty

scenarioper input-buffers row

Applies to the light-attack-during-recovery row.

This declaration check reads the adoption and combat.light-attack-action, not the running game. The action-declared-in description requires the citation to identify light-attack as the row's action scope and name ordinary permission and the complete effect; for the reserved all-actions spelling, it names these for every action in the set. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.light-attack-action, not the running game
When: a reviewer checks the citation's meaning
Then: combat.light-attack-action identifies the row's action scope and names ordinary permission and the complete effect; for the reserved all-actions spelling, it names these for every action in the set, as the action-declared-in description requires
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

buffer-action-citation-duty · item-during-recovery

declaration check: `item-during-recovery`'s action citation states its duty

scenarioper input-buffers row

Applies to the item-during-recovery row.

This declaration check reads the adoption and combat.use-item-action, not the running game. The action-declared-in description requires the citation to identify use-item as the row's action scope and name ordinary permission and the complete effect; for the reserved all-actions spelling, it names these for every action in the set. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.use-item-action, not the running game
When: a reviewer checks the citation's meaning
Then: combat.use-item-action identifies the row's action scope and names ordinary permission and the complete effect; for the reserved all-actions spelling, it names these for every action in the set, as the action-declared-in description requires
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

buffer-arming-citation-duty · dodge-during-recovery

declaration check: `dodge-during-recovery`'s arming citation states its duty

scenarioper input-buffers row

Applies to the dodge-during-recovery row.

This declaration check reads the adoption and combat.dodge-input-during-recovery, not the running game. The arms-when-declared-in description requires the citation to name every accepted early state, the matching action input, and the excluded cases for dodge-during-recovery. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.dodge-input-during-recovery, not the running game
When: a reviewer checks the citation's meaning
Then: combat.dodge-input-during-recovery names every accepted early state, the matching action input, and the excluded cases for dodge-during-recovery, as the arms-when-declared-in description requires
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

buffer-arming-citation-duty · light-attack-during-recovery

declaration check: `light-attack-during-recovery`'s arming citation states its duty

scenarioper input-buffers row

Applies to the light-attack-during-recovery row.

This declaration check reads the adoption and combat.light-attack-input-during-recovery, not the running game. The arms-when-declared-in description requires the citation to name every accepted early state, the matching action input, and the excluded cases for light-attack-during-recovery. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.light-attack-input-during-recovery, not the running game
When: a reviewer checks the citation's meaning
Then: combat.light-attack-input-during-recovery names every accepted early state, the matching action input, and the excluded cases for light-attack-during-recovery, as the arms-when-declared-in description requires
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

buffer-arming-citation-duty · item-during-recovery

declaration check: `item-during-recovery`'s arming citation states its duty

scenarioper input-buffers row

Applies to the item-during-recovery row.

This declaration check reads the adoption and combat.item-input-during-recovery, not the running game. The arms-when-declared-in description requires the citation to name every accepted early state, the matching action input, and the excluded cases for item-during-recovery. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.item-input-during-recovery, not the running game
When: a reviewer checks the citation's meaning
Then: combat.item-input-during-recovery names every accepted early state, the matching action input, and the excluded cases for item-during-recovery, as the arms-when-declared-in description requires
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

buffer-window-citation-duty · dodge-during-recovery

declaration check: `dodge-during-recovery`'s window citation states its duty

scenarioper input-buffers row

Applies to the dodge-during-recovery row.

This declaration check reads the adoption and combat.dodge-recovery-buffer, not the running game. The window-declared-in description requires the citation to state a positive duration, unit, inclusive last moment, clock, pause behavior, and open-state test for dodge-during-recovery. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.dodge-recovery-buffer, not the running game
When: a reviewer checks the citation's meaning
Then: combat.dodge-recovery-buffer states a positive duration, unit, inclusive last moment, clock, pause behavior, and open-state test for dodge-during-recovery, as the window-declared-in description requires
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

buffer-window-citation-duty · light-attack-during-recovery

declaration check: `light-attack-during-recovery`'s window citation states its duty

scenarioper input-buffers row

Applies to the light-attack-during-recovery row.

This declaration check reads the adoption and combat.light-attack-recovery-buffer, not the running game. The window-declared-in description requires the citation to state a positive duration, unit, inclusive last moment, clock, pause behavior, and open-state test for light-attack-during-recovery. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.light-attack-recovery-buffer, not the running game
When: a reviewer checks the citation's meaning
Then: combat.light-attack-recovery-buffer states a positive duration, unit, inclusive last moment, clock, pause behavior, and open-state test for light-attack-during-recovery, as the window-declared-in description requires
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

buffer-window-citation-duty · item-during-recovery

declaration check: `item-during-recovery`'s window citation states its duty

scenarioper input-buffers row

Applies to the item-during-recovery row.

This declaration check reads the adoption and combat.item-recovery-buffer, not the running game. The window-declared-in description requires the citation to state a positive duration, unit, inclusive last moment, clock, pause behavior, and open-state test for item-during-recovery. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.item-recovery-buffer, not the running game
When: a reviewer checks the citation's meaning
Then: combat.item-recovery-buffer states a positive duration, unit, inclusive last moment, clock, pause behavior, and open-state test for item-during-recovery, as the window-declared-in description requires
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

buffer-firing-citation-duty · dodge-during-recovery

declaration check: `dodge-during-recovery`'s firing citation states its duty

scenarioper input-buffers row

Applies to the dodge-during-recovery row.

This declaration check reads the adoption and combat.dodge-first-ready-moment, not the running game. The citation must name the first ordinary permission event that releases dodge-during-recovery and add no extra delay. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.dodge-first-ready-moment, not the running game
When: a reviewer checks the citation's meaning
Then: combat.dodge-first-ready-moment names the first ordinary permission event that releases dodge-during-recovery and adds no extra delay
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

buffer-firing-citation-duty · light-attack-during-recovery

declaration check: `light-attack-during-recovery`'s firing citation states its duty

scenarioper input-buffers row

Applies to the light-attack-during-recovery row.

This declaration check reads the adoption and combat.light-attack-first-ready-moment, not the running game. The citation must name the first ordinary permission event that releases light-attack-during-recovery and add no extra delay. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.light-attack-first-ready-moment, not the running game
When: a reviewer checks the citation's meaning
Then: combat.light-attack-first-ready-moment names the first ordinary permission event that releases light-attack-during-recovery and adds no extra delay
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

buffer-firing-citation-duty · item-during-recovery

declaration check: `item-during-recovery`'s firing citation states its duty

scenarioper input-buffers row

Applies to the item-during-recovery row.

This declaration check reads the adoption and combat.item-first-ready-moment, not the running game. The citation must name the first ordinary permission event that releases item-during-recovery and add no extra delay. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.item-first-ready-moment, not the running game
When: a reviewer checks the citation's meaning
Then: combat.item-first-ready-moment names the first ordinary permission event that releases item-during-recovery and adds no extra delay
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

buffer-cancellation-citation-duty · dodge-during-recovery

declaration check: `dodge-during-recovery`'s cancellation citation states its duty

scenarioper input-buffers row

Applies to the dodge-during-recovery row.

This declaration check reads the adoption and combat.dodge-buffer-cancellation, not the running game. The citation must name every event that discards dodge-during-recovery before firing or state that no extra event does. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.dodge-buffer-cancellation, not the running game
When: a reviewer checks the citation's meaning
Then: combat.dodge-buffer-cancellation names every event that discards dodge-during-recovery before firing or states that no extra event does
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

buffer-cancellation-citation-duty · light-attack-during-recovery

declaration check: `light-attack-during-recovery`'s cancellation citation states its duty

scenarioper input-buffers row

Applies to the light-attack-during-recovery row.

This declaration check reads the adoption and combat.light-attack-buffer-cancellation, not the running game. The citation must name every event that discards light-attack-during-recovery before firing or state that no extra event does. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.light-attack-buffer-cancellation, not the running game
When: a reviewer checks the citation's meaning
Then: combat.light-attack-buffer-cancellation names every event that discards light-attack-during-recovery before firing or states that no extra event does
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

buffer-cancellation-citation-duty · item-during-recovery

declaration check: `item-during-recovery`'s cancellation citation states its duty

scenarioper input-buffers row

Applies to the item-during-recovery row.

This declaration check reads the adoption and combat.item-buffer-cancellation, not the running game. The citation must name every event that discards item-during-recovery before firing or state that no extra event does. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.item-buffer-cancellation, not the running game
When: a reviewer checks the citation's meaning
Then: combat.item-buffer-cancellation names every event that discards item-during-recovery before firing or states that no extra event does
a missing duty makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

target-action-citation-duty

declaration check: `Row.id`'s action citation states its duty

scenarioper target-moment-windows row

Does not apply to soulslike-action-buffer: target-moment-windows has no rows.

target-moment-citation-duty

declaration check: `Row.id`'s target citation states its duty

scenarioper target-moment-windows row

Does not apply to soulslike-action-buffer: target-moment-windows has no rows.

target-arming-citation-duty

declaration check: `Row.id`'s arming citation states its duty

scenarioper target-moment-windows row

Does not apply to soulslike-action-buffer: target-moment-windows has no rows.

target-window-citation-duty

declaration check: `Row.id`'s window citation states its duty

scenarioper target-moment-windows row

Does not apply to soulslike-action-buffer: target-moment-windows has no rows.

target-result-citation-duty

declaration check: `Row.id`'s result citation states its duty

scenarioper target-moment-windows row

Does not apply to soulslike-action-buffer: target-moment-windows has no rows.

target-cancellation-citation-duty

declaration check: `Row.id`'s cancellation citation states its duty

scenarioper target-moment-windows row

Does not apply to soulslike-action-buffer: target-moment-windows has no rows.

competition-citation-duty · recovery-end-actions

declaration check: `recovery-end-actions`'s competition citation states its duty

scenarioper competition-rules row

Applies to the recovery-end-actions row.

This declaration check reads the adoption and combat.recovery-end-input-priority, not the running game. The citation must identify the matching situation and give one total priority over every forgiven input that can be ready there. A missing input, tie, or other incomplete priority makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the soulslike-action-buffer adoption and the prose at combat.recovery-end-input-priority, not the running game
When: a reviewer checks the citation's meaning
Then: combat.recovery-end-input-priority identifies the matching situation and gives one total priority over every forgiven input that can be ready there
a missing input, tie, or other incomplete priority makes the adoption invalid, and this test fails
Diagnostics: soulslike-action-buffer-declaration-record

forgiveness-holds

input forgiveness holds for the whole run

generalonce

Applies to soulslike-action-buffer.

Across every armed window, saved press, and target instance of the audited run, every forgiven input follows its row and cited rules; unmatched inputs receive no forgiveness; no row holds more than one press; no press is stored or fired twice; every competition follows its declaration; and refusal restores no cleared state. Where this adoption cannot construct a case, this test checks nothing for that case.

Test steps and diagnostics

Holds: across every armed window, saved press, and target instance of the audited run, every forgiven input was accepted, stored, fired, submitted, or cleared exactly as its row and cited rules state; no unmatched input received forgiveness; no row held more than one press; no press was stored twice or fired twice; every competition selected as declared; no refused proposal restored cleared forgiveness state; where the adoption cannot construct a case, this test checks nothing for that case
Seeds: ["audit-a","audit-b"]
Scope: every armed window, saved press, and target instance of the audited run
Diagnostics: soulslike-action-buffer-arming-log
soulslike-action-buffer-input-receipt
soulslike-action-buffer-waiting-press-state
soulslike-action-buffer-window-instances
soulslike-action-buffer-ready-set
soulslike-action-buffer-submission-log
soulslike-action-buffer-clearing-log
soulslike-action-buffer-target-grades

JSONthe adoption as one file

Answers you try on this page do not change this file. To change an adoption, open it in the authoring tool.

{
  "contract": "input-forgiveness",
  "version": 2,
  "summary": "This contract covers inputs accepted just before the game allows the action, just after it stops allowing it, or near a target moment such as a beat or impact. It records which game actions receive that help, what arms each case (makes it ready to accept or save an input), and when a saved action fires (becomes ready for the game to try). This contract does not cover physical controls, ordinary action rules, or small position corrections such as corner correction. The Control options contract covers physical controls.",
  "questions": {
    "ready-together": {
      "asks": "Several inputs that receive this help become ready at the same moment. Which ones does the game try?",
      "rationale": "A landing, beat, or recovery end can make several helped inputs ready. The game must decide which ones to try.",
      "when": {
        "any": [
          {
            "row-count": {
              "late-input-windows": "non-empty"
            }
          },
          {
            "row-count": {
              "input-buffers": "non-empty"
            }
          },
          {
            "row-count": {
              "target-moment-windows": "non-empty"
            }
          }
        ]
      },
      "otherwise": "No forgiveness row can make an input ready.",
      "options": {
        "all-ready-actions": {
          "meaning": "The game tries every helped input that becomes ready. A twin-stick hero may dodge and shoot at the same moment.",
          "semantics": "Every ready forgiven input is submitted once as an action proposal. Event resolution owns their order and the game rules may still refuse incompatible actions."
        },
        "declared-priority": {
          "meaning": "The game tries only one ready input. A fixed priority in your game's rules chooses it. A farm tool may water, and not plant, when both become ready.",
          "semantics": "Exactly one ready forgiven input is submitted. The matching competition-rules row supplies one total priority over every input that can be ready in that situation."
        },
        "cannot-coincide": {
          "meaning": "Two helped inputs can never become ready at the same moment. A one-button rhythm lane has at most one note action at a beat.",
          "semantics": "The adoption guarantees that no reachable game state presents two ready forgiven inputs at one moment. Reaching such a state invalidates the design claim."
        }
      }
    }
  },
  "declares": {
    "values": {},
    "rows": {
      "late-input-windows": {
        "description": "Actions accepted just after ordinary permission ends, such as a platformer jump after leaving walkable ground.",
        "when-empty": "No action remains available through input forgiveness after its ordinary permission ends.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name in your game's words, such as jump-after-ground."
          },
          "action": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The game action receiving late forgiveness, such as jump. Write all-actions to cover every action in the game."
          },
          "action-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say what the action is, when the game ordinarily permits it, and what its complete effect is. When this row uses all-actions, the rules say these things for every action in the game."
          },
          "arms-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say which transitions start this late case. The rules name every transition that starts it and every similar transition that does not. A platformer may name walking off ground and exclude jumping from it."
          },
          "window-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say how this late window is timed. The rules give its duration, which is above zero. They give the unit of the duration. They name the last moment at which the window is still open. They name the clock that measures the window. They say what a pause does to the window. They say how to test whether the window is open."
          },
          "cancels-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say which game events end this forgiveness before the cited window closes. The rules name every such event, or they say that there is no such event."
          }
        }
      },
      "input-buffers": {
        "description": "Early presses saved until an action first becomes ordinarily permitted, such as dodge pressed during attack recovery.",
        "when-empty": "No early press waits for an action to become ordinarily permitted.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name in your game's words, such as dodge-during-recovery."
          },
          "action": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The game action whose early press may wait, such as dodge. Write all-actions to cover every action in the game."
          },
          "action-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say what the action is, when the game ordinarily permits it, and what its complete effect is. When this row uses all-actions, the rules say these things for every action in the game."
          },
          "arms-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say in which early states the game saves a press. The rules name the accepted early states, the excluded states, and the matching action input. A soulslike may accept dodge during recovery but exclude menus, stun, and defeat."
          },
          "window-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say how the window of this saved press is timed. The rules give its duration, which is above zero. They give the unit of the duration. They name the last moment at which the window is still open. They name the clock that measures the window. They say what a pause does to the window. They say how to test whether the window is open."
          },
          "fires-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say which event releases the saved action. It is the first event at which the game ordinarily permits the action. A landing may release jump; the end of recovery may release dodge."
          },
          "cancels-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say which events discard the saved press before it fires. The rules name every such event, or they say that there is no such event."
          },
          "waiting-press": {
            "type": "string",
            "required": true,
            "options": [
              "first-press-stays",
              "latest-press-replaces"
            ],
            "description": "Which press this row keeps when a matching press arrives while the row already holds one: the first press stays, or the latest press replaces it. A menu confirm may keep the first click or replace it with the second."
          },
          "held-after-fire": {
            "type": "string",
            "required": true,
            "options": [
              "fresh-press-required",
              "hold-can-repeat"
            ],
            "description": "Whether a control that stays held after this saved press fires needs a release and a new press, or may save another press. A racing boost may repeat from one hold."
          }
        }
      },
      "target-moment-windows": {
        "description": "Inputs accepted near a cited target moment, such as a rhythm beat or an incoming strike's impact.",
        "when-empty": "No input is forgiven because it arrives near a target moment.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name in your game's words, such as lead-note-hit or sword-impact-parry."
          },
          "action": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The game action judged against the target moment, such as hit-note or parry. Write all-actions to cover every action in the game."
          },
          "action-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say what the action input is, when the game ordinarily permits the action, and what its complete attempt is. This target row grades an attempt; it does not grant permission. When this row uses all-actions, the rules say these things for every action in the game."
          },
          "target-moment-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say what the target moment is."
          },
          "arms-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say which event creates the current target instance and which input events are associated with it."
          },
          "window-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say how the outer window around the target moment is timed. One rule gives all of this timing. It gives the early and late bounds of the window, which have a positive width. It names the early and late moments that are still inside the window. It gives the unit. It names the clock that measures the window. It says what a pause does to the window. It says how to test whether the window is open."
          },
          "result-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say what result an accepted input gets. The same rules define any grade boundaries inside this row's one outer window; a rhythm note may record perfect, great, or good. By default, the target accepts no further input after the first accepted input. If your game does this differently, the rules say how."
          },
          "cancels-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say which events stop this target instance from accepting input before the cited window closes. The rules name every such event, or they say that there is no such event."
          }
        }
      },
      "competition-rules": {
        "description": "Situations where several helped inputs are ready together and one fixed game priority selects a single attempt. Rows exist only under the declared-priority answer; an adoption answering otherwise, or answering nothing, has none.",
        "when-empty": "No competition priority rule is declared.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name in your game's words, such as recovery-end-actions."
          },
          "declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules say what the situation is. The rules give one complete priority order, with no ties, over every helped input that can be ready there."
          }
        }
      }
    }
  },
  "rules": {},
  "origin": "https://opengdd.org/contracts/input-forgiveness-2",
  "mechanism": [
    "This text decides the order of the steps for when forgiveness arms, what input it captures or accepts, how repeated and competing inputs settle, when an action fires, and what clears the forgiveness state. The questions and rows supply choices and cited game rules. They do not change the order.",
    "An action or input not matched by a row in the current situation receives no forgiveness from this adoption, and no cited game rule outside these rows promises it any.",
    "An **action input** is the input event that the game receives after Control options maps a physical control. **Ordinary permission** is the action's legal state before any forgiveness. A **ready forgiven input** is either an input accepted for immediate submission by a late or target row, or a saved buffered press whose cited firing event has arrived. A **target moment** is the cited beat, impact, cue, or comparable game instant against which input timing is judged. A target instance is **settled** when it may accept no further input; the first accepted input settles it unless the cited result rule says otherwise. A **press** is the arrival of the action input, whichever physical edge the cited action rule uses — a release-triggered action counts. For every forgiveness row set, when §4's agreeing Timed window adoption exists for a cited window, runtime openness reads from it; otherwise the cited Fixed timing rule decides.",
    "### Arm forgiveness windows",
    "1. Arming runs on game events, not on input receipt. Whenever a row's cited arming event occurs, it creates one window instance under the cited Fixed timing rule: a late event creates one instance for that loss of permission, and a target event creates one per-target instance, in both cases before and independently of any input. A buffer's per-press instance is the exception: the qualifying press itself creates it at the moment step 6 stores the press. This contract owns those instance scopes.",
    "### Receive an action input",
    "2. Map the physical control to its game action through Control options. Read the action's ordinary permission and every matching row for the current situation. Physical device identity does not change a row's settlement. By default, a control already held when a late or target row arms creates no action input; the cited action rule may explicitly define a different input.",
    "3. Ordinary permission gates only late-input and buffer evaluation. When the action is ordinarily permitted, do not evaluate those two row sets. Do not submit yet: the target branch in step 4 runs whether ordinary permission is present or absent.",
    "4. Evaluate every matching target row for its associated target instance, regardless of ordinary permission. An open row can grade only an otherwise-legal attempt; it never grants ordinary permission. The accepted input becomes ready now, and the first accepted input settles the target unless that result rule says otherwise. Two rows of one row set matching one input in the same situation are an invalid adoption rather than an implicit choice.",
    "5. If a target row accepted this input, end this receipt. If no target row accepts and ordinary permission exists, submit the ordinary attempt without forgiveness and end this receipt. Otherwise — ordinary permission is absent — a matching late row may accept after its cited arming event while its window is open. An accepted late input becomes ready now.",
    "6. If neither a target row nor a late row accepts, a matching input-buffer row may save the press only while its cited arming rule holds. Storing the press creates its per-press window instance. The row stores at most one press, its action, input moment, and that instance. For a row whose action is the reserved `all-actions` spelling, a press of any covered action is a matching press of that row. If one already waits, apply that row's `waiting-press` field: `first-press-stays` ignores the later press, while `latest-press-replaces` clears the earlier press and creates a new instance for the later one.",
    "### Advance, fire, and clear rows",
    "7. A live late-input row ends when its action executes, ordinary permission returns, the cited timing window closes, or its cited early-clearing event occurs. Action execution cannot arm a replacement late window.",
    "8. A waiting buffer clears without firing when its cited timing window closes or its cited early-clearing event occurs. If neither happens, the first cited ordinary permission event makes it ready. No later input poll or extra delay is inserted.",
    "9. A target-moment row accepts no further input for a target instance after the cited timing window closes, the target is settled, or its cited early-clearing event occurs. Whether the window was open at the input moment follows the openness rule in this section's definitions.",
    "10. Collect every ready forgiven input at this game moment. A ready input exists once; a repeated update cannot create another copy from the same stored press or accepted input. When two adoptions of this contract produce ready inputs at one moment, settle each adoption independently, then submit all inputs selected by either adoption together.",
    "### Settle competition and submit attempts",
    "11. Under `all-ready-actions`, submit every ready forgiven input once. Under `declared-priority`, find the one matching competition row and submit only its highest-priority input; every situation in which forgiven inputs can be ready together has exactly one such row; the cited priority holds stable for the whole settlement moment. Clear every lower-priority ready input without submitting it. Under `cannot-coincide`, two ready inputs invalidate the design claim.",
    "12. Submit selected inputs as action proposals at this moment. Event resolution owns the order of proposals that share the moment. The action's Fixed rules own cost, effect, and any refusal after submission. Forgiveness does not force an otherwise conflicting action to succeed.",
    "13. Clear each buffered press that was submitted, and each buffered press that was a lower-priority ready input in step 11, immediately. Clear a submitted late window. A late window whose input was a lower-priority ready input in step 11 stays open until its own close or clearing event; while it remains open it may accept a new press, and the cleared input is not restored. A target instance whose input was a lower-priority ready input in step 11 stays open until settled or closed; under the default first-accepted rule it is already settled. A target input has no saved press after submission.",
    "14. Apply the firing buffer row's `held-after-fire` field only after its action fires and its saved press has been cleared. Under `fresh-press-required`, held state creates nothing until release and a new press. Under `hold-can-repeat`, the uninterrupted hold creates one new press when that row's arming condition next holds. If its cited window later closes while the hold and arming condition still hold, clear it and create one new waiting press immediately. At most one waits in the row.",
    "15. A refused action proposal does not restore its cleared forgiveness state. A new attempt needs a new qualifying arming event or press. Event resolution owns the consequences of the refusal; this contract owns only the cleared forgiveness state.",
    "The order of the steps is: arming, physical input mapping, ordinary permission, target acceptance, late acceptance, buffer capture, repeated-press choice, cited open-window and early-clearing state, firing event, competition selection, same-moment event order, action rules, clearing, and held-input renewal. A later step never rewrites an earlier input moment or target moment."
  ],
  "pack": "sha256:3312fb675aadc6b6160b2ee5ae71f1023a73fd544a1e5489d645188e72f8e4cd",
  "answers": {
    "ready-together": "declared-priority"
  },
  "values": {},
  "rows": {
    "late-input-windows": [],
    "input-buffers": [
      {
        "id": "dodge-during-recovery",
        "action": "dodge",
        "action-declared-in": "combat.dodge-action",
        "arms-when-declared-in": "combat.dodge-input-during-recovery",
        "window-declared-in": "combat.dodge-recovery-buffer",
        "fires-when-declared-in": "combat.dodge-first-ready-moment",
        "cancels-when-declared-in": "combat.dodge-buffer-cancellation",
        "waiting-press": "first-press-stays",
        "held-after-fire": "fresh-press-required"
      },
      {
        "id": "light-attack-during-recovery",
        "action": "light-attack",
        "action-declared-in": "combat.light-attack-action",
        "arms-when-declared-in": "combat.light-attack-input-during-recovery",
        "window-declared-in": "combat.light-attack-recovery-buffer",
        "fires-when-declared-in": "combat.light-attack-first-ready-moment",
        "cancels-when-declared-in": "combat.light-attack-buffer-cancellation",
        "waiting-press": "latest-press-replaces",
        "held-after-fire": "hold-can-repeat"
      },
      {
        "id": "item-during-recovery",
        "action": "use-item",
        "action-declared-in": "combat.use-item-action",
        "arms-when-declared-in": "combat.item-input-during-recovery",
        "window-declared-in": "combat.item-recovery-buffer",
        "fires-when-declared-in": "combat.item-first-ready-moment",
        "cancels-when-declared-in": "combat.item-buffer-cancellation",
        "waiting-press": "latest-press-replaces",
        "held-after-fire": "fresh-press-required"
      }
    ],
    "target-moment-windows": [],
    "competition-rules": [
      {
        "id": "recovery-end-actions",
        "declared-in": "combat.recovery-end-input-priority"
      }
    ]
  }
}

Soulslike action buffer

Use in your package

The contract that this adoption uses

Questions

Several inputs that receive this help become ready at the same moment. Which ones does the game try?

Late input windows

Input buffers

Target moment windows

Competition rules

input forgiveness uses the mapped action input and cited openness

an unmatched action input receives no forgiveness

empty row sets create no forgiveness state

Row.id arms one late window on its cited event

Row.id creates one instance for each cited target

dodge-during-recovery creates no instance before its qualifying press

light-attack-during-recovery creates no instance before its qualifying press

item-during-recovery creates no instance before its qualifying press

input receipt maps the control before reading forgiveness

target, late, buffer, and ordinary receipt keep their fixed order

Row.id accepts and grades only an open, otherwise-legal attempt

Row.id accepts through its cited last moment and not later

dodge-during-recovery stores one press and follows first-press-stays

light-attack-during-recovery stores one press and follows latest-press-replaces

item-during-recovery stores one press and follows latest-press-replaces

Row.id ends on execution, permission, close, or early clearing

dodge-during-recovery fires once at its first cited event or clears without firing

light-attack-during-recovery fires once at its first cited event or clears without firing

item-during-recovery fires once at its first cited event or clears without firing

Row.id accepts nothing after close, settlement, or early clearing

each ready forgiven input exists once

all-ready-actions submits every ready input once

declared-priority submits one input by a stable priority

cannot-coincide allows no reachable pair of ready inputs

selected inputs become proposals at this moment

dodge-during-recovery clears after submission

light-attack-during-recovery clears after submission

item-during-recovery clears after submission

dodge-during-recovery clears when its input is not selected

light-attack-during-recovery clears when its input is not selected

item-during-recovery clears when its input is not selected

Row.id clears on submission

Row.id does not end when its input is not selected

Row.id leaves no saved press after submission

Row.id remains open when its input is not selected, until settled or closed

dodge-during-recovery follows fresh-press-required after its action fires

light-attack-during-recovery follows hold-can-repeat after its action fires

item-during-recovery follows fresh-press-required after its action fires

a refused proposal restores no forgiveness state

a later step of the forgiveness order never rewrites earlier moments

declaration check: no row set has two rows matching one input

declaration check: declared-priority has one matching competition row

declaration check: non-priority answers declare no competition rows

declaration check: unmatched actions have no external forgiveness promise

declaration check: Row.id's action citation states its duty

declaration check: Row.id's arming citation states its duty

declaration check: Row.id's window citation states its duty

declaration check: Row.id's cancellation citation states its duty

declaration check: dodge-during-recovery's action citation states its duty

declaration check: light-attack-during-recovery's action citation states its duty

declaration check: item-during-recovery's action citation states its duty

declaration check: dodge-during-recovery's arming citation states its duty

declaration check: light-attack-during-recovery's arming citation states its duty

declaration check: item-during-recovery's arming citation states its duty

declaration check: dodge-during-recovery's window citation states its duty

declaration check: light-attack-during-recovery's window citation states its duty

declaration check: item-during-recovery's window citation states its duty

declaration check: dodge-during-recovery's firing citation states its duty

declaration check: light-attack-during-recovery's firing citation states its duty

declaration check: item-during-recovery's firing citation states its duty

declaration check: dodge-during-recovery's cancellation citation states its duty

declaration check: light-attack-during-recovery's cancellation citation states its duty

declaration check: item-during-recovery's cancellation citation states its duty

declaration check: Row.id's action citation states its duty

declaration check: Row.id's target citation states its duty

declaration check: Row.id's arming citation states its duty

declaration check: Row.id's window citation states its duty

declaration check: Row.id's result citation states its duty

declaration check: Row.id's cancellation citation states its duty

declaration check: recovery-end-actions's competition citation states its duty

input forgiveness holds for the whole run

`Row.id` arms one late window on its cited event

`Row.id` creates one instance for each cited target

`dodge-during-recovery` creates no instance before its qualifying press

`light-attack-during-recovery` creates no instance before its qualifying press

`item-during-recovery` creates no instance before its qualifying press

`Row.id` accepts and grades only an open, otherwise-legal attempt

`Row.id` accepts through its cited last moment and not later

`dodge-during-recovery` stores one press and follows `first-press-stays`

`light-attack-during-recovery` stores one press and follows `latest-press-replaces`

`item-during-recovery` stores one press and follows `latest-press-replaces`

`Row.id` ends on execution, permission, close, or early clearing

`dodge-during-recovery` fires once at its first cited event or clears without firing

`light-attack-during-recovery` fires once at its first cited event or clears without firing

`item-during-recovery` fires once at its first cited event or clears without firing

`Row.id` accepts nothing after close, settlement, or early clearing

`dodge-during-recovery` clears after submission

`light-attack-during-recovery` clears after submission

`item-during-recovery` clears after submission

`dodge-during-recovery` clears when its input is not selected

`light-attack-during-recovery` clears when its input is not selected

`item-during-recovery` clears when its input is not selected

`Row.id` clears on submission

`Row.id` does not end when its input is not selected

`Row.id` leaves no saved press after submission

`Row.id` remains open when its input is not selected, until settled or closed

`dodge-during-recovery` follows `fresh-press-required` after its action fires

`light-attack-during-recovery` follows `hold-can-repeat` after its action fires

`item-during-recovery` follows `fresh-press-required` after its action fires

declaration check: `Row.id`'s action citation states its duty

declaration check: `Row.id`'s arming citation states its duty

declaration check: `Row.id`'s window citation states its duty

declaration check: `Row.id`'s cancellation citation states its duty

declaration check: `dodge-during-recovery`'s action citation states its duty

declaration check: `light-attack-during-recovery`'s action citation states its duty

declaration check: `item-during-recovery`'s action citation states its duty

declaration check: `dodge-during-recovery`'s arming citation states its duty

declaration check: `light-attack-during-recovery`'s arming citation states its duty

declaration check: `item-during-recovery`'s arming citation states its duty

declaration check: `dodge-during-recovery`'s window citation states its duty

declaration check: `light-attack-during-recovery`'s window citation states its duty

declaration check: `item-during-recovery`'s window citation states its duty

declaration check: `dodge-during-recovery`'s firing citation states its duty

declaration check: `light-attack-during-recovery`'s firing citation states its duty

declaration check: `item-during-recovery`'s firing citation states its duty

declaration check: `dodge-during-recovery`'s cancellation citation states its duty

declaration check: `light-attack-during-recovery`'s cancellation citation states its duty

declaration check: `item-during-recovery`'s cancellation citation states its duty

declaration check: `Row.id`'s action citation states its duty

declaration check: `Row.id`'s target citation states its duty

declaration check: `Row.id`'s arming citation states its duty

declaration check: `Row.id`'s window citation states its duty

declaration check: `Row.id`'s result citation states its duty

declaration check: `Row.id`'s cancellation citation states its duty

declaration check: `recovery-end-actions`'s competition citation states its duty