Restore and cold boot

Prerequisite: persistence and custody. Keep the record operations separate from rebuilding a runtime:

create_checkpoint records the checkpoint in the in-process ledger.
flush_checkpoint seals it to the local cache.
reload_cached_checkpoint brings cached record data back into the ledger.
load_checkpoint attempts to rebuild the selected world through its public operations.

Inspect the report

A restore report carries status, built counts, shortfalls, and identity translation. Runtime identities are rebuilt; the translation information connects recorded and new identities. The separate research-record JSON lesson preserves the identity of the record it hydrates. Those are different contracts.

Preflight can refuse an incomplete chain before construction. Preserve the full required profile chain when preparing a cold start; reloading a single checkpoint does not imply every predecessor has been reloaded.

Restore named lesser structure

Run Named scopes in Nexus and restore for a successful replay with assertions. It records a named job beneath an unnamed parent, tears down the live roots and restores from the retained in-memory checkpoint. This is different from a process restart, which also needs the flush/reload steps above.

Dynamic named scopes carry their name, parent and root relationships. Required unnamed ancestry is saved as supporting values inside named records. Restoring rebuilds one shared Book/root and its children in parent order with fresh IDs; unnamed support stays outside Cloud discovery. Scope names do not restore the mutable contents of previously created objects. A later meld creates fresh state.

Released names disappear from later checkpoints while earlier sealed checkpoints retain their earlier structure. Formations rooted at a named lesser include its required ancestry and selected subtree. Record schema 3.0.0 makes older root-only readers refuse safely; valid older root-only records remain readable.

Quiesce ordinary lesser/SpellSpace creation, cleanup and lineage changes during live restore. Transaction load authority does not drain those pool cycles.

Follow both demonstrations

Expert 24 keeps the recorder alive and retires the original root before rebuilding it. Expert 27 flushes, tears down the root, creates a new runtime, and reads the cache again. The latter deliberately reports an admission refusal if the bundle is incomplete. A script finishing successfully therefore does not, on its own, prove a complete world was restored. Read the reported status, built resources, and shortfalls.

CrystallizerBootstrap packages the restart sequence into a one-shot operation: activate, attach configured storage, reload, verify, load, report. Its empty-history case differs from a broken chain. Use the pod-boot lesson for its complete setup.

The workflow in code

These are the core steps from the saved example. Use its complete linked script for all class definitions and setup.

def main() -> None:
    """Capture a live named hierarchy, retire it and rebuild fresh structural identities.

    Contract:
        Single-threaded: no scope acquisition/return races with load_checkpoint.
        The recorder remains alive, so this demonstrates in-memory replay; flush
        and reload are required when crossing process teardown instead.
    Returns:
        None.
    """
    recorder = md.Crystallizer()
    recorder.activate(md.CrystallizerConfigurationBuilder().with_defaults().activate())
    nexus = md.Nexus()
    nexus_configuration = nexus.create_configuration()
    nexus_configuration.with_rift_creation_enabled(True)
    nexus_configuration.with_allowed_target_frame_names(["named-jobs"])
    nexus.activate(nexus_configuration)

    configuration = md.SpellbookConfiguration("named-jobs").with_defaults().finalize()
    book = md.Spellbook(aetheric_frame="named-jobs", configuration=configuration)
    book.configure_aether_frame(
        system_state="dynamic", disposal=None, disposal_method_names=None,
        rift_enabled=True, ai_native=True,
    )
    book.bind(spell=JobNotebook, existence="unique_per_conduit", permissions="create")
    root = book.conjure(name="job-owner")
    observer = open_observer("before-restore")
    try:
        commands = observer.space.command_system
        job = commands.create_lesser_conduit(root.id, frame_name="named-jobs", name="job-42")
        observer.refresh_runtime_projections(frame_names=("named-jobs",))
        assert commands.get_conduit_by_name("job-42", frame_name="named-jobs") is job
        print("The capability command creates a named job; explicit refresh admits its new ID.")

        job.cleanup()
        assert "job-42" not in commands.list_conduit_names(frame_name="named-jobs")
        next_job = commands.create_lesser_conduit(root.id, frame_name="named-jobs", name="job-43")
        assert commands.get_conduit_by_name("job-43", frame_name="named-jobs") is next_job
        print("Named reuse updates the existing ID's descriptor without an in-command refresh.")

        support = root.create_lesser_conduit()
        nested = support.create_lesser_conduit(name="nested-job")
        original_id, support_id = nested.id, support.id
        original = nested.meld("JobNotebook")
        original.notes.append("not part of the structural record")
        observer.refresh_runtime_projections(frame_names=("named-jobs",))
        checkpoint = recorder.create_checkpoint()
        print("Checkpoint captured names and unnamed supporting ancestry, not notebook contents.")
    finally:
        observer.cleanup()
        root.permanent_cleanup()

    report = recorder.load_checkpoint(checkpoint)
    assert report["status"] == "complete"
    cloud = md.Aether().get_conduit_cloud("named-jobs")
    restored_root = cloud.get_conduit_by_name("job-owner")
    restored = cloud.get_conduit_by_name("nested-job")
    restored_observer = open_observer("after-restore")
    try:
        assert restored.id != original_id
        assert report["identity_map"][original_id] == restored.id
        assert support_id in report["identity_map"]
        assert not cloud.has_conduit_id(report["identity_map"][support_id])
        assert restored.meld("JobNotebook").notes == []
        assert restored_observer.space.command_system.get_conduit_by_name(
            "nested-job", frame_name="named-jobs",
        ) is restored
        print("Restore rebuilt named scopes with fresh IDs and retained the unnamed ancestor.")
        print("A new meld creates an empty notebook; earlier application data is not restored.")
    finally:
        restored_observer.cleanup()
        restored_root.permanent_cleanup()

Runnable examples

Named scopes in nexus and restore — Expert 38
A world that outlives its own runtime — Expert 27
Loading a whole world back — Expert 24
Pod boot the order is the product — Expert 01

All expert examples · Level contents · Full contents

Canonical page source