Continuous world

continuous-world · an adoption of State persistence scope, version 1

Tests included

Use in your game

Opens the authoring tool with these answers and settings already filled in. You still add your game's own rules and tuning.

Open in the authoring tool Download ZIP

What is in the ZIP

The ZIP holds the adoption and its acceptance tests. In the authoring tool, choose Add contract and pick this ZIP. If you keep your design as files, put them in contracts/.

Download adoption JSON · Download tests

The contract behind it

Covers what survives the end of a run or session, a quit, a crash, death, deleting saved data, and moving to another device. It also covers local saves, manual slots, cloud copies, server profiles, backups, conflicts, and version changes. Closed-game time, replay guarantees, file formats, and the shape of saved numbers stay elsewhere.

Read the full State persistence scope contract →

Questions

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

Show exact wording for builders

What normally happens when saved state cannot be read?

Asked when: the copy kinds list has at least one row.
If not asked: No saved copy can be opened later, so unreadable saved state never reaches a load attempt.

Refuse loadSupplied answer	The unreadable copy stays closed. A city slot remains listed, but none of its progress becomes active. Loading stops before any state from that copy becomes active. The copy is neither replaced nor repaired by this response.
Start fresh	Play starts from normal fresh state. A damaged puzzle slot opens with its first board instead of the old board. Fresh state becomes active instead of state from the unreadable copy. The response does not by itself delete or overwrite that copy.
Restore earlier copy	An earlier copy can replace it through the supported route, including a manual file restore. A factory returns after choosing the backup before its damaged autosave. A declared manual, in-game, or automatic recovery route can activate an earlier copy. The newest usable earlier copy under the matching backup rule becomes active.
Repair readable state	Readable progress returns and damaged parts reset. A dungeon keeps cleared floors but rebuilds one broken room record. Readable state becomes active as one repaired result. Every unreadable part takes the fresh value named by the cited repair rule.
Warn and try	The player can cancel or try the unreadable copy. A colony save opens only after its damage warning is accepted. No state from the copy becomes active before the explicit choice. Accepting the warning permits an attempt but does not promise success.

Why this is asked

Lost progress is the most visible failure a save system has. Choose the result players should expect first.

What normally happens when an older game build wrote the copy?

Asked when: the copy kinds list has at least one row.
If not asked: No loadable copy exists, so an older build has no saved state to open.

Refuse load	The older copy stays closed. A world from last year's rules cannot open in the current build. Loading stops before state written by the older build becomes active.
Convert and loadSupplied answer	The game updates the old state and opens it. A factory save gains the current recipe records before play resumes. A declared conversion produces current-build state before activation.
Warn and load	The old copy is tried only after a warning. A racing career from an earlier patch opens after the player accepts the risk. The player accepts a compatibility warning before old-build state becomes active. Acceptance permits an attempt but does not promise success.

Why this is asked

Updates can strand a player's progress or change it permanently. Choose how the current build protects that progress.

What normally happens when a newer game build wrote the copy?

Asked when: the copy kinds list has at least one row.
If not asked: No loadable copy exists, so a newer build has no saved state to open.

Refuse loadSupplied answer	The newer copy stays closed. A world from a later patch remains unavailable in this build. Loading stops before state written by the newer build becomes active.
Warn and load	The newer copy is tried only after a warning. A sandbox world opens after the player accepts that newer content may be lost. The player accepts a compatibility warning before newer-build state becomes active. Acceptance permits an attempt but does not promise success.

Why this is asked

Going back to an older build can erase newer content. Choose whether the player may take that risk.

Numbersno numbers

This contract has no numbers to set.

Rulesno rules

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

This contract has no rules between its numbers.

Lists5 lists

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

State families

state-families

Id	State declared in	Lifetime	Scope starts in	Scope ends in	Lifetime event declared in	Saved in	After normal quit	After crash	After death	After slot delete	After local profile delete	On another device
`world-progress`	`world.progress-fields`	`profile`	—	`profile.delete-world`	—	`current-world-copy`	`returns-last-commit`	`returns-last-commit`	`keeps-value`	`no-slot`	`clears-value`	`does-not-return`
`dropped-currency-recovery`	`recovery.currency-and-location`	`until-event`	—	—	`recovery.next-death-after-drop`	`current-world-copy`	`returns-last-commit`	`returns-last-commit`	`clears-value`	`no-slot`	`clears-value`	`does-not-return`
`combat-lock-target`	`combat.lock-target`	`not-kept`	—	`combat.first-interruption`	—	—	`does-not-return`	`does-not-return`	`clears-value`	`no-slot`	`no-profile`	`does-not-return`

Copy kinds

copy-kinds

Id	Contains declared in	Write trigger	Write rule declared in	Residence	Layout	Storage rule declared in	Unreadable copy	Older build copy	Newer build copy	Mode gated	Mode rule declared in	Removed at	Removal rule declared in
`current-world-copy`	`world.saved-fields`	`continuous`	`world.accepted-change`	`local-device`	`one-current`	`world.current-copy`	`use-game-default`	`use-game-default`	`use-game-default`	—	—	—	—

Backup copies

backup-copies

This adoption declares no backup copies.

Copy conflicts

copy-conflicts

This adoption declares no copy conflicts.

Earlier point returns

earlier-point-returns

This adoption declares no earlier point returns.

Test inputsscope and seeds

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

This adoption supplies none; every test uses its defaults.

Acceptance tests54 tests apply

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

run-scope-uses-cited-events

`Row.id` begins and ends its run only at the cited events

scenarioper state-families row

Does not apply to continuous-world: no row in state-families matches lifetime run.

session-scope-uses-cited-events

`Row.id` keeps one session through returns to the same context

scenarioper state-families row

Does not apply to continuous-world: no row in state-families matches lifetime session.

copy-carries-complete-identity · current-world-copy

`current-world-copy` copies carry complete identity and family membership

scenarioper copy-kinds row

Applies to the current-world-copy row.

A copy of kind current-world-copy is one coherent accepted commit with save-kind, copy, slot when present, build, and commit identities and the complete family set at world.saved-fields. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: one accepted commit of the copy kind named current-world-copy
When: the copy is recorded and later considered as a candidate
Then: the copy record carries save-kind id, copy identity, any slot identity, build identity, commit identity, and the complete state-family set named at world.saved-fields
the commit record identifies one coherent accepted write rather than a collection of separately accepted fields
Diagnostics: continuous-world-commit-log
continuous-world-candidate-set

conflict-has-two-unreplaced-accepted-copies

`Row.id` is a conflict only for two accepted unreplaced copies

scenarioper copy-conflicts row

Does not apply to continuous-world: copy-conflicts has no rows.

state-family-follows-maximum-lifetime · world-progress

`world-progress` follows its declared maximum lifetime

scenarioper state-families row

Applies to the world-progress row.

world-progress has a maximum lifetime of one local player profile. Each shorter boundary follows the row's result, and the trace distinguishes a restored value from an equal value derived later. The family definition is at world.progress-fields; the test names the address and restates nothing from it.

Test steps and diagnostics

Given: world-progress changes from an earlier value to a distinguishable value
When: the value is read immediately before and after every declared persistence boundary that continuous-world can construct
Then: the earlier value affects play for no longer than one local player profile
a shorter boundary clears it exactly when world-progress's selected boundary result says so
the trace identifies restoration of the earlier value separately from a later derivation of an equal value
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

state-family-follows-maximum-lifetime · dropped-currency-recovery

`dropped-currency-recovery` follows its declared maximum lifetime

scenarioper state-families row

Applies to the dropped-currency-recovery row.

dropped-currency-recovery has a maximum lifetime of the interval before its named event. Each shorter boundary follows the row's result, and the trace distinguishes a restored value from an equal value derived later. The family definition is at recovery.currency-and-location; the test names the address and restates nothing from it.

Test steps and diagnostics

Given: dropped-currency-recovery changes from an earlier value to a distinguishable value
When: the value is read immediately before and after every declared persistence boundary that continuous-world can construct
Then: the earlier value affects play for no longer than the interval before its named event
a shorter boundary clears it exactly when dropped-currency-recovery's selected boundary result says so
the trace identifies restoration of the earlier value separately from a later derivation of an equal value
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

state-family-follows-maximum-lifetime · combat-lock-target

`combat-lock-target` follows its declared maximum lifetime

scenarioper state-families row

Applies to the combat-lock-target row.

combat-lock-target has a maximum lifetime of the interval before its first named interruption. Each shorter boundary follows the row's result, and the trace distinguishes a restored value from an equal value derived later. The family definition is at combat.lock-target; the test names the address and restates nothing from it.

Test steps and diagnostics

Given: combat-lock-target changes from an earlier value to a distinguishable value
When: the value is read immediately before and after every declared persistence boundary that continuous-world can construct
Then: the earlier value affects play for no longer than the interval before its first named interruption
a shorter boundary clears it exactly when combat-lock-target's selected boundary result says so
the trace identifies restoration of the earlier value separately from a later derivation of an equal value
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

until-event-value-ends-at-cited-event · dropped-currency-recovery

`dropped-currency-recovery` ends at its cited event

scenarioper state-families row

Applies to the dropped-currency-recovery row.

dropped-currency-recovery follows its quit, crash, death, slot-deletion, local-profile-deletion, and device-change results at each boundary the adoption can construct and ends at recovery.next-death-after-drop. This test asserts nothing about run or session crossing because an event-bounded value declares no run or session scope. It names the address and restates nothing from it.

Test steps and diagnostics

Given: a distinguishable dropped-currency-recovery value before the event at recovery.next-death-after-drop
When: play crosses each of quit, crash, death, slot deletion, local-profile deletion, and device change that the adoption can construct, then the cited event; run and session crossing are out of reach because an event-bounded value declares no run or session scope
Then: each constructed boundary follows dropped-currency-recovery's own row result; a boundary the adoption cannot construct asserts nothing
the earlier value ends at recovery.next-death-after-drop and does not affect later play
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

not-kept-value-never-returns · combat-lock-target

`combat-lock-target` never returns after its named interruption

scenarioper state-families row

Applies to the combat-lock-target row.

The earlier combat-lock-target value never returns after combat.first-interruption. An equal value derived later is recorded as new state. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: a distinguishable combat-lock-target value before combat.first-interruption
When: play crosses combat.first-interruption and later reaches a point where an equal value can be derived
Then: the earlier value never returns after the boundary
the source record distinguishes a later derived equal value as new state
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

slot-and-profile-end-at-cited-event · world-progress

`world-progress` ends at its cited `profile` boundary

scenarioper state-families row

Applies to the world-progress row.

The maximum lifetime of world-progress ends at profile.delete-world. An equal value derived later is new state. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: a distinguishable world-progress value before profile.delete-world
When: play crosses the cited lifetime ending
Then: the earlier value reaches the end of its maximum lifetime at profile.delete-world and cannot affect later play
the source record distinguishes an equal value derived later as new state
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

commit-starts-only-at-selected-trigger · current-world-copy

`current-world-copy` starts a commit only at its selected trigger

scenarioper copy-kinds row

Applies to the current-world-copy row.

A commit for current-world-copy begins only at each cited accepted change under world.accepted-change. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: events around the write rule at world.accepted-change
When: the events occur before, at, and after each cited accepted change
Then: one current-world-copy commit starts at each cited accepted change and no commit starts at an event the cited rule does not name as an accepted change
the commit log records which cited event started it
Diagnostics: continuous-world-commit-log

commit-loadable-only-after-complete-success · current-world-copy

`current-world-copy` replaces its last commit only after complete success

scenarioper copy-kinds row

Applies to the current-world-copy row.

current-world-copy becomes loadable only when world.accepted-change reports success for the complete family set at world.saved-fields. A failed or partial write leaves the last successful commit in place. The test names both addresses and restates nothing from them.

Test steps and diagnostics

Given: a last successful current-world-copy commit and later complete-success, failed, and partial write attempts under world.accepted-change
When: each attempt is followed by a return that requests current-world-copy
Then: only the attempt reported successful for the complete set at world.saved-fields becomes loadable
a failed or partial attempt never replaces the last successful commit
the commit and load records distinguish the retained last commit from the rejected attempts
Diagnostics: continuous-world-commit-log
continuous-world-load-result
continuous-world-active-state-source

normal-quit-final-commit-follows-write-rule · current-world-copy

`current-world-copy` makes a final quit commit only when its rule calls for one

scenarioper copy-kinds row

Applies to the current-world-copy row.

On ordinary quit, current-world-copy makes a final commit only when world.accepted-change calls for one. Otherwise the prior successful commit remains last. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: each ordinary-quit case the adoption can construct for changed current-world-copy state under world.accepted-change
When: each ordinary quit completes
Then: where world.accepted-change calls for a final commit, exactly one starts
where the rule does not call for one, no final commit starts and the previous last successful commit remains; an unavailable branch asserts nothing
Diagnostics: continuous-world-commit-log

normal-quit-returns-last-commit · world-progress

`world-progress` returns its last commit after a normal quit

scenarioper state-families row

Applies to the world-progress row.

After a normal quit, world-progress returns from the latest successful commit of the copy kind named by saved-in; its uncommitted change does not return. If the row has no saved-in, the restoration clause asserts nothing.

Test steps and diagnostics

Given: a committed world-progress value followed by a distinguishable uncommitted change
When: the game quits normally and returns through the same context
Then: where this family names a copy kind at saved-in, the latest successful commit of that kind restores world-progress and the uncommitted change does not return
where this family has no saved-in, the restoration clause asserts nothing
Diagnostics: continuous-world-commit-log
continuous-world-load-result
continuous-world-active-state-source

normal-quit-returns-last-commit · dropped-currency-recovery

`dropped-currency-recovery` returns its last commit after a normal quit

scenarioper state-families row

Applies to the dropped-currency-recovery row.

After a normal quit, dropped-currency-recovery returns from the latest successful commit of the copy kind named by saved-in; its uncommitted change does not return. If the row has no saved-in, the restoration clause asserts nothing.

Test steps and diagnostics

Given: a committed dropped-currency-recovery value followed by a distinguishable uncommitted change
When: the game quits normally and returns through the same context
Then: where this family names a copy kind at saved-in, the latest successful commit of that kind restores dropped-currency-recovery and the uncommitted change does not return
where this family has no saved-in, the restoration clause asserts nothing
Diagnostics: continuous-world-commit-log
continuous-world-load-result
continuous-world-active-state-source

normal-quit-does-not-return · combat-lock-target

`combat-lock-target` does not return after a normal quit

scenarioper state-families row

Applies to the combat-lock-target row.

After a normal quit, the earlier combat-lock-target value does not return. Its post-quit value follows combat.lock-target, and the record distinguishes that result from restoration. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: a distinguishable combat-lock-target value before a normal quit
When: the game quits normally and returns through its normal flow
Then: the earlier value does not become active
combat-lock-target starts from the post-quit value governed at combat.lock-target
the source record distinguishes that value from restoration of the earlier value
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

crash-returns-last-commit · world-progress

`world-progress` returns its last completed commit after a crash

scenarioper state-families row

Applies to the world-progress row.

After a crash, no unfinished commit succeeds. world-progress returns from the last successful commit of the copy kind named by saved-in, without later changes. If the row has no saved-in, the restoration clause asserts nothing.

Test steps and diagnostics

Given: a committed world-progress value, then a distinguishable change and an unfinished commit
When: the game crashes and returns through the same context
Then: the unfinished commit does not succeed
where this family names a copy kind at saved-in, the last commit completed before the crash restores world-progress and the later change does not return
where this family has no saved-in, the restoration clause asserts nothing
Diagnostics: continuous-world-commit-log
continuous-world-load-result
continuous-world-active-state-source

crash-returns-last-commit · dropped-currency-recovery

`dropped-currency-recovery` returns its last completed commit after a crash

scenarioper state-families row

Applies to the dropped-currency-recovery row.

After a crash, no unfinished commit succeeds. dropped-currency-recovery returns from the last successful commit of the copy kind named by saved-in, without later changes. If the row has no saved-in, the restoration clause asserts nothing.

Test steps and diagnostics

Given: a committed dropped-currency-recovery value, then a distinguishable change and an unfinished commit
When: the game crashes and returns through the same context
Then: the unfinished commit does not succeed
where this family names a copy kind at saved-in, the last commit completed before the crash restores dropped-currency-recovery and the later change does not return
where this family has no saved-in, the restoration clause asserts nothing
Diagnostics: continuous-world-commit-log
continuous-world-load-result
continuous-world-active-state-source

crash-does-not-return · combat-lock-target

`combat-lock-target` does not return after a crash

scenarioper state-families row

Applies to the combat-lock-target row.

After a crash, the earlier combat-lock-target value does not return. Any unfinished commit fails; if none can exist, that clause asserts nothing. Its post-crash value follows combat.lock-target. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: a distinguishable combat-lock-target value and, where the adoption can construct one, an unfinished commit before a crash
When: the game crashes and returns through its normal flow
Then: the earlier value does not become active; where an unfinished commit exists, it does not succeed, and where none can exist that clause asserts nothing
combat-lock-target starts from the post-crash value governed at combat.lock-target
the source record distinguishes that value from restoration
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

timer-and-checkpoint-have-crash-loss-window

`Row.id` exposes its possible crash loss window

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches write-trigger timer or checkpoint.

layout-selects-requested-copy · current-world-copy

`current-world-copy` selects its requested copy before activation

scenarioper copy-kinds row

Applies to the current-world-copy row.

Before activation, current-world-copy selects its current copy and presents no player-selected slot under world.current-copy. Where an earlier commit is retained, it is not another layout; otherwise that clause asserts nothing. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the player requests current-world-copy through the selection route at world.current-copy and, where the adoption retains one, an earlier commit is also available
When: selection completes before any state activation
Then: current-world-copy selects its current copy and presents no player-selected slot
where an earlier commit is retained, it is not treated as another layout choice and remains available only through its matching backup and damage routes; where none is retained, this clause asserts nothing
Diagnostics: continuous-world-candidate-set
continuous-world-active-state-source

residence-controls-authoritative-candidates · current-world-copy

`current-world-copy` obtains candidates from its declared residence

scenarioper copy-kinds row

Applies to the current-world-copy row.

current-world-copy is available only on that device unless a transfer cited outside this adoption supplies it under world.current-copy. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the candidate sources the adoption can construct for current-world-copy as governed at world.current-copy
When: the game builds the candidate set before conflict handling
Then: current-world-copy is available only on that device unless a transfer cited outside this adoption supplies it
Diagnostics: continuous-world-candidate-set
continuous-world-authority-trace

candidate-identity-precedes-settlement · current-world-copy

`current-world-copy` reads candidate identity before settlement

scenarioper copy-kinds row

Applies to the current-world-copy row.

current-world-copy reads candidate identity first. An unreadable identity cannot enter conflict handling; no survivor goes directly to the effective damage response; a readable header with an unreadable body reaches damage only after conflict and build comparison.

Test steps and diagnostics

Given: current-world-copy candidates with readable identity, unreadable identity, and a readable header with an unreadable gameplay body
When: the game reads candidate identity before conflict, build, or damage settlement
Then: save-kind, slot when present, build, and commit identity are read before gameplay state
an unreadable identity is not a conflict candidate; if no candidate survives, the effective damage response runs immediately without conflict or build comparison
a readable header with an unreadable body remains a candidate through conflict and build comparison before reaching damage settlement
Diagnostics: continuous-world-candidate-set
continuous-world-settlement-trace
continuous-world-damage-report

missing-conflict-row-runs-no-conflict-response · current-world-copy

`current-world-copy` has no conflict response without a matching row

scenarioper copy-kinds row

Applies to the current-world-copy row.

If current-world-copy has no matching conflict row, this contract performs no conflict response for it. If it has one, this test asserts nothing.

Test steps and diagnostics

Given: a candidate set for current-world-copy
When: the game looks for a matching copy-conflicts row before build comparison
Then: where no matching conflict row exists, no candidate is selected, refused, or replaced by a conflict response from this contract
where a matching row exists, this test asserts nothing
Diagnostics: continuous-world-candidate-set
continuous-world-settlement-trace

one-kind-conflict-settles-only-named-kind

`Row.id` settles only `Row.copy kind`

scenarioper copy-conflicts row

Does not apply to continuous-world: copy-conflicts has no rows.

all-synced-conflict-settles-whole-set

`Row.id` settles every synced kind together

scenarioper copy-conflicts row

Does not apply to continuous-world: copy-conflicts has no rows.

conflict-select-by-rule

`Row.id` applies select-by-rule

scenarioper copy-conflicts row

Does not apply to continuous-world: copy-conflicts has no rows.

conflict-player-chooses-copy

`Row.id` applies player-chooses-copy

scenarioper copy-conflicts row

Does not apply to continuous-world: copy-conflicts has no rows.

conflict-refuse-until-resolved

`Row.id` applies refuse-until-resolved

scenarioper copy-conflicts row

Does not apply to continuous-world: copy-conflicts has no rows.

older-build-override-refuse-load

`Row.id` applies its older-build refuse-load override

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches older-build-copy refuse load.

older-build-default-refuse-load

`Row.id` applies the older-build refuse-load default

scenarioper copy-kinds row

Does not apply to continuous-world: older build default is convert and load, not refuse load.

older-build-override-convert-and-load

`Row.id` applies its older-build convert-and-load override

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches older-build-copy convert and load.

older-build-default-convert-and-load · current-world-copy

`current-world-copy` applies the older-build convert-and-load default

scenarioper copy-kinds row

Applies to the current-world-copy row.

current-world-copy uses the older-build default and converts to one coherent current-build copy before successful activation; a failed conversion refuses and preserves the source unless its cited rule records otherwise. The observable consequence is fixed here; the test restates nothing from the adoption's cited rule.

Test steps and diagnostics

Given: a selected readable copy of kind current-world-copy written by an older build, with no unresolved conflict
When: one conversion succeeds and a second constructed conversion fails
Then: the successful conversion produces one coherent current-build copy before all of its carried families activate together
the failed conversion refuses activation and leaves the source copy unchanged unless its cited rule records another disposition
the conversion record distinguishes success, refusal, and source-copy disposition
Diagnostics: continuous-world-writer-and-reader-builds
continuous-world-conversion-result
continuous-world-load-result
continuous-world-active-state-source

older-build-override-warn-and-load

`Row.id` applies its older-build warn-and-load override

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches older-build-copy warn and load.

older-build-default-warn-and-load

`Row.id` applies the older-build warn-and-load default

scenarioper copy-kinds row

Does not apply to continuous-world: older build default is convert and load, not warn and load.

newer-build-override-refuse-load

`Row.id` applies its newer-build refuse-load override

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches newer-build-copy refuse load.

newer-build-default-refuse-load · current-world-copy

`current-world-copy` applies the newer-build refuse-load default

scenarioper copy-kinds row

Applies to the current-world-copy row.

current-world-copy uses the newer-build default and refuses before any mismatched-build state activates. The observable consequence is fixed here; the test restates nothing from the adoption's cited rule.

Test steps and diagnostics

Given: a selected readable copy of kind current-world-copy written by a newer build, with no unresolved conflict
When: the player requests the copy
Then: loading stops before any state from the mismatched-build copy activates
the refusal record distinguishes refusal from an absent or unreadable copy
Diagnostics: continuous-world-writer-and-reader-builds
continuous-world-load-result
continuous-world-active-state-source

newer-build-override-warn-and-load

`Row.id` applies its newer-build warn-and-load override

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches newer-build-copy warn and load.

newer-build-default-warn-and-load

`Row.id` applies the newer-build warn-and-load default

scenarioper copy-kinds row

Does not apply to continuous-world: newer build default is refuse load, not warn and load.

unreadable-copy-override-refuse-load

`Row.id` applies its unreadable-copy refuse-load override

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches unreadable-copy refuse load.

unreadable-copy-default-refuse-load · current-world-copy

`current-world-copy` applies the unreadable-copy refuse-load default

scenarioper copy-kinds row

Applies to the current-world-copy row.

current-world-copy uses the unreadable-copy default and refuses the load without activating, replacing, or repairing unreadable state. The observable consequence is fixed here; the test restates nothing from the adoption's cited rule.

Test steps and diagnostics

Given: a selected copy of kind current-world-copy whose gameplay body is unreadable after conflict and build settlement
When: the player requests the unreadable copy
Then: no state from the unreadable copy becomes active
the unreadable copy is neither replaced nor repaired by this response
the load result distinguishes refusal from an absent copy
Diagnostics: continuous-world-damage-report
continuous-world-load-result
continuous-world-active-state-source
continuous-world-removal-log

unreadable-copy-override-start-fresh

`Row.id` applies its unreadable-copy start-fresh override

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches unreadable-copy start fresh.

unreadable-copy-default-start-fresh

`Row.id` applies the unreadable-copy start-fresh default

scenarioper copy-kinds row

Does not apply to continuous-world: unreadable copy default is refuse load, not start fresh.

unreadable-copy-override-restore-earlier-copy

`Row.id` applies its unreadable-copy restore-earlier-copy override

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches unreadable-copy restore earlier copy.

unreadable-copy-default-restore-earlier-copy

`Row.id` applies the unreadable-copy restore-earlier-copy default

scenarioper copy-kinds row

Does not apply to continuous-world: unreadable copy default is refuse load, not restore earlier copy.

unreadable-copy-override-repair-readable-state

`Row.id` applies its unreadable-copy repair-readable-state override

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches unreadable-copy repair readable state.

unreadable-copy-default-repair-readable-state

`Row.id` applies the unreadable-copy repair-readable-state default

scenarioper copy-kinds row

Does not apply to continuous-world: unreadable copy default is refuse load, not repair readable state.

unreadable-copy-override-warn-and-try

`Row.id` applies its unreadable-copy warn-and-try override

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches unreadable-copy warn and try.

unreadable-copy-default-warn-and-try

`Row.id` applies the unreadable-copy warn-and-try default

scenarioper copy-kinds row

Does not apply to continuous-world: unreadable copy default is refuse load, not warn and try.

backup-retains-orders-and-restores-earlier-copies

`Row.id` retains and restores earlier copies

scenarioper backup-copies row

Does not apply to continuous-world: backup-copies has no rows.

readable-compatible-copy-activates-together · current-world-copy

`current-world-copy` loads a readable compatible conflict-free copy

scenarioper copy-kinds row

Applies to the current-world-copy row.

A readable, same-build, conflict-free copy of kind current-world-copy loads successfully and activates every family at world.saved-fields together from one commit. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: a selected readable copy of kind current-world-copy from the running build with no conflict, carrying distinguishable values for every family at world.saved-fields
When: the game loads the copy
Then: the load is accepted rather than refused
every carried state family activates together from one commit
no partial copy is visible at any point
Diagnostics: continuous-world-load-result
continuous-world-active-state-source
continuous-world-activation-trace

load-preserves-families-from-other-kinds · current-world-copy

loading `current-world-copy` preserves state from other copy kinds

scenarioper copy-kinds row

Applies to the current-world-copy row.

Loading current-world-copy activates its carried families together and preserves the active value of every family saved in another kind. If no other kind exists, that clause asserts nothing.

Test steps and diagnostics

Given: active distinguishable state from current-world-copy and, where the adoption declares one, another copy kind
When: a readable compatible conflict-free copy of kind current-world-copy loads successfully
Then: families carried by current-world-copy activate together from its selected commit
families saved in another copy kind keep that kind's already active value
where no other copy kind exists, the second clause asserts nothing
Diagnostics: continuous-world-activation-trace
continuous-world-active-state-source

family-without-saved-in-is-never-restored · world-progress

`world-progress` is never restored when it names no save kind

scenarioper state-families row

Applies to the world-progress row.

For world-progress, when it has no saved-in, no return path restores its earlier value. For world-progress, when it names saved-in, only an accepted load of that copy kind restores its earlier value; no other return path does.

Test steps and diagnostics

Given: a distinguishable earlier world-progress value and every return path the adoption can construct
When: the return paths complete
Then: where world-progress has no saved-in, none of the return paths restores its earlier value
where world-progress names saved-in, its earlier value is restored only by an accepted load of that copy kind and by no other return path
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

family-without-saved-in-is-never-restored · dropped-currency-recovery

`dropped-currency-recovery` is never restored when it names no save kind

scenarioper state-families row

Applies to the dropped-currency-recovery row.

For dropped-currency-recovery, when it has no saved-in, no return path restores its earlier value. For dropped-currency-recovery, when it names saved-in, only an accepted load of that copy kind restores its earlier value; no other return path does.

Test steps and diagnostics

Given: a distinguishable earlier dropped-currency-recovery value and every return path the adoption can construct
When: the return paths complete
Then: where dropped-currency-recovery has no saved-in, none of the return paths restores its earlier value
where dropped-currency-recovery names saved-in, its earlier value is restored only by an accepted load of that copy kind and by no other return path
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

family-without-saved-in-is-never-restored · combat-lock-target

`combat-lock-target` is never restored when it names no save kind

scenarioper state-families row

Applies to the combat-lock-target row.

For combat-lock-target, when it has no saved-in, no return path restores its earlier value. For combat-lock-target, when it names saved-in, only an accepted load of that copy kind restores its earlier value; no other return path does.

Test steps and diagnostics

Given: a distinguishable earlier combat-lock-target value and every return path the adoption can construct
When: the return paths complete
Then: where combat-lock-target has no saved-in, none of the return paths restores its earlier value
where combat-lock-target names saved-in, its earlier value is restored only by an accepted load of that copy kind and by no other return path
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

earlier-point-follows-after-load

`Row.id` follows its after-load result

scenarioper earlier-point-returns row

Does not apply to continuous-world: earlier-point-returns has no rows.

missing-earlier-point-row-returns-nowhere · current-world-copy

`current-world-copy` returns nowhere without an earlier-point row

scenarioper copy-kinds row

Applies to the current-world-copy row.

A successful current-world-copy load returns continuous play nowhere under this contract when no earlier-point row names it. When one does, this test asserts nothing.

Test steps and diagnostics

Given: a successful current-world-copy load
When: the game checks for an earlier-point-returns row after activation
Then: where no row names current-world-copy, this contract returns continuous play to no earlier point
where a row names current-world-copy, this test asserts nothing
Diagnostics: continuous-world-load-result
continuous-world-return-point

earlier-point-mode-gate-controls-existence

`Row.id` exists only in its named modes

scenarioper earlier-point-returns row

Does not apply to continuous-world: earlier-point-returns has no rows.

death-follows-family-result · world-progress

`world-progress` follows its death result

scenarioper state-families row

Applies to the world-progress row.

On death, world-progress follows its selected result: the earlier value remains available to later play.

Test steps and diagnostics

Given: a distinguishable world-progress value immediately before death
When: death settles before any death-triggered copy removal the adoption declares
Then: the earlier value remains available to later play
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

death-follows-family-result · dropped-currency-recovery

`dropped-currency-recovery` follows its death result

scenarioper state-families row

Applies to the dropped-currency-recovery row.

On death, dropped-currency-recovery follows its selected result: the earlier value is removed before later play and an equal later value is recorded only as new state.

Test steps and diagnostics

Given: a distinguishable dropped-currency-recovery value immediately before death
When: death settles before any death-triggered copy removal the adoption declares
Then: the earlier value is removed before later play and an equal later value is recorded only as new state
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

death-follows-family-result · combat-lock-target

`combat-lock-target` follows its death result

scenarioper state-families row

Applies to the combat-lock-target row.

On death, combat-lock-target follows its selected result: the earlier value is removed before later play and an equal later value is recorded only as new state.

Test steps and diagnostics

Given: a distinguishable combat-lock-target value immediately before death
When: death settles before any death-triggered copy removal the adoption declares
Then: the earlier value is removed before later play and an equal later value is recorded only as new state
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

death-at-run-end-clears-run-family

`Row.id` clears when death is its run end

scenarioper state-families row

Does not apply to continuous-world: no row in state-families matches lifetime run.

death-at-until-event-clears-family · dropped-currency-recovery

`dropped-currency-recovery` clears when death is its cited event

scenarioper state-families row

Applies to the dropped-currency-recovery row.

If death is the event at recovery.next-death-after-drop, dropped-currency-recovery clears before later play. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: a distinguishable dropped-currency-recovery value before death
When: death occurs, where death is the event cited at recovery.next-death-after-drop
Then: if the cited event at recovery.next-death-after-drop is death, the earlier value clears before later play; if the cited event is not death, this test asserts nothing
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

slot-deletion-follows-family-result · world-progress

`world-progress` follows its slot-deletion result

scenarioper state-families row

Applies to the world-progress row.

On slot deletion, world-progress follows its selected result: the settlement records that this family has no related player-selected slot.

Test steps and diagnostics

Given: a distinguishable family value when it has no related player-selected slot
When: a slot-deletion boundary is considered
Then: the settlement records that this family has no related player-selected slot
Diagnostics: continuous-world-state-boundary-trace
continuous-world-settlement-report

slot-deletion-follows-family-result · dropped-currency-recovery

`dropped-currency-recovery` follows its slot-deletion result

scenarioper state-families row

Applies to the dropped-currency-recovery row.

On slot deletion, dropped-currency-recovery follows its selected result: the settlement records that this family has no related player-selected slot.

Test steps and diagnostics

Given: a distinguishable family value when it has no related player-selected slot
When: a slot-deletion boundary is considered
Then: the settlement records that this family has no related player-selected slot
Diagnostics: continuous-world-state-boundary-trace
continuous-world-settlement-report

slot-deletion-follows-family-result · combat-lock-target

`combat-lock-target` follows its slot-deletion result

scenarioper state-families row

Applies to the combat-lock-target row.

On slot deletion, combat-lock-target follows its selected result: the settlement records that this family has no related player-selected slot.

Test steps and diagnostics

Given: a distinguishable family value when it has no related player-selected slot
When: a slot-deletion boundary is considered
Then: the settlement records that this family has no related player-selected slot
Diagnostics: continuous-world-state-boundary-trace
continuous-world-settlement-report

local-profile-deletion-follows-family-result · world-progress

`world-progress` follows its local-profile-deletion result

scenarioper state-families row

Applies to the world-progress row.

On local-profile deletion, world-progress follows its selected result: the earlier value tied to that local profile clears before later play. Where a related profile exists, child slots are included only as the adoption's cited rule provides; otherwise that clause asserts nothing. The test restates nothing from the cited rule.

Test steps and diagnostics

Given: a distinguishable family value before deletion of its related local profile
When: the related local profile is deleted with every child slot named by the adoption's cited rule
Then: the earlier value tied to that local profile clears before later play
Diagnostics: continuous-world-state-boundary-trace
continuous-world-settlement-report
continuous-world-removal-log

local-profile-deletion-follows-family-result · dropped-currency-recovery

`dropped-currency-recovery` follows its local-profile-deletion result

scenarioper state-families row

Applies to the dropped-currency-recovery row.

On local-profile deletion, dropped-currency-recovery follows its selected result: the earlier value tied to that local profile clears before later play. Where a related profile exists, child slots are included only as the adoption's cited rule provides; otherwise that clause asserts nothing. The test restates nothing from the cited rule.

Test steps and diagnostics

Given: a distinguishable family value before deletion of its related local profile
When: the related local profile is deleted with every child slot named by the adoption's cited rule
Then: the earlier value tied to that local profile clears before later play
Diagnostics: continuous-world-state-boundary-trace
continuous-world-settlement-report
continuous-world-removal-log

local-profile-deletion-follows-family-result · combat-lock-target

`combat-lock-target` follows its local-profile-deletion result

scenarioper state-families row

Applies to the combat-lock-target row.

On local-profile deletion, combat-lock-target follows its selected result: the settlement records that this family has no related local player profile. Where a related profile exists, child slots are included only as the adoption's cited rule provides; otherwise that clause asserts nothing. The test restates nothing from the cited rule.

Test steps and diagnostics

Given: a distinguishable family value when it has no related local player profile
When: a local-profile-deletion boundary is considered
Then: the settlement records that this family has no related local player profile
Diagnostics: continuous-world-state-boundary-trace
continuous-world-settlement-report
continuous-world-removal-log

device-lifetime-ends-at-device-data-deletion

`Row.id` ends when device data is deleted

scenarioper state-families row

Does not apply to continuous-world: no row in state-families matches lifetime device.

account-lifetime-ends-at-account-deletion

`Row.id` ends when its account is deleted or reset

scenarioper state-families row

Does not apply to continuous-world: no row in state-families matches lifetime account.

another-device-returns-family

`Row.id` returns on another eligible device

scenarioper state-families row

Does not apply to continuous-world: no row in state-families matches on-another-device returns.

another-device-does-not-return-family · world-progress

`world-progress` does not return on another device

scenarioper state-families row

Applies to the world-progress row.

On another eligible device, the earlier world-progress value does not return. Its new-device value follows world.progress-fields. The device change does not delete any source-device copy; if none exists, that clause asserts nothing. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: a distinguishable world-progress value on one device before the same eligible player continues on another
When: the new device settles available state
Then: the earlier value does not activate and the family starts from the new-device value governed at world.progress-fields
any source-device copy is not deleted by the device change; where none exists, this clause asserts nothing
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source
continuous-world-removal-log

another-device-does-not-return-family · dropped-currency-recovery

`dropped-currency-recovery` does not return on another device

scenarioper state-families row

Applies to the dropped-currency-recovery row.

On another eligible device, the earlier dropped-currency-recovery value does not return. Its new-device value follows recovery.currency-and-location. The device change does not delete any source-device copy; if none exists, that clause asserts nothing. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: a distinguishable dropped-currency-recovery value on one device before the same eligible player continues on another
When: the new device settles available state
Then: the earlier value does not activate and the family starts from the new-device value governed at recovery.currency-and-location
any source-device copy is not deleted by the device change; where none exists, this clause asserts nothing
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source
continuous-world-removal-log

another-device-does-not-return-family · combat-lock-target

`combat-lock-target` does not return on another device

scenarioper state-families row

Applies to the combat-lock-target row.

On another eligible device, the earlier combat-lock-target value does not return. Its new-device value follows combat.lock-target. The device change does not delete any source-device copy; if none exists, that clause asserts nothing. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: a distinguishable combat-lock-target value on one device before the same eligible player continues on another
When: the new device settles available state
Then: the earlier value does not activate and the family starts from the new-device value governed at combat.lock-target
any source-device copy is not deleted by the device change; where none exists, this clause asserts nothing
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source
continuous-world-removal-log

removed-copy-disappears-at-selected-event

`Row.id` disappears at its removal event

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches removed-at normal quit or crash or death or slot delete or local profile delete or device data delete or account delete.

copy-kind-mode-gate-controls-existence

`Row.id` exists only in its named modes

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches mode-gated only in named modes.

cleared-or-ended-value-never-affects-later-play

ended and cleared values stay absent

scenarioonce

Applies to continuous-world.

After a lifetime ends or a boundary result clears a value, that earlier value never affects later play. An equal value derived later is new state. If no such case can be constructed, the test asserts nothing.

Test steps and diagnostics

Given: every event the continuous-world adoption can construct where a lifetime ends or a boundary result clears an earlier value
When: later play reaches points where an equal value can be derived
Then: the earlier value never affects later play after the end or clearing event
any equal value derived later is recorded as new state rather than restoration
where the adoption can construct no such event, this test asserts nothing
Diagnostics: continuous-world-state-boundary-trace
continuous-world-active-state-source

settlement-report-is-complete

every settlement report records its complete result

scenarioonce

Applies to continuous-world.

Every settlement report carries the mechanism's full identity, boundary, commit, selection, response, result, and loss fields. Conflict and damage reports add their required facts and never claim an unattempted success. A clause for a case the adoption cannot construct asserts nothing.

Test steps and diagnostics

Given: each persistence settlement the continuous-world adoption can construct
When: the settlement completes or refuses
Then: the report identifies state-family id, copy-kind id or its absence, event, scope before and after, last successful commit when read, selected copy and build when loaded, override or default used, state result, and any lost interval
a conflict report also identifies both candidate commits and the selected response
a damage report identifies refusal, fresh state, earlier-copy recovery, repaired parts, or warning choice and never claims an unattempted load succeeded
where a conflict, damage case, load, or answered question does not arise, its corresponding clause asserts nothing
Diagnostics: continuous-world-settlement-report
continuous-world-conflict-report
continuous-world-damage-report

state-family-citation-states-its-duty · world-progress

declaration check: `world-progress`'s state citation states its duty

scenarioper state-families row

Applies to the world-progress row.

This declaration check reads the adoption and cited prose, not the running game. world.progress-fields must name every field in world-progress and every point where it can affect later play. For a family that answers does-not-return after a quit, a crash, or on another device, it must also name the value the family starts from; otherwise that clause asserts nothing. Another meaning is a defect this test fails by construction. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the continuous-world adoption and the prose at world.progress-fields, not the running game
When: a reviewer checks the citation's meaning
Then: world.progress-fields names every field in this state family and every point where it can affect later play
where the row answers does-not-return after a quit, a crash, or on another device, world.progress-fields also names the value the family starts from; where it never gives that answer for those cases, this clause asserts nothing
another meaning is a defect this test fails by construction
Diagnostics: continuous-world-declaration-record

state-family-citation-states-its-duty · dropped-currency-recovery

declaration check: `dropped-currency-recovery`'s state citation states its duty

scenarioper state-families row

Applies to the dropped-currency-recovery row.

This declaration check reads the adoption and cited prose, not the running game. recovery.currency-and-location must name every field in dropped-currency-recovery and every point where it can affect later play. For a family that answers does-not-return after a quit, a crash, or on another device, it must also name the value the family starts from; otherwise that clause asserts nothing. Another meaning is a defect this test fails by construction. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the continuous-world adoption and the prose at recovery.currency-and-location, not the running game
When: a reviewer checks the citation's meaning
Then: recovery.currency-and-location names every field in this state family and every point where it can affect later play
where the row answers does-not-return after a quit, a crash, or on another device, recovery.currency-and-location also names the value the family starts from; where it never gives that answer for those cases, this clause asserts nothing
another meaning is a defect this test fails by construction
Diagnostics: continuous-world-declaration-record

state-family-citation-states-its-duty · combat-lock-target

declaration check: `combat-lock-target`'s state citation states its duty

scenarioper state-families row

Applies to the combat-lock-target row.

This declaration check reads the adoption and cited prose, not the running game. combat.lock-target must name every field in combat-lock-target and every point where it can affect later play. For a family that answers does-not-return after a quit, a crash, or on another device, it must also name the value the family starts from; otherwise that clause asserts nothing. Another meaning is a defect this test fails by construction. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the continuous-world adoption and the prose at combat.lock-target, not the running game
When: a reviewer checks the citation's meaning
Then: combat.lock-target names every field in this state family and every point where it can affect later play
where the row answers does-not-return after a quit, a crash, or on another device, combat.lock-target also names the value the family starts from; where it never gives that answer for those cases, this clause asserts nothing
another meaning is a defect this test fails by construction
Diagnostics: continuous-world-declaration-record

saved-in-joins-a-copy-kind · world-progress

declaration check: `world-progress` names an existing copy kind when saved

scenarioper state-families row

Applies to the world-progress row.

This declaration check reads the adoption, not the running game. When world-progress has saved-in, it must name exactly one copy kind in this adoption; any other name is a defect this test fails by construction. With no saved-in, this check asserts nothing. It says nothing about a family held in two places at once; one family names one restoring save kind.

Test steps and diagnostics

Given: the continuous-world adoption document, not the running game
When: a reviewer reads world-progress's saved-in field
Then: where saved-in is present, it names exactly one copy-kinds row in this adoption; another name is a defect this test fails by construction
where saved-in is absent, this join check asserts nothing
Diagnostics: continuous-world-declaration-record

saved-in-joins-a-copy-kind · dropped-currency-recovery

declaration check: `dropped-currency-recovery` names an existing copy kind when saved

scenarioper state-families row

Applies to the dropped-currency-recovery row.

This declaration check reads the adoption, not the running game. When dropped-currency-recovery has saved-in, it must name exactly one copy kind in this adoption; any other name is a defect this test fails by construction. With no saved-in, this check asserts nothing. It says nothing about a family held in two places at once; one family names one restoring save kind.

Test steps and diagnostics

Given: the continuous-world adoption document, not the running game
When: a reviewer reads dropped-currency-recovery's saved-in field
Then: where saved-in is present, it names exactly one copy-kinds row in this adoption; another name is a defect this test fails by construction
where saved-in is absent, this join check asserts nothing
Diagnostics: continuous-world-declaration-record

saved-in-joins-a-copy-kind · combat-lock-target

declaration check: `combat-lock-target` names an existing copy kind when saved

scenarioper state-families row

Applies to the combat-lock-target row.

This declaration check reads the adoption, not the running game. When combat-lock-target has saved-in, it must name exactly one copy kind in this adoption; any other name is a defect this test fails by construction. With no saved-in, this check asserts nothing. It says nothing about a family held in two places at once; one family names one restoring save kind.

Test steps and diagnostics

Given: the continuous-world adoption document, not the running game
When: a reviewer reads combat-lock-target's saved-in field
Then: where saved-in is present, it names exactly one copy-kinds row in this adoption; another name is a defect this test fails by construction
where saved-in is absent, this join check asserts nothing
Diagnostics: continuous-world-declaration-record

backup-copy-kind-joins

declaration check: `Row.id` names an existing copy kind

scenarioper backup-copies row

Does not apply to continuous-world: backup-copies has no rows.

conflict-copy-kind-joins

declaration check: `Row.id` names an existing shared copy kind

scenarioper copy-conflicts row

Does not apply to continuous-world: copy-conflicts has no rows.

earlier-point-copy-kind-joins

declaration check: `Row.id` names an existing copy kind

scenarioper earlier-point-returns row

Does not apply to continuous-world: earlier-point-returns has no rows.

account-family-names-account-ending

declaration check: `Row.id` names account deletion or reset as its end

scenarioper state-families row

Does not apply to continuous-world: no row in state-families matches lifetime account.

restore-earlier-override-has-backup

declaration check: `Row.id`'s restore-earlier-copy override has a backup row

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches unreadable-copy restore earlier copy.

restore-earlier-default-has-backup

declaration check: `Row.id`'s restore-earlier-copy default has a backup row

scenarioper copy-kinds row

Does not apply to continuous-world: unreadable copy default is refuse load, not restore earlier copy.

returning-family-uses-shared-authority

declaration check: `Row.id` returns from a shared authority

scenarioper state-families row

Does not apply to continuous-world: no row in state-families matches on-another-device returns.

one-conflict-row-per-scope

declaration check: each conflict scope has at most one row

scenarioonce

Applies to continuous-world.

This declaration check reads the adoption, not the running game. Each represented conflict scope has at most one row. A duplicate is a defect this test fails by construction. With no conflict rows, the check asserts nothing.

Test steps and diagnostics

Given: the continuous-world adoption document, not the running game
When: a reviewer groups copy-conflicts rows by a this-copy-kind name or the all-synced-kinds scope
Then: no declared scope has more than one conflict row; a duplicate scope is a defect this test fails by construction; with no conflict rows, this check asserts nothing
Diagnostics: continuous-world-declaration-record

one-earlier-point-row-per-copy-kind

declaration check: each copy kind has at most one earlier-point row

scenarioonce

Applies to continuous-world.

This declaration check reads the adoption, not the running game. Each copy kind has at most one earlier-point row. A duplicate is a defect this test fails by construction. With no such rows, the check asserts nothing.

Test steps and diagnostics

Given: the continuous-world adoption document, not the running game
When: a reviewer groups earlier-point-returns rows by copy-kind
Then: no copy kind is named by more than one earlier-point-returns row; a duplicate is a defect this test fails by construction; with no such rows, this check asserts nothing
Diagnostics: continuous-world-declaration-record

copy-citations-state-their-duties · current-world-copy

declaration check: `current-world-copy`'s required citations state their duties

scenarioper copy-kinds row

Applies to the current-world-copy row.

This declaration check reads the adoption and cited prose, not the running game. world.saved-fields, world.accepted-change, and world.current-copy must state their family-set, write-success and loss-window, and applicable residence, authority, identity, and selection duties. A missing duty is a defect this test fails by construction. The test names the addresses and restates nothing from them.

Test steps and diagnostics

Given: the continuous-world adoption and the prose at world.saved-fields, world.accepted-change, and world.current-copy, not the running game
When: a reviewer checks each citation's meaning
Then: world.saved-fields names the complete family set written and restored together
world.accepted-change names the trigger, success condition, final-write behavior, and quit or crash loss window
world.current-copy names residence, applicable sync or service acceptance and authority, layout, identities, and player selection
a citation missing its duty is a defect this test fails by construction
Diagnostics: continuous-world-declaration-record

backup-citations-state-their-duties

declaration check: `Row.id`'s backup citations state their duties

scenarioper backup-copies row

Does not apply to continuous-world: backup-copies has no rows.

conflict-citation-states-its-duties

declaration check: `Row.id`'s resolution citation states its duties

scenarioper copy-conflicts row

Does not apply to continuous-world: copy-conflicts has no rows.

earlier-return-citation-states-its-duties

declaration check: `Row.id`'s return citation states its duties

scenarioper earlier-point-returns row

Does not apply to continuous-world: earlier-point-returns has no rows.

copy-removal-citation-states-its-duty

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

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches removed-at normal quit or crash or death or slot delete or local profile delete or device data delete or account delete.

copy-mode-citation-states-its-duty

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

scenarioper copy-kinds row

Does not apply to continuous-world: no row in copy-kinds matches mode-gated only in named modes.

player-mode-return-is-mode-gated

declaration check: `Row.id`'s player-mode return is mode-gated

scenarioper earlier-point-returns row

Does not apply to continuous-world: earlier-point-returns has no rows.

earlier-point-mode-citation-states-its-duty

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

scenarioper earlier-point-returns row

Does not apply to continuous-world: earlier-point-returns has no rows.

persistence-holds

the persistence mechanism holds for the whole run

generalonce

Applies to continuous-world.

Across each of quit, crash, death, slot deletion, profile deletion, and device change that the adoption can construct, plus each constructible damage and build-mismatch case, each family's value on both sides of every constructed boundary matches its row and the numbered settlement order holds. Every load the adoption can construct refuses partial state and activates all carried families together only when accepted. A case the adoption cannot construct asserts nothing. The pack's default audit seeds apply unless the adoption supplies its own.

Test steps and diagnostics

Holds: every state family's distinguishable value on both sides of every constructed boundary matched its row; every commit, candidate, conflict, build comparison, damage response, activation, earlier return, deletion, device return, and settlement report that the adoption constructed followed the mechanism's numbered order; every constructed load that was partial or refused activated no state; every accepted load activated all carried families together; where the adoption can construct no load, conflict, damage, build mismatch, or earlier return, that clause asserts nothing
Seeds: ["audit-a","audit-b"]
Scope: each of quit, crash, death, slot deletion, profile deletion, and device change that the adoption can construct, plus each constructible damage and build-mismatch case
Diagnostics: continuous-world-state-boundary-trace
continuous-world-commit-log
continuous-world-candidate-set
continuous-world-settlement-trace
continuous-world-load-result
continuous-world-active-state-source
continuous-world-settlement-report
continuous-world-first-ordering-violation

JSONthe adoption as one file

The adoption file as supplied. Answers you try on this page are not written into it; to change an adoption, open it in the authoring tool.

{
  "contract": "state-persistence-scope",
  "version": 1,
  "summary": "Covers what survives the end of a run or session, a quit, a crash, death, deleting saved data, and moving to another device. It also covers local saves, manual slots, cloud copies, server profiles, backups, conflicts, and version changes. Closed-game time, replay guarantees, file formats, and the shape of saved numbers stay elsewhere.",
  "questions": {
    "unreadable-copy-default": {
      "asks": "What normally happens when saved state cannot be read?",
      "rationale": "Lost progress is the most visible failure a save system has. Choose the result players should expect first.",
      "when": {
        "row-count": {
          "copy-kinds": "non-empty"
        }
      },
      "otherwise": "No saved copy can be opened later, so unreadable saved state never reaches a load attempt.",
      "options": {
        "refuse-load": {
          "meaning": "The unreadable copy stays closed. A city slot remains listed, but none of its progress becomes active.",
          "semantics": "Loading stops before any state from that copy becomes active. The copy is neither replaced nor repaired by this response."
        },
        "start-fresh": {
          "meaning": "Play starts from normal fresh state. A damaged puzzle slot opens with its first board instead of the old board.",
          "semantics": "Fresh state becomes active instead of state from the unreadable copy. The response does not by itself delete or overwrite that copy."
        },
        "restore-earlier-copy": {
          "meaning": "An earlier copy can replace it through the supported route, including a manual file restore. A factory returns after choosing the backup before its damaged autosave.",
          "semantics": "A declared manual, in-game, or automatic recovery route can activate an earlier copy. The newest usable earlier copy under the matching backup rule becomes active."
        },
        "repair-readable-state": {
          "meaning": "Readable progress returns and damaged parts reset. A dungeon keeps cleared floors but rebuilds one broken room record.",
          "semantics": "Readable state becomes active as one repaired result. Every unreadable part takes the fresh value named by the cited repair rule."
        },
        "warn-and-try": {
          "meaning": "The player can cancel or try the unreadable copy. A colony save opens only after its damage warning is accepted.",
          "semantics": "No state from the copy becomes active before the explicit choice. Accepting the warning permits an attempt but does not promise success."
        }
      }
    },
    "older-build-default": {
      "asks": "What normally happens when an older game build wrote the copy?",
      "rationale": "Updates can strand a player's progress or change it permanently. Choose how the current build protects that progress.",
      "when": {
        "row-count": {
          "copy-kinds": "non-empty"
        }
      },
      "otherwise": "No loadable copy exists, so an older build has no saved state to open.",
      "options": {
        "refuse-load": {
          "meaning": "The older copy stays closed. A world from last year's rules cannot open in the current build.",
          "semantics": "Loading stops before state written by the older build becomes active."
        },
        "convert-and-load": {
          "meaning": "The game updates the old state and opens it. A factory save gains the current recipe records before play resumes.",
          "semantics": "A declared conversion produces current-build state before activation."
        },
        "warn-and-load": {
          "meaning": "The old copy is tried only after a warning. A racing career from an earlier patch opens after the player accepts the risk.",
          "semantics": "The player accepts a compatibility warning before old-build state becomes active. Acceptance permits an attempt but does not promise success."
        }
      }
    },
    "newer-build-default": {
      "asks": "What normally happens when a newer game build wrote the copy?",
      "rationale": "Going back to an older build can erase newer content. Choose whether the player may take that risk.",
      "when": {
        "row-count": {
          "copy-kinds": "non-empty"
        }
      },
      "otherwise": "No loadable copy exists, so a newer build has no saved state to open.",
      "options": {
        "refuse-load": {
          "meaning": "The newer copy stays closed. A world from a later patch remains unavailable in this build.",
          "semantics": "Loading stops before state written by the newer build becomes active."
        },
        "warn-and-load": {
          "meaning": "The newer copy is tried only after a warning. A sandbox world opens after the player accepts that newer content may be lost.",
          "semantics": "The player accepts a compatibility warning before newer-build state becomes active. Acceptance permits an attempt but does not promise success."
        }
      }
    }
  },
  "declares": {
    "values": {},
    "rows": {
      "state-families": {
        "description": "List each family of state that can change later play and give its observed persistence boundaries.",
        "when-empty": "No changing game state is covered, so this adoption makes no persistence promise.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "Name the state family in game words, such as campaign-progress, run-inventory, unlocks, or settings."
          },
          "state-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The fixed game prose naming every field in this family and the points where it can affect later play. For a family that does not return after a quit, a crash, or on another device, it also names the value the family starts from."
          },
          "lifetime": {
            "type": "string",
            "required": true,
            "options": [
              "run",
              "session",
              "slot",
              "profile",
              "device",
              "account",
              "until-event",
              "not-kept"
            ],
            "description": "Run: the state belongs to one attempt; a roguelike's carried items go when that attempt ends. Session: the state belongs to one continuous visit; a co-op lobby choice goes when the party leaves that lobby. Slot: the state belongs to one player-selected save; campaign progress goes when that slot is deleted. Profile: the state belongs to one local player profile; unlocks go when that profile is deleted. Device: the state belongs to one installation; local settings go when that device data is erased. Account: the state belongs to one account; online settings go when that account is deleted or reset. Until event: the state lasts to one named game event; dropped currency goes at the next death. Not kept: the state does not cross its first named interruption; an enemy's alert meter does not return after quitting."
          },
          "scope-starts-in": {
            "type": "citation",
            "when": {
              "row": {
                "lifetime": [
                  "run",
                  "session"
                ]
              }
            },
            "description": "The player-observable start of this attempt or continuous visit. A run may start when the character enters the dungeon; a session may start when the party joins a lobby."
          },
          "scope-ends-in": {
            "type": "citation",
            "when": {
              "row": {
                "lifetime": [
                  "run",
                  "session",
                  "slot",
                  "profile",
                  "device",
                  "account",
                  "not-kept"
                ]
              }
            },
            "description": "The player-observable ending of this lifetime. It may be an attempt result, leaving a lobby, deleting a player-selected slot, deleting a local profile, erasing device data, deleting an account, or the first interruption that discards the value."
          },
          "lifetime-event-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "lifetime": [
                  "until-event"
                ]
              }
            },
            "description": "The named game event that destroys the earlier value. A recovery point may last until the next death after it appears."
          },
          "saved-in": {
            "type": "string",
            "pattern": "kebab-case",
            "description": "The save kind that restores this family. Absence means no copy restores it."
          },
          "after-normal-quit": {
            "type": "string",
            "required": true,
            "options": [
              "returns-last-commit",
              "does-not-return"
            ],
            "description": "Whether the last saved point returns after an ordinary quit. A campaign returns its last checkpoint; an unsaved match score does not."
          },
          "after-crash": {
            "type": "string",
            "required": true,
            "options": [
              "returns-last-commit",
              "does-not-return"
            ],
            "description": "Whether the last saved point returns after a crash. A timer-written world may lose changes since its last write while still returning that write."
          },
          "after-death": {
            "type": "string",
            "required": true,
            "options": [
              "keeps-value",
              "clears-value"
            ],
            "description": "Whether death keeps this value. Roguelike unlocks may remain while the dead run's inventory clears."
          },
          "after-slot-delete": {
            "type": "string",
            "required": true,
            "options": [
              "keeps-value",
              "clears-value",
              "no-slot"
            ],
            "description": "Whether deleting the related player-selected save keeps this value. That slot is named by the storage rule for several player-selected saves; a save presented as one current copy answers that no related slot exists."
          },
          "after-local-profile-delete": {
            "type": "string",
            "required": true,
            "options": [
              "keeps-value",
              "clears-value",
              "no-profile"
            ],
            "description": "Whether deleting the related local player profile keeps this value. That profile is named by the restoring copy's storage rule; a family with no such profile answers that no related profile exists."
          },
          "on-another-device": {
            "type": "string",
            "required": true,
            "options": [
              "returns",
              "does-not-return"
            ],
            "description": "Whether the value returns when the same eligible player continues on another device. A server profile may return; local settings may not."
          }
        }
      },
      "copy-kinds": {
        "description": "List each independently written and loaded save kind, such as campaign slots, profile data, cloud settings, or a server profile.",
        "when-empty": "No saved copy can be opened later. Loading cannot restore state, compare builds, recover damage, or resolve a conflict.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "Name this save kind in game words, such as campaign-slots, unlock-profile, or account-settings."
          },
          "contains-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The fixed list of state-family ids written and restored together by this save kind."
          },
          "write-trigger": {
            "type": "string",
            "required": true,
            "options": [
              "player-save",
              "checkpoint",
              "continuous",
              "timer",
              "service-owned"
            ],
            "description": "What starts a save: a save action, a named checkpoint, each accepted change, a timer, or the service's own rule."
          },
          "write-rule-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The rule naming exactly when a save begins, what makes it successful, and which later changes a quit or crash can lose."
          },
          "residence": {
            "type": "string",
            "required": true,
            "options": [
              "local-device",
              "cloud-synced",
              "server-authoritative"
            ],
            "description": "Where the copy that can restore play is authoritative: this device, synced device copies, or a game service. Copies shared through sync can conflict; a profile controlled by the service reads its accepted state."
          },
          "layout": {
            "type": "string",
            "required": true,
            "options": [
              "one-current",
              "manual-slots"
            ],
            "description": "How the save is presented: one current copy or several player-selected slots. A slot is one named load choice in the storage rule; retained earlier copies belong in the backup list."
          },
          "storage-rule-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The rule naming copy residence, sync or service authority, and the player-visible selection route. For several player-selected saves it also names each stable slot identity; one current copy names no player-selected slot."
          },
          "unreadable-copy": {
            "type": "string",
            "required": true,
            "options": [
              "use-game-default",
              "refuse-load",
              "start-fresh",
              "restore-earlier-copy",
              "repair-readable-state",
              "warn-and-try"
            ],
            "description": "Use the game's ordinary answer for a save that cannot be read, or choose a different result for this save kind."
          },
          "older-build-copy": {
            "type": "string",
            "required": true,
            "options": [
              "use-game-default",
              "refuse-load",
              "convert-and-load",
              "warn-and-load"
            ],
            "description": "Use the game's ordinary answer for a save written by an older build, or choose a different result for this save kind."
          },
          "newer-build-copy": {
            "type": "string",
            "required": true,
            "options": [
              "use-game-default",
              "refuse-load",
              "warn-and-load"
            ],
            "description": "Use the game's ordinary answer for a save written by a newer build, or choose a different result for this save kind."
          },
          "mode-gated": {
            "type": "string",
            "options": [
              "only-in-named-modes"
            ],
            "description": "This save kind exists only in named player modes. A restore point may exist in a practice mode and a standard mode but not in a challenge mode."
          },
          "mode-rule-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "mode-gated": [
                  "only-in-named-modes"
                ]
              }
            },
            "description": "The rule naming every player mode where this save kind exists and confirming that it is absent elsewhere."
          },
          "removed-at": {
            "type": "string",
            "options": [
              "normal-quit",
              "crash",
              "death",
              "slot-delete",
              "local-profile-delete",
              "device-data-delete",
              "account-delete"
            ],
            "description": "The event that removes this copy from later load choices. A permadeath save may vanish when the character dies. For several player-selected saves this names removal of the deleted slot's copy, not of the whole save kind."
          },
          "removal-rule-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "removed-at": [
                  "normal-quit",
                  "crash",
                  "death",
                  "slot-delete",
                  "local-profile-delete",
                  "device-data-delete",
                  "account-delete"
                ]
              }
            },
            "description": "The rule naming the exact event that removes the copy and what the player sees afterward."
          }
        }
      },
      "backup-copies": {
        "description": "List save kinds that retain an earlier copy for supported recovery.",
        "when-empty": "No save kind promises an earlier usable copy, so damage cannot be answered by restoring one.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "Name the earlier-copy family, such as previous-campaign-checkpoint."
          },
          "copy-kind": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The save kind protected by this earlier copy."
          },
          "backup-rule-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The rule naming when an earlier copy is retained, how many remain, and what later progress recovery loses."
          },
          "restore-rule-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The supported route for opening an earlier copy. It names whether recovery is automatic, in the game, or an external file step."
          }
        }
      },
      "copy-conflicts": {
        "description": "List shared save kinds that can present two complete but disagreeing copies. One adoption has at most one row per conflict scope: one for each named save kind and one for all synced kinds.",
        "when-empty": "No shared save kind can present competing copies, so no conflict response runs.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "Name the conflict in game words, such as campaign-slot-sync."
          },
          "scope": {
            "type": "string",
            "required": true,
            "options": [
              "this-copy-kind",
              "all-synced-kinds"
            ],
            "description": "Whether the response settles one save kind or every synced save kind together. One cloud dialog may settle campaign slots and quicksaves as a set."
          },
          "copy-kind": {
            "type": "string",
            "when": {
              "row": {
                "scope": [
                  "this-copy-kind"
                ]
              }
            },
            "pattern": "kebab-case",
            "description": "The one cloud-synced or service save kind whose copies can disagree."
          },
          "response": {
            "type": "string",
            "required": true,
            "options": [
              "select-by-rule",
              "player-chooses-copy",
              "refuse-until-resolved"
            ],
            "description": "What happens before any disagreeing state becomes active. A fixed rule may always prefer the copy the game service holds; the player may choose between dated copies; or neither copy may open until sync is repaired."
          },
          "resolution-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The rule detecting disagreement, comparing copy identity, selecting or preserving copies, and naming the event that clears the conflict."
          }
        }
      },
      "earlier-point-returns": {
        "description": "List save kinds that can return to an earlier point of the same continuous play, whether or not the game names a run. One adoption has at most one row per save kind.",
        "when-empty": "No save kind can return to an earlier point of the same continuous play, so reload-to-retry is unavailable.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "Name the earlier return point in game words, such as dungeon-retry or quicksave."
          },
          "copy-kind": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The save kind that can return play to the earlier point."
          },
          "after-load": {
            "type": "string",
            "required": true,
            "options": [
              "resume-stays",
              "resume-is-used-once",
              "player-mode-decides"
            ],
            "description": "Whether the same earlier point remains available after a successful load. A practice mode may keep a boss checkpoint while an iron mode allows one return."
          },
          "return-rule-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The rule naming the earlier point, successful activation, and whether another load remains possible."
          },
          "mode-gated": {
            "type": "string",
            "options": [
              "only-in-named-modes"
            ],
            "description": "This earlier return point exists only in named player modes. A quicksave may be available in a practice mode but absent in a challenge mode."
          },
          "mode-rule-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "mode-gated": [
                  "only-in-named-modes"
                ]
              }
            },
            "description": "The rule naming every player mode where this earlier return point exists and confirming that it is absent elsewhere."
          }
        }
      }
    }
  },
  "rules": {},
  "origin": "https://opengdd.org/contracts/state-persistence-scope-1",
  "mechanism": [
    "This is the one normative settlement authority for state-family identity, scope starts and endings, commits, loads, damage, build mismatch, copy conflicts, deletion, and device change. Questions and rows supply defaults, overrides, and cited game rules; they do not define another sequence.",
    "A **run** begins at the player-observable attempt start named by `scope-starts-in` and ends at the result or exit named by `scope-ends-in`. Victory, death, and abandonment are common endings, but only the cited game rules decide. A save or load does not start or end a run. A **session** begins when play enters the world, match, lobby, or profile context named by `scope-starts-in` and ends at the exit, switch, or reset named by `scope-ends-in`. It survives a pause, background interval, closure, or relaunch that returns to that same context; a missing commit may still prevent its earlier value from returning.",
    "A **commit** is one coherent accepted write of a copy kind. A **copy** is a load candidate with its save-kind id, copy identity, any slot identity, build identity, commit identity, and complete state-family set. A **conflict** exists when the cited rule finds two accepted shared copies in one declared conflict scope that disagree and neither has already replaced the other. An **earlier copy** is a retained older commit named by a backup row.",
    "### Change and commit",
    "1. When state changes, keep each `state-families` row as one family under its cited game rule. The row's lifetime is the maximum scope of that earlier value. An `until-event` value ends at its cited game event; a shorter boundary result may clear any value sooner only when the row says so. 2. Evaluate run and session starts and endings from their separate cited player-observable events. A save action, automatic write, timer tick, process launch, process close, or load does not create a new run or session by itself. 3. Start a copy-kind commit only at its selected write trigger. A player save follows the cited save action. A checkpoint follows its named game event. Continuous writing follows each accepted change named by its rule. A timer follows the cited interval. A service-owned copy follows its authority's cited acceptance event. 4. A commit becomes loadable only when `write-rule-declared-in` reports success for the complete `contains-declared-in` set. A failed or partial write never replaces the last successful commit. Earlier copies are retained and ordered only by their backup and storage rules.",
    "### Quit, crash, and return",
    "5. On an ordinary quit, perform a final commit only when the copy kind's cited write rule calls for one. For each state row, `returns-last-commit` restores its latest successful commit on return; `does-not-return` starts from the cited post-quit value. Uncommitted changes do not return. A copy removed at normal quit is no longer a later load choice. 6. On a crash, no unfinished commit succeeds. For each state row, `returns-last-commit` restores the last commit that succeeded before the crash; `does-not-return` starts from the cited post-crash value. A timer or checkpoint therefore has an explicit possible loss window. A copy removed at crash is no longer a later load choice. 7. Select the requested slot or profile before activating state. A `one-current` kind selects its current copy. `manual-slots` selects the player's named slot. A retained earlier copy is not another layout; the damage response and matching backup rule may select it later, and a backup row's cited restore route is also available to the player directly, independent of any damage response. 8. A local-device copy is available only on that device unless another cited transfer exists outside this adoption. A cloud-synced kind obtains every accepted device and cloud candidate before conflict handling. A server-authoritative kind obtains the service's accepted copy and does not treat an unaccepted local cache as equal authority. Read each candidate's save-kind, slot, build, and commit identity now. A candidate whose identity cannot be read is not a conflict candidate. If no candidate survives, run the requested kind's damage response immediately, without conflict or build comparison. A readable header with an unreadable gameplay body remains a candidate for steps 9 and 10, then reaches the damage response in step 11.",
    "### Conflict, compatibility, and damage",
    "9. If readable shared candidates conflict, apply the matching row's response before reading their gameplay state. A one-kind row settles only that save kind; a whole-set row settles every synced kind together. `select-by-rule` chooses one complete copy. `player-chooses-copy` waits for one complete-copy choice. `refuse-until-resolved` activates neither. No response merges fields. 10. Compare the selected copy's writing build with the running build. Apply the copy-kind override when present; otherwise apply the matching older or newer default. Refusal activates no state. Conversion produces one current-build copy before activation. A warning precedes the attempt and does not promise that it succeeds. If conversion fails, refuse the load and leave the source copy unchanged unless its cited rule says otherwise. 11. Read the selected copy as one coherent unit. If it is unreadable, apply the copy-kind override or `unreadable-copy-default`. Refusal activates nothing. Fresh start activates the cited fresh state without silently deleting the unreadable copy. Earlier-copy recovery follows the matching backup row, selects the newest usable earlier copy, and reports the lost interval. Repair activates one coherent repaired result and resets every unreadable part under the cited rule; failure to produce a coherent result refuses the load. Warning waits for the player's choice before any attempted activation. 12. Activate all state families in the accepted copy together. State families saved in another copy kind keep the already active value from that kind; a state family without `saved-in` is never restored by this load. 13. If the accepted copy has a `earlier-point-returns` row, return continuous play to its cited earlier point. If that point is inside a run, continue the same run identity. Apply `after-load` only after successful activation: keeping the resume leaves it available, using it once makes it unavailable, and a player-mode answer follows the mode fixed before the load.",
    "### Death, deletion, and another device",
    "14. On death, apply every state's `after-death` result. `clears-value` removes the earlier value before later play. `keeps-value` retains it. If death is also the cited run end, every run-lifetime value clears even if no save action occurs. If it is the cited event for an `until-event` value, that value clears as well. Longer-lived unlocks, settings, and profile state follow their own rows. A copy with `removed-at: death` disappears from the load choices after these state results are settled. 15. On slot deletion, clear each `clears-value` row tied to that slot and keep each `keeps-value` row. `no-slot` records that the state has no related player-selected slot. Deleting a local profile applies `after-local-profile-delete` the same way and includes any slots whose cited rule makes them children of that profile. Device-data deletion ends device-lifetime state under its cited rule. Account deletion or reset ends account-lifetime state through `scope-ends-in`. At each event, remove every copy whose `removed-at` value names it. 16. On another eligible device, `returns` obtains the family from its cloud-synced or server-authoritative copy before activation and still runs conflict handling. `does-not-return` starts from the cited new-device value. A device change does not by itself delete the source device's copy. 17. After every event, no earlier value affects later play once its lifetime has ended or its selected boundary result cleared it. A later game rule may derive a new value, but that is new state rather than restoration of the cleared value. A mode-gated copy or earlier return point exists only while the cited player mode permits it.",
    "Every settlement report identifies the state-family id, copy-kind id or its absence, event, scope before and after, last successful commit when read, selected copy and build when loaded, override or default used, state result, and any lost interval. Conflict reports also identify both candidate commits and the selected response. Damage reports identify refusal, fresh state, earlier-copy recovery, repaired parts, or warning choice without claiming an unattempted load succeeded."
  ],
  "answers": {
    "unreadable-copy-default": "refuse-load",
    "older-build-default": "convert-and-load",
    "newer-build-default": "refuse-load"
  },
  "values": {},
  "rows": {
    "state-families": [
      {
        "id": "world-progress",
        "state-declared-in": "world.progress-fields",
        "lifetime": "profile",
        "scope-ends-in": "profile.delete-world",
        "saved-in": "current-world-copy",
        "after-normal-quit": "returns-last-commit",
        "after-crash": "returns-last-commit",
        "after-death": "keeps-value",
        "after-slot-delete": "no-slot",
        "after-local-profile-delete": "clears-value",
        "on-another-device": "does-not-return"
      },
      {
        "id": "dropped-currency-recovery",
        "state-declared-in": "recovery.currency-and-location",
        "lifetime": "until-event",
        "lifetime-event-declared-in": "recovery.next-death-after-drop",
        "saved-in": "current-world-copy",
        "after-normal-quit": "returns-last-commit",
        "after-crash": "returns-last-commit",
        "after-death": "clears-value",
        "after-slot-delete": "no-slot",
        "after-local-profile-delete": "clears-value",
        "on-another-device": "does-not-return"
      },
      {
        "id": "combat-lock-target",
        "state-declared-in": "combat.lock-target",
        "lifetime": "not-kept",
        "scope-ends-in": "combat.first-interruption",
        "after-normal-quit": "does-not-return",
        "after-crash": "does-not-return",
        "after-death": "clears-value",
        "after-slot-delete": "no-slot",
        "after-local-profile-delete": "no-profile",
        "on-another-device": "does-not-return"
      }
    ],
    "copy-kinds": [
      {
        "id": "current-world-copy",
        "contains-declared-in": "world.saved-fields",
        "write-trigger": "continuous",
        "write-rule-declared-in": "world.accepted-change",
        "residence": "local-device",
        "layout": "one-current",
        "storage-rule-declared-in": "world.current-copy",
        "unreadable-copy": "use-game-default",
        "older-build-copy": "use-game-default",
        "newer-build-copy": "use-game-default"
      }
    ],
    "earlier-point-returns": [],
    "backup-copies": [],
    "copy-conflicts": []
  },
  "pack": "sha256:86060e861a3d6b10e0019612467e03749328dba98ab1a148bbc54c09e2492cf7"
}

Continuous world

Use in your game

The contract behind it

Questions

What normally happens when saved state cannot be read?

What normally happens when an older game build wrote the copy?

What normally happens when a newer game build wrote the copy?

State families

Copy kinds

Backup copies

Copy conflicts

Earlier point returns

Row.id begins and ends its run only at the cited events

Row.id keeps one session through returns to the same context

current-world-copy copies carry complete identity and family membership

Row.id is a conflict only for two accepted unreplaced copies

world-progress follows its declared maximum lifetime

dropped-currency-recovery follows its declared maximum lifetime

combat-lock-target follows its declared maximum lifetime

dropped-currency-recovery ends at its cited event

combat-lock-target never returns after its named interruption

world-progress ends at its cited profile boundary

current-world-copy starts a commit only at its selected trigger

current-world-copy replaces its last commit only after complete success

current-world-copy makes a final quit commit only when its rule calls for one

world-progress returns its last commit after a normal quit

dropped-currency-recovery returns its last commit after a normal quit

combat-lock-target does not return after a normal quit

world-progress returns its last completed commit after a crash

dropped-currency-recovery returns its last completed commit after a crash

combat-lock-target does not return after a crash

Row.id exposes its possible crash loss window

current-world-copy selects its requested copy before activation

current-world-copy obtains candidates from its declared residence

current-world-copy reads candidate identity before settlement

current-world-copy has no conflict response without a matching row

Row.id settles only Row.copy kind

Row.id settles every synced kind together

Row.id applies select-by-rule

Row.id applies player-chooses-copy

Row.id applies refuse-until-resolved

Row.id applies its older-build refuse-load override

Row.id applies the older-build refuse-load default

Row.id applies its older-build convert-and-load override

current-world-copy applies the older-build convert-and-load default

Row.id applies its older-build warn-and-load override

Row.id applies the older-build warn-and-load default

Row.id applies its newer-build refuse-load override

current-world-copy applies the newer-build refuse-load default

Row.id applies its newer-build warn-and-load override

Row.id applies the newer-build warn-and-load default

Row.id applies its unreadable-copy refuse-load override

current-world-copy applies the unreadable-copy refuse-load default

Row.id applies its unreadable-copy start-fresh override

Row.id applies the unreadable-copy start-fresh default

Row.id applies its unreadable-copy restore-earlier-copy override

Row.id applies the unreadable-copy restore-earlier-copy default

Row.id applies its unreadable-copy repair-readable-state override

Row.id applies the unreadable-copy repair-readable-state default

Row.id applies its unreadable-copy warn-and-try override

Row.id applies the unreadable-copy warn-and-try default

Row.id retains and restores earlier copies

current-world-copy loads a readable compatible conflict-free copy

loading current-world-copy preserves state from other copy kinds

world-progress is never restored when it names no save kind

dropped-currency-recovery is never restored when it names no save kind

combat-lock-target is never restored when it names no save kind

Row.id follows its after-load result

current-world-copy returns nowhere without an earlier-point row

Row.id exists only in its named modes

world-progress follows its death result

dropped-currency-recovery follows its death result

combat-lock-target follows its death result

Row.id clears when death is its run end

dropped-currency-recovery clears when death is its cited event

world-progress follows its slot-deletion result

dropped-currency-recovery follows its slot-deletion result

combat-lock-target follows its slot-deletion result

world-progress follows its local-profile-deletion result

dropped-currency-recovery follows its local-profile-deletion result

`Row.id` begins and ends its run only at the cited events

`Row.id` keeps one session through returns to the same context

`current-world-copy` copies carry complete identity and family membership

`Row.id` is a conflict only for two accepted unreplaced copies

`world-progress` follows its declared maximum lifetime

`dropped-currency-recovery` follows its declared maximum lifetime

`combat-lock-target` follows its declared maximum lifetime

`dropped-currency-recovery` ends at its cited event

`combat-lock-target` never returns after its named interruption

`world-progress` ends at its cited `profile` boundary

`current-world-copy` starts a commit only at its selected trigger

`current-world-copy` replaces its last commit only after complete success

`current-world-copy` makes a final quit commit only when its rule calls for one

`world-progress` returns its last commit after a normal quit

`dropped-currency-recovery` returns its last commit after a normal quit

`combat-lock-target` does not return after a normal quit

`world-progress` returns its last completed commit after a crash

`dropped-currency-recovery` returns its last completed commit after a crash

`combat-lock-target` does not return after a crash

`Row.id` exposes its possible crash loss window

`current-world-copy` selects its requested copy before activation

`current-world-copy` obtains candidates from its declared residence

`current-world-copy` reads candidate identity before settlement

`current-world-copy` has no conflict response without a matching row

`Row.id` settles only `Row.copy kind`

`Row.id` settles every synced kind together

`Row.id` applies select-by-rule

`Row.id` applies player-chooses-copy

`Row.id` applies refuse-until-resolved

`Row.id` applies its older-build refuse-load override

`Row.id` applies the older-build refuse-load default

`Row.id` applies its older-build convert-and-load override

`current-world-copy` applies the older-build convert-and-load default

`Row.id` applies its older-build warn-and-load override

`Row.id` applies the older-build warn-and-load default

`Row.id` applies its newer-build refuse-load override

`current-world-copy` applies the newer-build refuse-load default

`Row.id` applies its newer-build warn-and-load override

`Row.id` applies the newer-build warn-and-load default

`Row.id` applies its unreadable-copy refuse-load override

`current-world-copy` applies the unreadable-copy refuse-load default

`Row.id` applies its unreadable-copy start-fresh override

`Row.id` applies the unreadable-copy start-fresh default

`Row.id` applies its unreadable-copy restore-earlier-copy override

`Row.id` applies the unreadable-copy restore-earlier-copy default

`Row.id` applies its unreadable-copy repair-readable-state override

`Row.id` applies the unreadable-copy repair-readable-state default

`Row.id` applies its unreadable-copy warn-and-try override

`Row.id` applies the unreadable-copy warn-and-try default

`Row.id` retains and restores earlier copies

`current-world-copy` loads a readable compatible conflict-free copy

loading `current-world-copy` preserves state from other copy kinds

`world-progress` is never restored when it names no save kind

`dropped-currency-recovery` is never restored when it names no save kind

`combat-lock-target` is never restored when it names no save kind

`Row.id` follows its after-load result

`current-world-copy` returns nowhere without an earlier-point row

`Row.id` exists only in its named modes

`world-progress` follows its death result

`dropped-currency-recovery` follows its death result

`combat-lock-target` follows its death result

`Row.id` clears when death is its run end

`dropped-currency-recovery` clears when death is its cited event

`world-progress` follows its slot-deletion result

`dropped-currency-recovery` follows its slot-deletion result

`combat-lock-target` follows its slot-deletion result

`world-progress` follows its local-profile-deletion result

`dropped-currency-recovery` follows its local-profile-deletion result

`combat-lock-target` follows its local-profile-deletion result

`Row.id` ends when device data is deleted

`Row.id` ends when its account is deleted or reset

`Row.id` returns on another eligible device

`world-progress` does not return on another device

`dropped-currency-recovery` does not return on another device

`combat-lock-target` does not return on another device

`Row.id` disappears at its removal event

`Row.id` exists only in its named modes

declaration check: `world-progress`'s state citation states its duty

declaration check: `dropped-currency-recovery`'s state citation states its duty

declaration check: `combat-lock-target`'s state citation states its duty