Structural operations and admission

Prerequisites: dynamic composition and room boundaries. Continue using public structural verbs such as bind, link, sever, transfer, and staged binding. Each owns its admission and bookkeeping; normal application code does not open an extra transaction around it.

Read and write paths have different jobs

The internal DevOps plane coordinates structural changes through scopes and claim modes. Resolution uses its own validity and creation gates. A failure at an admission or posture gate should be diagnosed at the boundary named by the error. The rewiring lesson demonstrates both a static world and a dynamic world whose posture explicitly disables linking.

A gate is more than a mutex

Stopping new entrants does not prove existing readers have left. The gate lesson distinguishes reversible disable/enable from terminal shutdown. It selects the raise entry policy for a single-threaded demonstration, disables admission, checks refusal, reopens the gate, and checks that the same validation call works.

For shutdown, it performs a bounded close_and_wait_rift(...) and checks the remaining active-thread count afterward. That count is a diagnostic, not a polling loop to use as a substitute for synchronization.

The concurrency guide demonstrates several rooms executing actual jobs against a shared target. Use the architecture reference for the internal coordination design behind these public operations.

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:
    # STEPS 1 AND 2: both conduits exist before anything is wired.
    owner_book = md.Spellbook(aetheric_frame="rewire-world")
    borrower_book = md.Spellbook(aetheric_frame="rewire-world")
    service_id = owner_book.bind(
        spell=Service, existence="unique", permissions="create",
        binding_name="rewire-service",
    )
    borrower_book.bind(
        spell=Consumer, existence="unique", permissions="create",
        binding_name="rewire-consumer",
    )
    owner = owner_book.conjure(dynamic=True, name="owner")
    borrower = borrower_book.conjure(dynamic=True, name="borrower")
    print("two conduits up, nothing wired between them yet")

    # The owner resolves its own spell. This works before any linking -
    # ownership and sharing are different questions.
    assert owner.meld("Service",
                      binding_name="rewire-service").label == "service"
    print("owner melds its own spell -> service")

    # STEP 3: link, now that both ends exist.
    assert owner.link(borrower) is True
    print()
    print("link() -> True")

    # STEP 4: the CONSUMER pulls. Naming `owner` here is not a style
    # choice - the conduit named must own the spell.
    assert borrower.add_spell_to_contract(
        spell_id=service_id,
        conduit=owner,
        permissions="create",
    )
    print("borrower pulled the owner's spell into its contract")
    print("  sharing is a PULL - the named conduit must OWN the spell")

    # STEP 5: meld completes the late binding across the new edge.
    borrowed = borrower.meld("Service", binding_name="rewire-service")
    assert borrowed.label == "service"
    print("borrower melds it ->", borrowed.label)
    print()
    print("the world was rewired while running, in three ordinary calls")

    # A WORLD TOLD NOT TO LINK REFUSES, AND SAYS WHY. This one IS
    # dynamic; it has simply been braked.
    braked_owner, braked_borrower = _pair(
        "rewire-braked", system_state="dynamic", disable_linking=True,
    )
    try:
        braked_owner.link(braked_borrower)
        raise AssertionError("expected a refusal: linking is braked")
    except RuntimeError as error:
        assert "posture" in str(error)
        print()
        print("braked world refused link() -")
        print("  ", error)

    # AN ORDINARY STATIC WORLD REFUSES TOO - and with the SAME sentence,
    # because the posture gate answers first and an unconfigured
    # non-dynamic frame is already "not allowed to link" to it.
    static_owner, static_borrower = _pair("rewire-static")
    try:
        static_owner.link(static_borrower)
        raise AssertionError("expected a refusal: static cannot link")
    except RuntimeError as error:
        assert "posture" in str(error)
        print()
        print("static world refused link() -")
        print("  ", error)
        print("  SAME sentence as the braked world: the message names the")
        print("  GATE that refused, not the property you had in mind")

    print()
    print("link, pull, meld - and the order is just dependency order")
    print("nothing here opens, holds, or commits anything by hand")

Runnable examples

Rewiring a running world — Expert 16
The gate that waits for readers — Expert 35

All expert examples · Level contents · Full contents

Canonical page source