Pointer command

pointer-command-2

Tests included

This contract defines the behavior of pointer commands: click to move, unit selection, or a tap on a target.

This contract decides what a mouse click or screen tap does: what it selects, what it orders, and what a cancel ends.

Use in your package

The first button opens the authoring tool with this contract added and its questions unanswered. You can also download the zip file and add the contract later.

Open in the authoring tool Download zip file

What is in the zip file

The zip file holds the contract 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/. Fill in the answers there.

Download contract JSON · Download verification pack

Questions

Up to 6 questions. Some appear only after earlier answers.

Try the answers

Pick answers to see which rules and tests apply. Nothing is saved here. In the zip file and in the authoring tool, the questions have no answers yet.

Show exact wording for builders

Who receives a command made by pointing at the world?

Fixed actor	One fixed actor or party receives every world command. An ARPG hero moves wherever the ground is clicked. Every proposed command names the actor or party fixed by its cited command rule. No world selection is required to supply a receiver.
Current selection	The current world selection receives every command. An RTS order moves the selected squad. The receiver set is the complete current selection. An empty set is refused as a receiver.
World target	The command belongs to the place or object under the pointer, without a selected actor. A colony work order marks one ore tile for any worker. A proposed command names its world target and no selected receiver. The cited game rule owns any later choice of actor, worker, structure, or world system that carries it out.

Why this is asked

A pointer command may control one fixed actor, the current selection, or the place the pointer is on.

When the pointer just misses a target, what can it choose?

Exact point only	Only the exact place or object under the pointer counts. A click beside a chest does not choose it. Candidate lookup uses the exact pointer point and applies no near-miss reach.
Nearest within reach	The nearest candidate inside the game's declared reach counts. A click beside a small lever can choose it. Candidate lookup chooses the nearest selectable candidate inside the cited reach and uses the cited complete tie-break.

Why this is asked

The game can require the exact point or choose the nearest candidate inside a declared reach.

The player clicks or drags to select units, and nothing is there. What happens to the current selection?

Asked when: the selection gestures list has at least one row.
If not asked: No pointer gesture changes the current world selection.

Clear selection	The current selection is cleared. A tactics click on open ground leaves no unit selected. An empty result empties the current selection.
Keep selection	The current selection stays. A colony drag across bare ground leaves the chosen workers selected. An empty result keeps the current selection.

Why this is asked

An empty click or box can clear the selection or leave the current selection in place. The answer applies only to selection gestures whose change is replace. When no such row exists, the answer has no effect.

The player points at an invalid target for the chosen ability or verb. Does the game keep waiting for another target?

Asked when: the targeted verbs list has at least one row.
If not asked: No chosen ability or verb waits for a world target from the pointer.

Keep targeting	The game keeps waiting for another point. An ARPG fire spell still waits after the player points outside its range. After an invalid target, the same chosen verb stays active.
Leave targeting	The game stops waiting after the invalid point. A tower placement returns to ordinary pointing after a blocked tile. After an invalid target, the chosen verb is cleared.

Why this is asked

The game can wait for the player to point again, or it can return to ordinary pointing.

The player holds the key that adds an order to the queue. Where does the new order go?

Asked when: the queue modifiers list has at least one row.
If not asked: No pointer modifier adds a command to a queue.

Append at end	The new order goes to the end of the queue. An RTS shift-order adds a final waypoint. The declared placement is after every waiting command for the same plan owner.
Insert next	The new order becomes the next order after the current one. A colony emergency repair runs before work already waiting. The declared placement is before every waiting command for the same plan owner.

Why this is asked

The new order may wait at the end of the queue, or become the next order after the current one.

A new order arrives while another order is waiting. The player does not hold the key that adds an order to the queue. What happens?

Asked when: the context commands list has at least one row, or the targeted verbs list has at least one row.
If not asked: No pointer command can enter a queue.

Replaces waiting	The new order replaces every order waiting in its owner's queue. A hero turns toward the newest clicked destination. The unmodified placement clears waiting pointer commands for the same plan owner.
Always appends	The new order goes to the end of its owner's queue. A colony keeps each new work mark. The unmodified placement is after every waiting pointer command for the same plan owner.
Rejected while busy	The new order is refused while its owner has an order waiting. A build tool accepts no second placement until the first is no longer waiting. An unmodified proposal is refused while its plan owner has a waiting pointer command.

Why this is asked

An order given without that key can replace the orders that wait in the queue, join the end of the queue, or be refused while its owner has an order waiting.

Lists5 lists

Some settings are lists of rows.

A reference points to a number or a rule in your design. For a number, use the address of a decided number in your tuning, not an open one. For a rule, use its file and heading, such as 02-mechanics.md#recovery. The reference must match exactly one heading in that file. No > DELEGATED: or > PERSONALIZATION: tag may cover any part of the section under that heading. Each field's description says what it needs.

Selection gestures

selection-gestures

Pointer gestures that replace, add, remove, or toggle actors or world objects in the current selection.

An empty list means: No pointer gesture changes the current world selection.

Each row is: id, gesture, resolves-on, shape, change, gesture-declared-in, candidates-declared-in.

Every field

Field	Kind	When it appears	Meaning
`id`	string	Required	A short name in your game's words, such as point-select or box-select.
`gesture`	string	Required	The pointer action that the game receives after physical input mapping, such as select-point or select-area.
`resolves-on`	choice: press, release, drag-complete	Required	The pointer phase that settles the selection. A tactics point may settle on release; an RTS box settles when its drag completes.
`shape`	choice: point, area	Required	Whether the gesture tests one pointer point or the cited dragged area.
`change`	choice: replace, add, remove, toggle	Required	How the selectable results change the current selection. A strategy box may replace it while a modified click adds one unit.
`gesture-declared-in`	reference	Required	Where your game's rules say how the game recognizes this press, release, or drag. The rules include any drag threshold and the geometry of the area.
`candidates-declared-in`	reference	Required	Where your game's rules say which kinds of target can be selected. The rules say when the pointer point or the dragged area includes a target. They give the near-miss reach, when the game uses one. They give a complete tie-break. A point rule may return several candidates, as in double-click select-type.

Context commands

context-commands

Commands chosen directly from the classified world target under a pointer gesture, such as moving on ground or attacking an enemy.

An empty list means: No pointer gesture chooses a command directly from what lies under it.

Each row is: id, gesture, resolves-on, target-kind, command, gesture-declared-in, target-declared-in, area-declared-in, receiver-condition, command-declared-in.

Every field

Field	Kind	When it appears	Meaning
`id`	string	Required	A short name in your game's words, such as move-on-ground or attack-enemy.
`gesture`	string	Required	The pointer action that the game receives after physical input mapping, such as world-command or context-order.
`resolves-on`	choice: press, release, drag-complete	Required	The pointer phase that proposes the command. An action RPG may move on release while a colony designation completes as a drag.
`target-kind`	string	Required	The mutually exclusive world classification that selects this row, such as ground, enemy, door, or buildable-tile.
`command`	string	Required	The game command proposed by this row, such as move, basic-attack, open-door, or place-tower.
`gesture-declared-in`	reference	Required	Where your game's rules say how the game recognizes the pointer action and which phase completes it.
`target-declared-in`	reference	Required	Where your game's rules say how the game classifies what is under the pointer and what the exact target is. For nearest-within-reach, the rules also give the reach and the tie-break.
`area-declared-in`	reference	Present when row resolves on is Drag complete.	Where your game's rules say what the dragged region is, whether its boundary is included, and how the region becomes the command target.
`receiver-condition`	reference	Optional	Where your game's rules say which receiver class this row is limited to, such as worker or soldier. This field is optional.
`command-declared-in`	reference	Required	Where your game's rules say what the command is. The rules name its receiver. They name its target. They say who owns the queue for each target. They say when the command is permitted. They say what happens when the target cannot be reached. They give the complete effect of the command when it is accepted and when it is refused.

Targeted verbs

targeted-verbs

Abilities and verbs that use a pointer-captured world target, whether the verb or the target arrives first. Every targeting state can be left: through leave-targeting, a targeting cancellation row, or the cited start rule.

An empty list means: No chosen ability or verb waits for a world target from the pointer.

Each row is: id, verb, order, confirm-style, target-gesture, confirm-gesture, resolves-on, after-dispatch, starts-when-declared-in, target-gesture-declared-in, confirm-gesture-declared-in, targets-declared-in, area-declared-in, command-declared-in.

Every field

Field	Kind	When it appears	Meaning
`id`	string	Required	A short name in your game's words, such as artillery-target or use-key-on-door.
`verb`	string	Required	The chosen ability or verb applied to the captured world target.
`order`	choice: verb-first, target-first	Required	Whether the verb starts before target capture or arrives from a cited game action after the pointer captures the target.
`confirm-style`	choice: separate-gesture, at-entry-position	Required	Whether confirmation needs another pointer gesture or uses the pointer snapshot captured when this verb entry begins.
`target-gesture`	string	Present when row order is Target first.	The pointer action that captures the world target before the verb arrives.
`confirm-gesture`	string	Present when row confirm style is Separate gesture.	The action that separately confirms this target. It may be a pointer gesture or a cited non-pointer action, such as releasing the held ability key.
`resolves-on`	choice: press, release, drag-complete	Required	The phase that this row uses. With a separate confirmation, it is the phase of the confirming gesture. For a target-first row, it is the phase that captures the target. For a verb-first row that confirms at the entry position, it is the phase that completes the cited entry action. A row that resolves on a completed drag also cites its region rule.
`after-dispatch`	choice: leave-targeting, keep-targeting	Required	Whether a valid dispatched command ends targeting or keeps the same verb ready for another target. A tower tool may remain active for repeated placement.
`starts-when-declared-in`	reference	Required	Where your game's rules say which game action supplies the verb. For a target-first row, this action arrives after the target is captured.
`target-gesture-declared-in`	reference	Present when row order is Target first.	Where your game's rules say how the game recognizes the target-first pointer action and in which phase it captures the target.
`confirm-gesture-declared-in`	reference	Present when row confirm style is Separate gesture.	Where your game's rules say how the game recognizes the confirmation gesture and which phase completes it.
`targets-declared-in`	reference	Required	Where your game's rules say how a target is captured. The rules name every valid target. They give the near-miss reach and the tie-break, when the game uses them. They give the complete test for an invalid target.
`area-declared-in`	reference	Present when row resolves on is Drag complete.	Where your game's rules say what the dragged region is, whether its boundary is included, and how the region becomes the target of the verb.
`command-declared-in`	reference	Required	Where your game's rules say what the command is. The rules name its receiver. They say who owns the queue for each target. They say when the command is permitted. They say what the command costs. They say what happens when the target cannot be reached. They give the complete effect of the command, or its refusal.

Queue modifiers

queue-modifiers

Modifier actions that add matching pointer commands to a queue.

An empty list means: No pointer modifier adds a command to a queue.

Each row is: id, modifier-action, modifier-declared-in, applies-to-declared-in.

Every field

Field	Kind	When it appears	Meaning
`id`	string	Required	A short name in your game's words, such as queue-orders or urgent-work-next.
`modifier-action`	string	Required	The mapped game action held or active when the pointer command completes.
`modifier-declared-in`	reference	Required	Where your game's rules say when this modifier action is active, what the capacity of the queue is, if it has one, and what happens when the queue has no free place.
`applies-to-declared-in`	reference	Required	Where your game's rules say to which context commands and targeted verbs this modifier applies. The rules name every one of them, and they name at least one row of this adoption.

Cancellations

cancellations

Actions that end targeting, abort a selection drag, clear the orders waiting in a queue, or clear the current selection without proposing another command.

An empty list means: No action has a separate cancellation meaning in this adoption.

Each row is: id, action, resolves-on, active-state, result, action-declared-in, state-declared-in.

Every field

Field	Kind	When it appears	Meaning
`id`	string	Required	A short name in your game's words, such as cancel-ability-target or abort-box-select.
`action`	string	Required	The pointer action or other game action that has a cancellation meaning in the cited state.
`resolves-on`	choice: press, release, drag-cancel	Required	The phase of the action that applies the cancellation.
`active-state`	choice: targeting, selection-drag, queued-commands, selection	Required	The state in which this row applies. The state named selection exists while the current selection is not empty. A cancel of an ability uses targeting. An RTS gesture that clears planned orders uses queued-commands.
`result`	choice: ends-targeting, ends-drag, empties-queue, empties-selection	Required	The state change made without another world command. The result matches the row's active state; empties-queue clears the queue named at state-declared-in.
`action-declared-in`	reference	Required	Where your game's rules say how the game recognizes the cancellation action and which phase completes it.
`state-declared-in`	reference	Required	Where your game's rules say when the affected state exists: the targeting state, the selection drag, the queue, or the selection.

For builders

Exact wording for builders and 64 pack tests

Exact wording for builders

This text decides the order of the steps for what a pointer press, drag, or release over the world means; how selection, context command, and targeting states advance; where a queue modifier places a command; and what a cancellation clears. The questions and rows supply choices and cited game rules. They do not change the order.

A game-facing pointer action is the action received after Control options maps a mouse, touch, or stick-driven cursor input. A pointer phase is its press, release, completed drag, or canceled drag. A pointer snapshot is the world point and classified object under the pointer at that phase. The broader game-facing action also includes a cited non-pointer action that supplies a verb, confirmation, or cancellation; a non-pointer action has one completion phase, recorded as its press unless its cited rule names release. The current selection is one set of world objects. It starts empty unless a cited load or scene-entry rule supplies it, lasts until a rule changes it, and may also change through cited control-group recall, unit death, roster change, scene entry, or load. A selection drag starts when its cited gesture rule crosses the drag threshold and lasts until that same gesture completes or cancels. A targeting state holds one chosen ability or verb, or a target-first snapshot while it waits for the verb. A command proposal contains one command, its receiver shape, exact world target, and queue placement. A waiting plan contains pointer commands accepted for later execution for the owner named by the cited command rule. The questions and field descriptions call a waiting plan a queue, and call its commands orders. The game's Fixed command rules own whether a proposal is accepted and what it does.

### Recognize the gesture

1. Control options maps physical input to one game-facing pointer action. The matching cited gesture rule observes its press, movement, and release. This contract does not inspect device identity.

2. On press, record the pointer snapshot needed by the cited gesture rule. A row that resolves on press proceeds immediately, and no later drag or release result is inferred from that press for this contract.

3. While the pointer moves, the cited rule alone decides whether it remains a point gesture, becomes a drag, or is canceled. Its cited distance, duration, geometry, coordinate space, and boundary rule are read directly; this adoption contributes no number. A cited gesture rule may emit repeated completed phases while a control is held.

4. On release, create the final pointer snapshot. A release row resolves now. A recognized drag creates one drag-complete phase; an aborted drag creates one drag-cancel phase belonging to that drag's own game-facing action. One physical sequence cannot produce both a point result and a drag result unless the cited rule creates two distinct game-facing actions.

### Resolve cancellation and targeting

5. At each completed action phase, check cancellation before any other row. A cancellation row matches on three terms of its own: the game-facing action, its resolving phase, and the currently holding active state, checked in this order: targeting, selection-drag, queued-commands, selection. Apply its declared result and end this phase. It proposes no command and performs no selection change beyond empties-selection.

6. For verb-first, a game action named by starts-when-declared-in supplies the verb and begins its targeting entry. For target-first, the capture gesture — matched on its game-facing action, phase, and classified snapshot — captures the world target and begins a target-first state; then the cited game action — a verb coin, pie menu, or command card — supplies the verb. A second entry does not change the active targeting state unless the cited start rule explicitly replaces it.

7. While targeting is active, ordinary selection and direct-command rows do not run. Under separate-gesture, a matching confirmation action reads the pointer snapshot at its completion moment — for a non-pointer confirmation such as a key release, the pointer's position at that release. Under at-entry-position, confirmation reads the entry-time snapshot: the pointer position when a verb-first entry begins or the already captured target for target-first. A drag-complete row also reads its cited region rule, and validity is tested on that region. Apply near-miss-resolution through targets-declared-in, then test validity. A non-matching pointer action has no meaning here unless it matches a cancellation row.

8. For an invalid target, propose no command. Under keep-targeting, preserve the active verb. Under leave-targeting, clear it. The same pointer phase is not then matched against the context-command rows.

9. For a valid target, create one command proposal from the targeted row and its cited rules; under current-selection an empty selection makes it one refused proposal, as in step 12. Preserve the row's after-dispatch result with the proposal. A refused command is still a dispatched proposal, so refusal does not restore targeting unless the cited game rule starts a new instance.

### Resolve selection or a context command

10. With no active targeting state, find the one selection or context row that matches the game-facing action, pointer phase, and classified pointer snapshot. A context row with receiver-condition also matches the receiver class named by that citation; receiver class therefore participates in classification when a row cites it. A receiver-conditioned adoption keeps its receiver set homogeneous for that action: when rows cite different receiver classes for one action, phase, and target kind, the selection holds one class at a time under the receiver-condition citation. This version cannot express different commands for the members of one mixed selection. For one game-facing action and phase, selection rows, context rows, and target-first capture gestures have mutually exclusive classifications. Apply near-miss-resolution through the row's cited target or candidate rule. If no row matches, change no world-command state and record the unmatched classification in step 16.

11. For a selection row, compute its complete candidate set from the cited point or area rule. With an empty result, a replace row applies empty-selection; an add, remove, or toggle row always keeps the current selection, because an empty result gives such a row nothing to add, remove, or toggle. With a non-empty result, apply replace, add, remove, or toggle to the complete set. Commit the new selection once and end this pointer phase.

12. For a context row, copy its classified point or object as the command target. Under fixed-actor, read the fixed receiver from the cited command rule. Under current-selection, copy the complete current selection. An empty copy creates one refused proposal with no world effect and ends at this step; it never reaches queue placement or dispatch. Under world-target, attach no selected receiver and read that exact target's plan owner from the cited command rule. Create one command proposal and continue.

### Place and dispatch the command

13. Read queue modifiers only after the command, receiver, and target are fixed. A matching modifier changes placement, not meaning. Under append-at-end, place the proposal after every waiting pointer command for the same waiting-plan owner. Under insert-next, place it before those waiting commands and after the command already being carried out. The cited modifier rule owns plan capacity and the complete result of the refusal when no place is available; this contract never drops another command implicitly.

14. With a matching modifier, add the proposal at the position from step 13. Without one, read unmodified-command: replaces-waiting clears waiting pointer commands for the same owner, always-appends places the proposal after them, and rejected-while-busy records a refusal and stops when one is waiting. A proposal exists once per completed phase; a held modifier or update cannot add another copy within that phase. After a targeted proposal is dispatched, placed, or refused at this step, apply its row's after-dispatch result: leave-targeting ends the state and keep-targeting preserves it.

15. Submit each dispatched proposal to its cited Fixed command rule. That rule owns permission, cost, range, path request, the unreachable-destination case, effect, refusal, and whether the command already being carried out stops. A queued proposal is submitted when it reaches its declared place. Event resolution owns the order when several proposals share one instant.

16. Record the pointer result: gesture id, resolving phase, pointer snapshot, prior and final targeting state, prior and final selection when changed, command and receiver when proposed, target, queue modifier or unmodified placement outcome, cancellation when used, target validity for every targeted verb that reached a validity test, a no-matching-row result when applicable, and the cited game-rule result when available.

The order of the steps is: physical mapping, gesture recognition, cancellation, targeting entry, target confirmation, selection or context classification, receiver snapshot, queue placement, command dispatch, game rule, and same-instant event order. A later step never changes the pointer snapshot or receiver copied by an earlier step; classification may read receiver class without copying the receiver set.

Verification pack

sha256:e5103351d21ef47e6f90b1e34ceba968cf5bf77ec393a38413f80aa8e442eee1

The format calls an adoption that has its matching pack Checked. The tests are included, but this does not mean that a game has passed them. An adoption without the pack is Promised. The builder must still build the chosen behavior.

64 pack tests

Placeholders are filled from the adoption's answers, numbers, rows, and test inputs.

pointer command uses actions, phases, snapshots, and states

pointer-command-vocabulary

scenarioonce

Applies for every adoption

A game-facing pointer action arrives after physical input mapping. Its pointer phase is a press, release, completed drag, or canceled drag, and its pointer snapshot is the world point and classified object at that phase. A cited non-pointer action has one completion phase. A selection drag and a targeting state begin and end only as the contract states. This test checks nothing about device identity, several simultaneous pointers, or camera view or follow behavior.

Given: the Instance adoption and its cited pointer, action, selection, and command rules
When: the contract's state and records are identified before a pointer phase is resolved
Then: a game-facing pointer action is received after physical input mapping and a pointer phase is its press, release, completed drag, or canceled drag
a pointer snapshot is the world point and classified object under the pointer at that phase
a cited non-pointer action that supplies a verb, confirmation, or cancellation has one completion phase, recorded as press unless its cited rule names release
a selection drag begins when its cited gesture rule crosses the drag threshold and ends when that action completes or cancels
a targeting state holds one chosen verb or one target-first snapshot waiting for the verb
device identity, several simultaneous pointers, and camera view or follow behavior are outside this contract, and this test checks nothing about them
Diagnostics: Instance-pointer-result
Instance-snapshot-log
Instance-targeting-state

selection, proposals, and waiting plans keep distinct meanings

selection-proposal-and-plan-vocabulary

scenarioonce

Applies for every adoption

The current selection is one set and starts empty unless a cited load or scene-entry rule supplies it. It persists until a cited rule changes it. A command proposal contains one command, receiver shape, exact world target, and queue placement. A waiting plan contains pointer commands accepted for later execution for its cited plan owner.

Given: the Instance adoption with distinguishable selection, proposal, and waiting-plan records
When: a selection change and a pointer command are each followed through their declared route
Then: the current selection is one set of world objects and begins empty unless a cited load or scene-entry rule supplies it
the selection persists until a cited pointer, control-group recall, death, roster, scene-entry, or load rule changes it
one command proposal contains one command, its receiver shape, its exact world target, and its queue placement
one waiting plan contains pointer commands accepted for later execution for the plan owner named by the cited command rule
Diagnostics: Instance-selection-state
Instance-proposal-log
Instance-plan-state

selection gesture Row.id resolves at its declared phase

selection-gesture-resolves-at-declared-phase

scenarioper selection-gestures row

Applies for every adoption

Selection row Row.id matches action Row.gesture and Bind phase under Row.gesture declared in. The test names the address and restates nothing from it.

Given: selection row Row.id and the gesture rule at Row.gesture declared in
When: game-facing pointer action Row.gesture is performed through its declared press, movement, and release
Then: Row.id Bind phase
the row matches only its declared game-facing pointer action and resolving phase
the test leaves recognition, thresholds, and geometry to Row.gesture declared in and restates nothing from it
Diagnostics: Instance-pointer-result
Instance-snapshot-log

context command Row.id resolves at its declared phase

context-gesture-resolves-at-declared-phase

scenarioper context-commands row

Applies for every adoption

Context row Row.id matches action Row.gesture and Bind phase under Row.gesture declared in. Where that cited rule emits repeated completed phases while held, each emitted phase produces exactly one Row.command proposal; where it emits none, this test checks nothing about repeated phases. The test names the address and restates nothing from it.

Given: context row Row.id and the gesture rule at Row.gesture declared in
When: game-facing pointer action Row.gesture is performed through its declared press, movement, and release
Then: Row.id Bind phase
the row matches only its declared game-facing pointer action and resolving phase
where Row.gesture declared in emits repeated completed phases while held, each emitted phase produces exactly one Row.command proposal; where it emits none, this test checks nothing in this line
the test leaves recognition, thresholds, and geometry to Row.gesture declared in and restates nothing from it
Diagnostics: Instance-pointer-result
Instance-snapshot-log
Instance-proposal-log

targeted verb Row.id resolves at its declared phase

targeted-verb-resolves-at-declared-phase

scenarioper targeted-verbs row

Applies for every adoption

Targeted verb Row.id Bind phase. One completed phase is recorded before validity is tested, and an incomplete phase creates no command proposal.

Given: targeted-verb row Row.id in its declared targeting route
When: its capture or confirmation reaches Row.resolves on
Then: Row.id Bind phase
one completed phase is recorded before validity is tested
an incomplete phase creates no command proposal
Diagnostics: Instance-pointer-result
Instance-snapshot-log
Instance-proposal-log

the cited gesture rule alone classifies motion

gesture-rule-alone-classifies-motion

scenarioonce

Applies for every adoption

The cited gesture rule alone decides whether movement stays a point gesture, becomes a drag, or cancels. Its distance, duration, geometry, coordinate space, and boundary rule are read directly; this adoption contributes no number.

Given: each pointer action the Instance adoption can perform, including positions on either side of every cited gesture boundary
When: the action moves and ends
Then: the cited gesture rule alone decides point, drag, or cancel
the result follows the cited distance, duration, geometry, coordinate space, and boundary rule
the adoption contributes no gesture quantity of its own
Diagnostics: Instance-pointer-result
Instance-snapshot-log

one physical sequence produces one pointer result

one-physical-sequence-one-result

scenarioonce

Applies for every adoption

One physical sequence produces a point result or a drag result, never both. If the cited rule creates two distinct game-facing pointer actions, each has its own result; otherwise this test checks nothing about that exception.

Given: each physical pointer sequence the Instance adoption can recognize
When: the sequence passes through press, movement, and release
Then: the sequence produces a point result or a drag result, never both
where the cited gesture rule creates two distinct game-facing pointer actions, each action has its own result; otherwise this test checks nothing in this line
Diagnostics: Instance-pointer-result

each repeated completed command phase produces one proposal

repeated-completed-phases-stay-distinct

scenarioonce

Applies for every adoption

Where a cited gesture rule emits repeated completed command phases while held, each phase has its own result and produces exactly one proposal. A held interval with no repeated phase produces no extra proposal. Where no rule emits repeated phases, this test checks nothing.

Given: a held control whose cited gesture rule emits repeated completed command phases, where the adoption has one
When: the control remains held through two cited completed phases
Then: each emitted completed phase has its own pointer result
each completed command phase produces exactly one command proposal
a held interval that emits no repeated completed phase produces no extra proposal
where no cited rule emits repeated completed phases, this test checks nothing
Diagnostics: Instance-pointer-result
Instance-proposal-log

cancellation Row.id applies before any other row

cancellation-applies-before-other-rows

scenarioper cancellations row

Applies for every adoption

Cancellation Row.id matches action Row.action, its Bind phase phase, and the holding state in Row.state declared in before any other row. It Bind result, proposes no command, changes no selection beyond empties-selection, and ends the phase. Where more than one cancellation row could match, the contract checks the holding state in the order targeting, selection-drag, queued-commands, selection. A mismatch does not apply this row, and this test checks nothing about another cancellation row. This test checks nothing about an area cancellation.

Given: cancellation row Row.id, action Row.action, and the cited state at Row.state declared in
When: Bind state and Row.action reaches Bind phase
the most similar case that does not match in action, phase, or holding state is also checked
Then: the complete match is checked before selection, context-command, or targeting rows and Bind result
the matched phase proposes no command, changes no selection beyond empties-selection, and ends immediately
where more than one cancellation row could match, the holding state is checked in the order targeting, selection-drag, queued-commands, selection
the mismatch does not apply Row.id, and this test checks nothing about another cancellation row that matches
this test checks nothing about an area cancellation, if the game has one, because this row has no dragged cancellation region
Diagnostics: Instance-cancellation-log
Instance-targeting-state
Instance-selection-state
Instance-plan-state
Instance-proposal-log

verb-first row Row.id begins from its cited action

verb-first-begins-targeting

scenarioper targeted-verbs row

Applies when row order is Verb first.

For verb-first row Row.id, the action at Row.starts when declared in supplies Row.verb and begins targeting. A second entry does not replace an active state unless that cited rule explicitly does so. The test names the address and restates nothing from it.

Given: targeted-verb row Row.id with no active targeting state and the start rule at Row.starts when declared in
When: the cited game action supplies verb Row.verb
the same entry is attempted while a targeting state is already active
Then: the first action begins a targeting entry holding Row.verb
the second entry does not replace the active state unless Row.starts when declared in explicitly replaces it
the test leaves the start action and any explicit replacement to Row.starts when declared in and restates nothing from it
Diagnostics: Instance-targeting-state
Instance-snapshot-log

target-first row Row.id captures its target before the verb

target-first-captures-before-verb

scenarioper targeted-verbs row

Applies when row order is Target first.

Target-first row Row.id captures the classified target through Row.target gesture at Row.target gesture declared in, then Row.starts when declared in supplies Row.verb. A later entry does not replace an active state unless the start rule explicitly does so. The test names both addresses and restates nothing from them.

Given: targeted-verb row Row.id, capture action Row.target gesture, and the rules at Row.target gesture declared in and Row.starts when declared in
When: Row.target gesture reaches Row.resolves on on a classified snapshot with no active targeting state
the cited game action then supplies verb Row.verb
another entry is attempted while the state is active
Then: the capture stores that exact world target in a target-first state before the verb arrives
the cited start action supplies Row.verb to the stored target
the later entry does not replace the active state unless Row.starts when declared in explicitly replaces it
the test leaves recognition and the start action to the two cited rules and restates nothing from them
Diagnostics: Instance-targeting-state
Instance-snapshot-log

Row.id reads the target when confirmation completes

separate-confirmation-reads-completion-snapshot

scenarioper targeted-verbs row

Applies when row confirm style is Separate gesture.

For Row.id, separate confirmation Row.confirm gesture reads Bind snapshot. A non-pointer confirmation that reads a pointer snapshot uses the pointer position at that action's completion; where this row reads a dragged region, this test checks nothing about that position. Recognition comes from Row.confirm gesture declared in; the test names the address and restates nothing from it.

Given: active targeting for Row.id and confirmation action Row.confirm gesture recognized at Row.confirm gesture declared in
When: the confirmation completes at Row.resolves on after the pointer has moved from the entry position
Then: confirmation reads Bind snapshot
for a non-pointer confirmation that reads a pointer snapshot, the snapshot uses the pointer position at that action's completion; where this row reads a dragged region, this test checks nothing in this line
the test leaves recognition and completion to Row.confirm gesture declared in and restates nothing from it
Diagnostics: Instance-snapshot-log
Instance-targeting-state
Instance-pointer-result

Row.id confirms from its entry snapshot

entry-position-confirmation-keeps-entry-snapshot

scenarioper targeted-verbs row

Applies when row confirm style is At entry position.

At-entry-position row Row.id confirms from Bind source. A later pointer position does not replace that snapshot.

Given: targeted-verb row Row.id with distinguishable entry and later pointer snapshots
When: the row captures its declared entry-time snapshot and the pointer later occupies another position
Then: confirmation reads Bind source
the later pointer position does not replace that snapshot
Diagnostics: Instance-snapshot-log
Instance-targeting-state

dragged verb Row.id uses its cited region

targeted-drag-uses-cited-region

scenarioper targeted-verbs row

Applies when row resolves on is Drag complete.

When Row.id reaches drag-complete, the complete region at Row.area declared in becomes its target. The adoption contributes no endpoint, geometry, coordinate-space, or boundary rule. The test names the address and restates nothing from it.

Given: targeted-verb row Row.id and a completed dragged region governed at Row.area declared in
When: the row reaches drag-complete
Then: the complete region from Row.area declared in becomes the verb target
the test contributes no endpoint, geometry, coordinate-space, or boundary rule
the test names the address and restates nothing from it
Diagnostics: Instance-snapshot-log
Instance-pointer-result

Row.id resolves a candidate and tests validity

targeted-verb-tests-candidate-and-validity

scenarioper targeted-verbs row

Applies for every adoption

Targeted verb Row.id applies near-miss resolution and validity through Row.targets declared in. The result record distinguishes a valid target from an invalid one. The test names the address and restates nothing from it. This test checks nothing for a verb that needs several separately confirmed points.

Given: targeted-verb row Row.id with one cited valid target and one cited invalid target under Row.targets declared in
When: each target reaches the row's confirmation route
Then: candidate lookup applies the adoption's near-miss-resolution answer through Row.targets declared in
the cited validity test records valid for the valid target and invalid for the invalid target
the test leaves target kinds, reach, tie-break, and validity content to Row.targets declared in and restates nothing from it
this test checks nothing for a verb that needs several separately confirmed points
Diagnostics: Instance-snapshot-log
Instance-pointer-result
Instance-targeting-state

an invalid target keeps targeting

invalid-target-keeps-targeting

scenarioonce

Applies when Invalid target is Keep targeting.

An invalid target creates no command proposal and keeps the same chosen verb active. The same phase is never matched against a context-command row. The result records invalid target rather than a refused proposal.

Given: each targeted verb in Instance with an invalid target under its cited target rule
When: the verb reaches confirmation and the target fails validity
Then: no command proposal is created
the same chosen verb remains active for another target
no context-command row runs from the same phase
the pointer result records invalid target rather than a refused proposal
Diagnostics: Instance-pointer-result
Instance-targeting-state
Instance-proposal-log

an invalid target leaves targeting

invalid-target-leaves-targeting

scenarioonce

Applies when Invalid target is Leave targeting.

An invalid target creates no command proposal and clears the chosen verb. The same phase is never matched against a context-command row. The result records invalid target rather than a refused proposal.

Given: each targeted verb in Instance with an invalid target under its cited target rule
When: the verb reaches confirmation and the target fails validity
Then: no command proposal is created
the chosen verb is cleared
no context-command row runs from the same phase
the pointer result records invalid target rather than a refused proposal
Diagnostics: Instance-pointer-result
Instance-targeting-state
Instance-proposal-log

a valid target creates one Row.id proposal

valid-target-creates-one-proposal

scenarioper targeted-verbs row

Applies for every adoption

A valid target for Row.id creates one proposal carrying the exact target, the command from Row.command declared in, and the receiver selected by the command-receiver answer. It Bind after. A refused command remains a dispatched proposal, and the refusal does not restore the earlier targeting instance. The test names the address and restates nothing from it.

Given: targeted-verb row Row.id with a valid resolved target under Row.targets declared in
When: the row completes confirmation and its proposal reaches placement
Then: one command proposal is created with the command from Row.command declared in, the receiver selected by the command-receiver answer, the validated exact target, and a placement outcome
the proposal preserves the row result that Bind after
a refused command remains a dispatched proposal, and the refusal does not restore the earlier targeting instance
the test leaves permission, cost, range, path, unreachable result, effect, and refusal to Row.command declared in and restates nothing from it
Diagnostics: Instance-proposal-log
Instance-targeting-state
Instance-pointer-result
Instance-plan-state

Row.id targeting suppresses ordinary selection and context rows

targeting-suppresses-selection-and-context

scenarioper targeted-verbs row

Applies for every adoption

While the targeting state for Row.id is active, an ordinary selection or context gesture has no meaning. If the same action and phase matches a cancellation row in the holding state, only the cancellation applies. Where the adoption cannot construct one of the two cases, this test checks nothing for that case.

Given: targeted-verb row Row.id's active targeting state and a game-facing pointer action that would match a selection or context row with no targeting state
When: the action completes while targeting is active, first without and then with a matching cancellation row where one exists
Then: without a matching cancellation row, the action changes no selection and creates no context-command proposal
with a matching cancellation row, only that cancellation result applies and the phase ends
where one of the two cases cannot be constructed, this test checks nothing for that case
Diagnostics: Instance-targeting-state
Instance-selection-state
Instance-proposal-log
Instance-cancellation-log

one selection or context row matches without targeting

selection-or-context-row-match

scenarioonce

Applies for every adoption

With no active targeting state, if a selection or context row matches action, phase, and classification, exactly one proceeds. A target-first capture gesture is resolved at targeting entry and is neither a selection or context row match nor an unmatched classification. If no row matches, no world-command state changes and the unmatched classification is recorded. Where no unmatched classification can be constructed, this test checks nothing for that case.

Given: no active targeting state and each classified pointer snapshot the Instance adoption can produce, including an unmatched classification where one can be constructed
When: the game-facing pointer action reaches a completed phase
Then: where a row matches, exactly one selection or context row proceeds from its action, phase, and classification
a target-first capture gesture is resolved at targeting entry and is neither a selection or context row match nor an unmatched classification
where no row matches, no world-command state changes and the result records the unmatched classification
where every classification that can be constructed matches a row, this test checks nothing for the unmatched case
Diagnostics: Instance-pointer-result
Instance-selection-state
Instance-proposal-log

Row.id also matches its cited receiver class

receiver-conditioned-context-match

scenarioper context-commands row

Applies for every adoption

Context row Row.id also matches the receiver class at Bind condition. Where another row cites a different receiver class for the same action, phase, and target kind, the selection holds one class at a time under that citation. The non-matching class matches no row here, changes no world-command state, and is recorded as an unmatched classification. This test checks nothing about different commands for the members of one mixed selection. The test names the address and restates nothing from it.

Given: context row Row.id, the receiver classes distinguished at Bind condition, and otherwise identical action, phase, and target classifications
When: the context action completes once with a matching receiver class and once with a non-matching class
Then: Row.id matches only the receiver class named at Bind condition
where another row cites a different receiver class for the same action, phase, and target kind, the selection holds one class at a time under that citation
the non-matching class matches no row here, changes no world-command state, and is recorded as an unmatched classification
this test checks nothing about different commands for the members of one mixed selection
the test names the address and restates nothing from it
Diagnostics: Instance-pointer-result
Instance-selection-state
Instance-proposal-log

selection row Row.id commits its complete candidate set once

selection-row-uses-complete-candidate-set

scenarioper selection-gestures row

Applies for every adoption

Selection row Row.id reads Bind shape from Row.candidates declared in and Bind change. The phase ends without a proposal. This test checks nothing about selection layers. The test names the address and restates nothing from it.

Given: selection row Row.id with a non-empty and an empty result from Row.candidates declared in
When: Row.gesture completes at Row.resolves on for each result
Then: candidate lookup returns Bind shape through Row.candidates declared in
the row Bind change
the pointer phase ends without a command proposal
the test leaves candidate kinds, inclusion, reach, and tie-break to Row.candidates declared in and restates nothing from it
this test checks nothing about selection layers, because the result is one set
Diagnostics: Instance-selection-state
Instance-pointer-result
Instance-proposal-log

an empty replacement clears the selection

empty-replace-clears-selection

scenarioonce

Applies when Empty selection is Clear selection.

When a replace selection row returns an empty complete candidate set, the current selection is cleared and committed once. The result distinguishes that change from an already empty selection left unchanged. The contract says the answer applies only to selection rows whose change is replace; where the adoption declares none, this answer has no effect, and this test checks nothing.

Given: each replace selection row in Instance, a non-empty current selection, and an empty complete candidate set
When: the selection gesture completes
Then: the current selection is cleared and committed once
the result record distinguishes clearing a non-empty selection from leaving an already empty selection unchanged
where the adoption declares no replace selection row, this answer has no effect, and this test checks nothing
Diagnostics: Instance-selection-state
Instance-pointer-result

an empty replacement keeps the selection

empty-replace-keeps-selection

scenarioonce

Applies when Empty selection is Keep selection.

When a replace selection row returns an empty complete candidate set, the earlier current selection remains unchanged. The result distinguishes the empty candidate set from a non-empty set with the same final members. The contract says the answer applies only to selection rows whose change is replace; where the adoption declares none, this answer has no effect, and this test checks nothing.

Given: each replace selection row in Instance, a distinguishable current selection, and an empty complete candidate set
When: the selection gesture completes
Then: the earlier current selection remains unchanged
the result record distinguishes the empty candidate set from a non-empty set that gives the same selection
where the adoption declares no replace selection row, this answer has no effect, and this test checks nothing
Diagnostics: Instance-selection-state
Instance-pointer-result

context row Row.id copies its target into one proposal

context-row-copies-target-and-creates-proposal

scenarioper context-commands row

Applies for every adoption

Context row Row.id copies the classified Row.target kind point or object from Row.target declared in as its exact target. One proposal is created with command Row.command and the receiver shape selected by the command-receiver answer; its Fixed command rule is at Row.command declared in. The copied target and receiver do not change before placement. The test names both addresses and restates nothing from them.

Given: context row Row.id and a classified Row.target kind snapshot under Row.target declared in
When: Row.gesture completes at Row.resolves on with no active targeting state
Then: the row copies the classified point or object as the exact target
one proposal is created with command Row.command and the receiver shape selected by the command-receiver answer
the proposal proceeds to queue placement without changing the copied target or receiver
the test leaves classification, reach, and tie-break to Row.target declared in and command content to Row.command declared in and restates nothing from them
Diagnostics: Instance-snapshot-log
Instance-proposal-log
Instance-pointer-result

dragged context row Row.id uses its cited region

context-drag-uses-cited-region

scenarioper context-commands row

Applies when row resolves on is Drag complete.

When context row Row.id reaches drag-complete, the complete region at Row.area declared in becomes its target. The adoption contributes no geometry, coordinate-space, or boundary rule. The test names the address and restates nothing from it.

Given: context row Row.id and the completed dragged region at Row.area declared in
When: Row.gesture reaches drag-complete
Then: the complete region from Row.area declared in becomes the command target
the test contributes no geometry, coordinate-space, or boundary rule
the test names the address and restates nothing from it
Diagnostics: Instance-snapshot-log
Instance-pointer-result
Instance-proposal-log

the cited fixed actor receives each command

fixed-actor-receives-command

scenarioonce

Applies when Command receiver is Fixed actor.

Every command proposal copies the fixed actor or party from its cited command rule. No current selection supplies the receiver, and placement does not change it.

Given: each matching context command and valid targeted verb in Instance
When: the command proposal is created
Then: the proposal copies the fixed actor or party from its cited command rule
no current selection is required to supply the receiver
the proposal proceeds through placement with that receiver unchanged
Diagnostics: Instance-proposal-log
Instance-selection-state
Instance-plan-state

the complete current selection receives each command

current-selection-receives-command

scenarioonce

Applies when Command receiver is Current selection.

A non-empty complete current selection is copied as the receiver and its proposal proceeds to placement. An empty copy creates one refused proposal with no world effect and ends before placement or dispatch. For a valid targeted verb, the contract says an empty current selection makes one refused proposal in the same way. The result distinguishes that from no proposal. Later selection changes do not alter the copy.

Given: each matching context command and valid targeted verb in Instance, first with a non-empty current selection and then with an empty one
When: the command proposal reaches receiver resolution
Then: the non-empty case copies the complete current selection and creates one proposal that proceeds to placement
the empty case creates one refused proposal with no world effect and ends before queue placement or command dispatch
for a valid targeted verb, the contract says an empty current selection makes one refused proposal in the same way
the result record distinguishes the refused proposal from no proposal
later selection changes do not change the copied receiver
Diagnostics: Instance-selection-state
Instance-proposal-log
Instance-pointer-result
Instance-plan-state

the exact world target owns each command

world-target-owns-command

scenarioonce

Applies when Command receiver is World target.

Each proposal attaches no selected receiver and reads the exact world target's plan owner from its cited command rule. This test checks nothing about later actor or worker allocation.

Given: each matching context command and valid targeted verb in Instance
When: the command proposal is created
Then: the proposal attaches no selected receiver
the cited command rule supplies the exact target's plan owner
this contract does not perform later actor or worker allocation, and this test checks nothing about it
Diagnostics: Instance-proposal-log
Instance-selection-state
Instance-plan-state

candidate lookup uses the exact pointer point

exact-point-only-resolves-candidates

scenarioonce

Applies when Near miss resolution is Exact point only.

Every candidate lookup uses only the exact pointer point. No near-miss reach adds a candidate; the cited row rule still owns target kinds, point inclusion, and validity.

Given: each candidate lookup in Instance, with one point on a cited target and one point just outside it
When: the pointer snapshot is classified through the row's candidate or target rule
Then: only the exact pointer point is used
no near-miss reach adds a candidate
the cited rule still owns target kinds, point inclusion, and validity
Diagnostics: Instance-snapshot-log
Instance-pointer-result

candidate lookup chooses the cited nearest candidate

nearest-within-reach-resolves-candidates

scenarioonce

Applies when Near miss resolution is Nearest within reach.

Every candidate lookup chooses the nearest selectable candidate inside the reach cited by its row rule; a candidate outside that reach is not chosen. A tie follows the cited complete tie-break; where no tie can be constructed, this test checks nothing about a tie.

Given: each candidate lookup in Instance, with candidates inside and outside the reach and a cited tie where one can be constructed
When: the pointer snapshot is classified through the row's candidate or target rule
Then: the nearest selectable candidate inside the cited reach is chosen
a candidate outside the cited reach is not chosen
a tie follows the complete tie-break in the cited row rule; where no tie can be constructed, this test checks nothing in this line
Diagnostics: Instance-snapshot-log
Instance-pointer-result

queue modifier Row.id appends a matching proposal

queue-modifier-appends-at-end

scenarioper queue-modifiers row

Applies when Queued command placement is Append at end.

When Row.modifier action is active under Row.modifier declared in, modifier Row.id places a matching proposal after every waiting pointer command for the same plan owner without changing its meaning. Capacity and the no-place result stay in that citation, nothing is dropped implicitly, and Row.applies to declared in decides applicability. A command that the applicability rule does not name takes the unmodified-command path even while the modifier action is active. This test checks nothing about placement differences between rows. The test names both addresses and restates nothing from them.

Given: queue modifier Row.id, a matching command named through Row.applies to declared in, and distinguishable current and waiting commands for one plan owner
When: Row.modifier action is active under Row.modifier declared in when the proposal completes
Then: the proposal keeps its command, receiver, and target and is placed after every waiting pointer command for the same owner
the cited modifier rule decides activity, capacity, and the complete no-place result, and no command is dropped implicitly
the applicability rule decides which declared commands this modifier reaches
a command that Row.applies to declared in does not name takes the unmodified-command path even while Row.modifier action is active
this test checks nothing about placement differences between rows, because the answer applies to the whole adoption
the test names both addresses and restates nothing from them
Diagnostics: Instance-proposal-log
Instance-plan-state
Instance-pointer-result

queue modifier Row.id inserts a matching proposal next

queue-modifier-inserts-next

scenarioper queue-modifiers row

Applies when Queued command placement is Insert next.

When Row.modifier action is active under Row.modifier declared in, modifier Row.id places a matching proposal before every waiting pointer command and after the command already being carried out, without changing its meaning. Capacity and the no-place result stay in that citation, nothing is dropped implicitly, and Row.applies to declared in decides applicability. A command that the applicability rule does not name takes the unmodified-command path even while the modifier action is active. This test checks nothing about placement differences between rows. The test names both addresses and restates nothing from them.

Given: queue modifier Row.id, a matching command named through Row.applies to declared in, and distinguishable current and waiting commands for one plan owner
When: Row.modifier action is active under Row.modifier declared in when the proposal completes
Then: the proposal keeps its command, receiver, and target and is placed before every waiting pointer command and after the command already being carried out
the cited modifier rule decides activity, capacity, and the complete no-place result, and no command is dropped implicitly
the applicability rule decides which declared commands this modifier reaches
a command that Row.applies to declared in does not name takes the unmodified-command path even while Row.modifier action is active
this test checks nothing about placement differences between rows, because the answer applies to the whole adoption
the test names both addresses and restates nothing from them
Diagnostics: Instance-proposal-log
Instance-plan-state
Instance-pointer-result

an unmodified command replaces waiting pointer commands

unmodified-command-replaces-waiting

scenarioonce

Applies when Unmodified command is Replaces waiting.

With no matching queue modifier, the proposal clears every waiting pointer command for the same owner and is placed once. Whether a command already being carried out stops belongs to the cited command rule. The plan record distinguishes replacement from an append with the same visible count. This test checks nothing about placement differences between rows, because the answer applies to the whole adoption.

Given: an unmodified proposal in Instance for a plan owner with distinguishable waiting pointer commands
When: the proposal reaches placement with no matching queue modifier
Then: every waiting pointer command for the same owner is cleared
the new proposal is placed once and proceeds to its cited command rule
the command already being carried out stops only if the cited command rule says so
the plan record distinguishes replacement from an append that leaves one visible entry
this test checks nothing about placement differences between rows, because the answer applies to the whole adoption
Diagnostics: Instance-proposal-log
Instance-plan-state
Instance-pointer-result

an unmodified command appends after waiting commands

unmodified-command-always-appends

scenarioonce

Applies when Unmodified command is Always appends.

With no matching queue modifier, the proposal is placed after every waiting pointer command for the same owner. Earlier waiting commands keep their order, and the proposal reaches its cited command rule at that place. This test checks nothing about placement differences between rows, because the answer applies to the whole adoption.

Given: an unmodified proposal in Instance for a plan owner with distinguishable waiting pointer commands
When: the proposal reaches placement with no matching queue modifier
Then: the proposal is placed after every waiting pointer command for the same owner
every earlier waiting command remains in the same order
the new proposal proceeds to its cited command rule when it reaches that place
this test checks nothing about placement differences between rows, because the answer applies to the whole adoption
Diagnostics: Instance-proposal-log
Instance-plan-state
Instance-pointer-result

an unmodified command is accepted only when its plan is not busy

unmodified-command-rejects-while-busy

scenarioonce

Applies when Unmodified command is Rejected while busy.

With no matching queue modifier, a busy plan owner records one refused proposal and keeps the waiting plan unchanged. The same proposal for an owner with no waiting pointer command is placed once and submitted. The log distinguishes a refusal from no proposal. This test checks nothing about placement differences between rows, because the answer applies to the whole adoption.

Given: the same unmodified proposal in Instance, first for a plan owner with one waiting pointer command and then for that owner with none
When: the proposal reaches placement with no matching queue modifier in each state
Then: the busy case records one refused proposal, leaves the waiting plan unchanged, and stops before command-rule submission
the not-busy case places the proposal once and submits it to its cited command rule
the proposal log distinguishes a refusal from no proposal
this test checks nothing about placement differences between rows, because the answer applies to the whole adoption
Diagnostics: Instance-proposal-log
Instance-plan-state
Instance-pointer-result

one completed phase creates no duplicate proposal

proposal-count-and-targeting-result

scenarioonce

Applies for every adoption

Each completed phase that creates a proposal creates exactly one. A held modifier or update adds no copy. For a targeted verb, the row's after-dispatch result applies after placement or refusal; for a context command, this test checks nothing about that result.

Given: each completed pointer phase in Instance that creates a proposal, including one with a held queue modifier where available
When: the proposal is created, placed or refused, and any targeted-verb result is applied
Then: the completed phase creates exactly one proposal
a held modifier or update creates no second copy within that phase
for a targeted verb, its after-dispatch result applies after placement or refusal; for a context command, this test checks nothing in this line
Diagnostics: Instance-proposal-log
Instance-pointer-result
Instance-targeting-state
Instance-plan-state

dispatch stops at the cited command rule

proposal-submission-stops-at-command-rule

scenarioonce

Applies for every adoption

Each placed proposal is submitted once to its cited Fixed command rule at its declared place. Permission, cost, range, path, the unreachable case, effect, refusal, and whether a current command stops belong to that rule. Event resolution owns same-instant order. This test checks nothing about a paired Action legibility adoption.

Given: each placed proposal in Instance, including one queued proposal when the adoption can create one
When: the proposal reaches its declared place and is submitted
Then: the proposal is submitted once to its cited Fixed command rule at its declared place
the pointer contract makes no claim about permission, cost, range, path, the unreachable case, effect, refusal, or whether a current command stops after submission
when several proposals share one instant, their order is left to Event resolution
this test checks nothing about a paired Action legibility adoption
Diagnostics: Instance-proposal-log
Instance-plan-state
Instance-pointer-result

the pointer result records the completed phase

pointer-result-record-is-complete

scenarioonce

Applies for every adoption

Every pointer result records its gesture, phase, snapshot, targeting states, changed selection, proposed command and receiver, target, placement outcome, cancellation, tested target validity, unmatched classification, and available cited game-rule result. Where the adoption cannot construct an optional circumstance, this test checks nothing for that circumstance.

Given: each completed pointer phase in Instance, including every optional circumstance the adoption can construct
When: the pointer result is read after resolution
Then: the result records gesture id, resolving phase, pointer snapshot, prior and final targeting state, and prior and final selection when changed
it records command and receiver when proposed, target, queue modifier or unmodified placement outcome, cancellation when used, and target validity for every targeted verb that reached validity
it records no-matching-row when applicable and the cited game-rule result when available
where the adoption cannot construct an optional circumstance, this test checks nothing for that circumstance
Diagnostics: Instance-pointer-result

later steps preserve the earlier snapshot and receiver

authority-order-preserves-copies

scenarioonce

Applies for every adoption

The contract's order of the steps is physical mapping, gesture recognition, cancellation, targeting entry, confirmation, selection or context classification, receiver snapshot, placement, dispatch, game rule, and same-instant event order. Later steps never change an earlier snapshot or receiver; classification can read receiver class without copying the set. The questions and rows supply choices and cited game rules. They do not change the order.

Given: each completed pointer phase in Instance with distinguishable snapshot, receiver, placement, and game-rule data
When: the phase proceeds through every step it reaches
Then: physical mapping precedes gesture recognition, cancellation, targeting entry, target confirmation, selection or context classification, receiver snapshot, queue placement, command dispatch, game rule, and same-instant event order
a later step never changes the pointer snapshot or receiver copied earlier
classification can read receiver class without copying the receiver set
the questions and rows supply choices and cited game rules, and they do not change the order
Diagnostics: Instance-pointer-result
Instance-snapshot-log
Instance-proposal-log
Instance-plan-state

absent rows and unasked questions keep their declared meaning

empty-collections-and-unasked-questions

scenarioonce

Applies for every adoption

This check reads the adoption shape. Each empty row set has exactly its when-empty meaning. Each gated question the adoption does not answer has exactly its otherwise meaning: without empty-selection, no pointer gesture changes the current world selection; without invalid-target, no chosen ability or verb waits for a world target from the pointer; without queued-command-placement, no pointer modifier adds a command to a queue; without unmodified-command, no pointer command can enter a queue. When the adoption answers a question or fills a row set, this test checks nothing for that question or row set.

Given: the Instance adoption document, including each empty and non-empty row set and each gated question it does or does not answer
When: a reviewer compares the adoption shape with every row-set when-empty sentence and every gated-question otherwise sentence
Then: an empty selection-gestures set means no pointer gesture changes the current selection; when non-empty, this test checks nothing in this line
an empty context-commands set means no pointer gesture chooses a command directly from its world target; when non-empty, this test checks nothing in this line
an empty targeted-verbs set means no chosen verb waits for a pointer target; when non-empty, this test checks nothing in this line
an empty queue-modifiers set means no pointer modifier adds a command to a queue; when non-empty, this test checks nothing in this line
an empty cancellations set means no action has a separate cancellation meaning in this adoption; when non-empty, this test checks nothing in this line
when the adoption does not answer empty-selection, no pointer gesture changes the current world selection; when it answers, this test checks nothing in this line
when the adoption does not answer invalid-target, no chosen ability or verb waits for a world target from the pointer; when it answers, this test checks nothing in this line
when the adoption does not answer queued-command-placement, no pointer modifier adds a command to a queue; when it answers, this test checks nothing in this line
when the adoption does not answer unmodified-command, no pointer command can enter a queue; when it answers, this test checks nothing in this line
Diagnostics: Instance-declaration-record

declaration check: selection and context rows are disjoint

selection-and-context-rows-are-disjoint

scenarioonce

Applies for every adoption

This declaration check reads the adoption, not the running game. Under the contract's mutually exclusive classifications, no selection and context row, two selection rows, or target-first capture and selection or context row can match the same game-facing action, phase, and classification. No two cancellation rows match the same game-facing action and phase in one holding state under the contract's targeting, selection-drag, queued-commands, selection order. Context target kinds for one action and phase, together with any cited receiver class, must be mutually exclusive. One completed phase selects or commands, never both. Any other shape makes the adoption invalid, and this test fails.

Given: the Instance adoption, not the running game
When: a reviewer compares every selection row, context row, target-first capture gesture, and cancellation row by its contract matching terms
Then: no selection row and context row match the same game-facing action, phase, and classification
no two selection rows match the same game-facing action, phase, and classification
no target-first capture gesture matches the same game-facing action, phase, and classification as a selection or context row
no two cancellation rows match the same game-facing action and phase in one holding state
for one context action and phase, target-kind values together with any cited receiver class are mutually exclusive
one completed phase therefore selects or commands, never both
any other shape makes the adoption invalid, and this test fails
Diagnostics: Instance-declaration-record

declaration check: modifier Row.id names only declared commands, and at least one

queue-modifier-targets-declared-rows

scenarioper queue-modifiers row

Applies for every adoption

This declaration check reads the adoption and Row.applies to declared in, not the running game. The rule must name only declared context-command and targeted-verb rows, and the contract requires it to name at least one declared row. An undeclared target or empty applicability set makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.applies to declared in, not the running game
When: a reviewer compares every command named by the applicability rule with context-command and targeted-verb row ids
Then: the rule names only declared context-command and targeted-verb rows
the contract requires the rule to name at least one declared row
any undeclared target or empty applicability set makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: cancellation Row.id names a state this adoption can hold

cancellation-state-can-exist

scenarioper cancellations row

Applies for every adoption

This declaration check reads the adoption, not the running game. For cancellation Row.id in Row.active state, Bind duty, and its result must match that state. Any other shape makes the adoption invalid, and this test fails.

Given: the Instance adoption and cancellation row Row.id, not the running game
When: a reviewer compares its active state with the adoption's rows and answers
Then: for active state Row.active state, Bind duty
the result matches that state: targeting with ends-targeting, selection-drag with ends-drag, queued-commands with empties-queue, or selection with empties-selection
any other shape makes the adoption invalid, and this test fails
Diagnostics: Instance-declaration-record

declaration check: current selection has a declared source

current-selection-has-a-source

scenarioonce

Applies when Command receiver is Current selection.

This declaration check reads the adoption, not the running game. Under current-selection, at least one selection gesture or a cited load or scene-entry rule must supply the selection. Any other shape makes the adoption invalid, and this test fails.

Given: the Instance adoption and its selection, load, and scene-entry declarations, not the running game
When: a reviewer checks how a non-empty current selection can first exist
Then: at least one selection gesture or a cited load or scene-entry rule supplies the selection
any other shape makes the adoption invalid, and this test fails
Diagnostics: Instance-declaration-record

declaration check: targeted verb Row.id has a way to leave targeting

targeted-verb-has-exit

scenarioper targeted-verbs row

Applies for every adoption

This declaration check reads the adoption, the contract's targeted-verbs description, and Row.starts when declared in, not the running game. The description requires every targeting state to be left through leave-targeting, a targeting cancellation row, or the cited start rule. Targeted verb Row.id must therefore have leave-targeting as its applicable invalid-target answer or after-dispatch value, a targeting cancellation row, or an exit in that cited start rule. Any other shape makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption, the contract's targeted-verbs description, targeted-verb row Row.id, its start rule, and its cancellation rows, not the running game
When: a reviewer checks every route by which this targeting state can end
Then: the targeted-verbs description requires every targeting state to be left through leave-targeting, a targeting cancellation row, or the cited start rule
for Row.id, the applicable invalid-target answer or after-dispatch value is leave-targeting, or the adoption has a targeting cancellation row, or Row.starts when declared in states an exit
any other shape makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id gesture citation states its duty

selection-gesture-citation-duty

scenarioper selection-gestures row

Applies for every adoption

This declaration check reads the adoption and Row.gesture declared in, not the running game. The citation must satisfy this duty: it recognizes the game-facing pointer action and its completion phase, including drag threshold and area geometry where used. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.gesture declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.gesture declared in recognizes the game-facing pointer action and its completion phase, including drag threshold and area geometry where used
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id candidate citation states its duty

selection-candidates-citation-duty

scenarioper selection-gestures row

Applies for every adoption

This declaration check reads the adoption and Row.candidates declared in, not the running game. The citation must satisfy this duty: it names selectable target kinds, point or area inclusion, near-miss reach when used, and a complete tie-break. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.candidates declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.candidates declared in names selectable target kinds, point or area inclusion, near-miss reach when used, and a complete tie-break
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id gesture citation states its duty

context-gesture-citation-duty

scenarioper context-commands row

Applies for every adoption

This declaration check reads the adoption and Row.gesture declared in, not the running game. The citation must satisfy this duty: it recognizes the game-facing pointer action and its completion phase. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.gesture declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.gesture declared in recognizes the game-facing pointer action and its completion phase
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id target citation states its duty

context-target-citation-duty

scenarioper context-commands row

Applies for every adoption

This declaration check reads the adoption and Row.target declared in, not the running game. The citation must satisfy this duty: it classifies the pointer snapshot, names the exact target, and states reach and a complete tie-break for nearest-within-reach. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.target declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.target declared in classifies the pointer snapshot, names the exact target, and states reach and a complete tie-break for nearest-within-reach
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id area citation states its duty

context-area-citation-duty

scenarioper context-commands row

Applies when row resolves on is Drag complete.

This declaration check reads the adoption and Row.area declared in, not the running game. The citation must satisfy this duty: it names the dragged region, boundary inclusion, and how that region becomes the command target. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.area declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.area declared in names the dragged region, boundary inclusion, and how that region becomes the command target
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id receiver-condition citation states its duty

context-receiver-condition-citation-duty

scenarioper context-commands row

Applies for every adoption

This declaration check reads the adoption and Bind address, not the running game. The citation must satisfy this duty: it names the receiver class that limits this row. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Bind address, not the running game
When: a reviewer checks the citation's meaning
Then: Bind address names the receiver class that limits this row
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id command citation states its duty

context-command-citation-duty

scenarioper context-commands row

Applies for every adoption

This declaration check reads the adoption and Row.command declared in, not the running game. The citation must satisfy this duty: it names the command, receiver, target, per-target plan owner, permission, unreachable-target result, and complete accepted or refused effect. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.command declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.command declared in names the command, receiver, target, per-target plan owner, permission, unreachable-target result, and complete accepted or refused effect
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id start citation states its duty

targeted-start-citation-duty

scenarioper targeted-verbs row

Applies for every adoption

This declaration check reads the adoption and Row.starts when declared in, not the running game. The citation must satisfy this duty: it names the game action that supplies the verb and any targeting-state replacement or exit it owns. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.starts when declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.starts when declared in names the game action that supplies the verb and any targeting-state replacement or exit it owns
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id target-gesture citation states its duty

targeted-target-gesture-citation-duty

scenarioper targeted-verbs row

Applies when row order is Target first.

This declaration check reads the adoption and Row.target gesture declared in, not the running game. The citation must satisfy this duty: it recognizes the target-first pointer action and its capture phase. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.target gesture declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.target gesture declared in recognizes the target-first pointer action and its capture phase
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id confirmation citation states its duty

targeted-confirm-gesture-citation-duty

scenarioper targeted-verbs row

Applies when row confirm style is Separate gesture.

This declaration check reads the adoption and Row.confirm gesture declared in, not the running game. The citation must satisfy this duty: it recognizes the confirmation action and its completion phase. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.confirm gesture declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.confirm gesture declared in recognizes the confirmation action and its completion phase
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id targets citation states its duty

targeted-targets-citation-duty

scenarioper targeted-verbs row

Applies for every adoption

This declaration check reads the adoption and Row.targets declared in, not the running game. The citation must satisfy this duty: it names target capture, every valid target, near-miss reach and tie-break when used, and the complete invalid-target test. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.targets declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.targets declared in names target capture, every valid target, near-miss reach and tie-break when used, and the complete invalid-target test
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id area citation states its duty

targeted-area-citation-duty

scenarioper targeted-verbs row

Applies when row resolves on is Drag complete.

This declaration check reads the adoption and Row.area declared in, not the running game. The citation must satisfy this duty: it names the dragged region, boundary inclusion, and how that region becomes the verb target. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.area declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.area declared in names the dragged region, boundary inclusion, and how that region becomes the verb target
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id command citation states its duty

targeted-command-citation-duty

scenarioper targeted-verbs row

Applies for every adoption

This declaration check reads the adoption and Row.command declared in, not the running game. The citation must satisfy this duty: it names the command, receiver, per-target plan owner, permission, cost, unreachable-target result, and complete effect or refusal. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.command declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.command declared in names the command, receiver, per-target plan owner, permission, cost, unreachable-target result, and complete effect or refusal
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id modifier citation states its duty

queue-modifier-citation-duty

scenarioper queue-modifiers row

Applies for every adoption

This declaration check reads the adoption and Row.modifier declared in, not the running game. The citation must satisfy this duty: it names when the mapped modifier is active, any waiting-plan capacity, and the complete result when no place is available. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.modifier declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.modifier declared in names when the mapped modifier is active, any waiting-plan capacity, and the complete result when no place is available
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id applicability citation states its duty

queue-applicability-citation-duty

scenarioper queue-modifiers row

Applies for every adoption

This declaration check reads the adoption and Row.applies to declared in, not the running game. The citation must satisfy this duty: it names every declared context command and targeted verb to which this modifier applies. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.applies to declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.applies to declared in names every declared context command and targeted verb to which this modifier applies
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id action citation states its duty

cancellation-action-citation-duty

scenarioper cancellations row

Applies for every adoption

This declaration check reads the adoption and Row.action declared in, not the running game. The citation must satisfy this duty: it recognizes the cancellation action and its completion phase. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.action declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.action declared in recognizes the cancellation action and its completion phase
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

declaration check: Row.id state citation states its duty

cancellation-state-citation-duty

scenarioper cancellations row

Applies for every adoption

This declaration check reads the adoption and Row.state declared in, not the running game. The citation must satisfy this duty: it names when the affected targeting, selection-drag, waiting-plan, or selection state exists. A missing duty makes the adoption invalid, and this test fails. The test names the address and restates nothing from it.

Given: the Instance adoption and Row.state declared in, not the running game
When: a reviewer checks the citation's meaning
Then: Row.state declared in names when the affected targeting, selection-drag, waiting-plan, or selection state exists
a missing duty makes the adoption invalid, and this test fails
the test names the address and restates nothing from it
Diagnostics: Instance-declaration-record

pointer command holds for the whole run

pointer-command-holds

generalonce

Applies for every adoption

Across Inputs scope, every completed phase matches at most one row in the contract's precedence; every selection change commits once from the complete candidate set; every proposal keeps its copied snapshot and receiver to its declared place; every cancellation clears only its declared state; every targeting state ends only as declared; and no phase produces two proposals.

Holds: every completed pointer phase matched at most one row in the precedence the contract fixes; every selection change committed once from the complete candidate set; every command proposal carried its copied snapshot and receiver unchanged to its declared place; every cancellation cleared only its declared state; every targeting state ended only as declared; no phase produced two proposals
Seeds: Inputs seeds
Scope: Inputs scope
Diagnostics: Instance-pointer-result
Instance-snapshot-log
Instance-selection-state
Instance-targeting-state
Instance-proposal-log
Instance-plan-state
Instance-cancellation-log

Use this contract in your package ↑