Conclusion — what the patterns compose into

profile forge.world.core.v1

; ACTIVE LOCUS — where state, authority, observation and continuity couple. al_world is the book's ROOT
; CLOCK: the world's transition relation. al_locus carries state (a rotor), holds authority (configurable:
; it ACCEPTS runtime writes), al_view is what can be observed of it. Every later chapter is wired,
; directly or through routers, to this clock or to one of the book's other clock domains.
[pulser:al_world](every 1){sig_out}
[spinner:al_locus](w=16, n=8, rotor=quarter_turn_z, configurable){sig_in, socket}
[orb:al_view]{pose}

[al_world] --sig--> [al_locus]
[al_locus] --socket--> [al_view]

; RECORD AT A BOUNDARY — a record is a projection taken at a boundary; it never acts. rb_record has NO
; controller here: in the chain it is fed by chapter 1's locus. A pose is a record of a rotor at the socket.
[orb:rb_record]{pose}

; the record records chapter 1's locus, at the socket boundary — fan-out from one socket is unrestricted
[al_locus] --socket--> [rb_record]

; LOCUS IS NOT ITS CARRIER — one signal through three carriers; the locus's state is unchanged by which relay
; carried it. lc_thread is this chapter's ENTRY (open port); thread → core → machine are relays: replaceable
; embodiments — and, in the chain, ROUTERS other chapters draw from.
[relay:lc_thread]{sig_in, sig_out}
[relay:lc_core]{sig_in, sig_out}
[relay:lc_machine]{sig_in, sig_out}
[spinner:lc_locus](w=16, n=8, rotor=quarter_turn_z){sig_in, socket}
[orb:lc_view]{pose}

[lc_thread] --sig--> [lc_core]
[lc_core] --sig--> [lc_machine]
[lc_machine] --sig--> [lc_locus]
[lc_locus] --socket--> [lc_view]

; the root clock drives the carrier chain
[al_world] --sig--> [lc_thread]

; IDENTITY IS A SEAL — the named rotor `identity` is the unit; the world's id is the hash of this text's
; canonical form. is_in is the entry; in the chain it is fed by the machine router of chapter 3.
[relay:is_in]{sig_in, sig_out}
[spinner:is_seal](w=16, n=8, rotor=identity){sig_in, socket}
[orb:is_id]{pose}

[is_in] --sig--> [is_seal]
[is_seal] --socket--> [is_id]

[lc_machine] --sig--> [is_in]

; CONTINUITY THROUGH RECONSTRUCTION — a configurable locus whose state is RE-ESTABLISHED by a claim at
; epoch 2 (SetRotor, receipt Applied). ct_in is the entry; in the chain the core router of chapter 3 feeds it.
[relay:ct_in]{sig_in, sig_out}
[spinner:ct_locus](w=16, n=8, rotor=quarter_turn_z, configurable){sig_in, socket}
[orb:ct_view]{pose}

[ct_in] --sig--> [ct_locus]
[ct_locus] --socket--> [ct_view]

[lc_core] --sig--> [ct_in]

; REFUSING JOIN — a Door admits exactly one signal wire. rj_r is the entry AND Part II's router: in the chain
; it is fed by the machine router and feeds the composition chapters. The refused variant is beside this.
[relay:rj_r]{sig_in, sig_out}
[door:rj_join]{sig_in}

[rj_r] --sig--> [rj_join]

[lc_machine] --sig--> [rj_r]

; SHARED OBSERVABLE — the rotor determines the pose and is in the Film; a numeric fault on the orb is seeded
; as INITIAL runtime state and healed by ResetFault at epoch 3. so_in is the entry, fed by Part II's router.
[relay:so_in]{sig_in, sig_out}
[spinner:so_rotor](w=16, n=8, rotor=quarter_turn_z, configurable){sig_in, socket}
[orb:so_pose]{pose}

[so_in] --sig--> [so_rotor]
[so_rotor] --socket--> [so_pose]

[rj_r] --sig--> [so_in]

; SEMANTIC MEMBRANE — one rotor, two projections: the membrane exposes the pose and nothing of the rotor's
; representation. Fan-out from a socket is unrestricted. sm_in is the entry.
[relay:sm_in]{sig_in, sig_out}
[spinner:sm_inside](w=16, n=8, rotor=quarter_turn_z){sig_in, socket}
[orb:sm_outside_a]{pose}
[orb:sm_outside_b]{pose}

[sm_in] --sig--> [sm_inside]
[sm_inside] --socket--> {[sm_outside_a], [sm_outside_b]}

[rj_r] --sig--> [sm_in]

; CAPABILITY-BOUNDED COMPOSITION — cb_fixed is feasible to write to and NOT permitted (no `configurable`):
; the claim at epoch 1 is Rejected(not_configurable). cb_in fans out to the spinner and to the gate (a Door).
[relay:cb_in]{sig_in, sig_out}
[spinner:cb_fixed](w=16, n=8, rotor=quarter_turn_z){sig_in, socket}
[orb:cb_view]{pose}
[door:cb_gate]{sig_in}

[cb_in] --sig--> {[cb_fixed], [cb_gate]}
[cb_fixed] --socket--> [cb_view]

[rj_r] --sig--> [cb_in]

; CARRIER CONFINEMENT — the carrier (a Door) opens only through the grant (a relay); nothing else can reach
; its one input port. cc_grant is the entry and a router: chapters 11 and 12 draw from it.
[relay:cc_grant]{sig_in, sig_out}
[door:cc_carrier]{sig_in}

[cc_grant] --sig--> [cc_carrier]

[cb_in] --sig--> [cc_grant]

; PROJECTION, NOT DUPLICATION — pj_view_a and pj_view_b are both derived from pj_artifact through
; SocketControl; neither is a copy. pj_in is the entry, fed by the grant router.
[relay:pj_in]{sig_in, sig_out}
[spinner:pj_artifact](w=16, n=8, rotor=quarter_turn_z){sig_in, socket}
[orb:pj_view_a]{pose}
[orb:pj_view_b]{pose}

[pj_in] --sig--> [pj_artifact]
[pj_artifact] --socket--> {[pj_view_a], [pj_view_b]}

[cc_grant] --sig--> [pj_in]

; REFUSABLE DIVERGENCE — a claim naming a target the world does not have is Rejected(unknown_spinner) by
; name, with a receipt. rd_in is the entry, fed by the grant router.
[relay:rd_in]{sig_in, sig_out}
[spinner:rd_real](w=16, n=8, rotor=quarter_turn_z, configurable){sig_in, socket}
[orb:rd_view]{pose}

[rd_in] --sig--> [rd_real]
[rd_real] --socket--> [rd_view]

[cc_grant] --sig--> [rd_in]

; PROGRESS OVER UTILIZATION — TWO CLOCK DOMAINS: pu_busy fires every epoch into three relays that only
; relocate the signal; pu_progress fires every 2 and turns a rotor. Busy is not the same as admitted.
; pu_hop1 is also Part III's router in the chain.
[pulser:pu_busy](every 1){sig_out}
[relay:pu_hop*3]{sig_in, sig_out}
[door:pu_sink]{sig_in}
[pulser:pu_progress](every 2){sig_out}
[spinner:pu_locus](w=16, n=8, rotor=quarter_turn_z){sig_in, socket}
[orb:pu_admitted]{pose}

[pu_busy] --sig--> [pu_hop0]
[pu_hop0] --sig--> [pu_hop1]
[pu_hop1] --sig--> [pu_hop2]
[pu_hop2] --sig--> [pu_sink]
[pu_progress] --sig--> [pu_locus]
[pu_locus] --socket--> [pu_admitted]

; DORMANT BUT ALIVE — its OWN clock domain, with phase 3: the locus receives nothing for three epochs and is
; fully defined the whole time; at epoch 4 it turns. Dormant is a placement fact, not a liveness fact.
[pulser:db_clock](every 4, phase 3){sig_out}
[spinner:db_locus](w=16, n=8, rotor=quarter_turn_z){sig_in, socket}
[orb:db_view]{pose}

[db_clock] --sig--> [db_locus]
[db_locus] --socket--> [db_view]

; CARRIER MULTIPLEXING — the floor's signal arrives at cm_in (a router) and fans out to four slots (relays),
; each carrying to a locus (a Door that opens when its signal arrives). Replication `*4` is the language's own.
[relay:cm_in]{sig_in, sig_out}
[relay:cm_slot*4]{sig_in, sig_out}
[door:cm_locus*4]{sig_in}

[cm_in] --sig--> {[cm_slot0], [cm_slot1], [cm_slot2], [cm_slot3]}
[cm_slot0] --sig--> [cm_locus0]
[cm_slot1] --sig--> [cm_locus1]
[cm_slot2] --sig--> [cm_locus2]
[cm_slot3] --sig--> [cm_locus3]

; the busy clock's second hop is the floor's router
[pu_hop1] --sig--> [cm_in]

; PROGRESS-AWARE PLACEMENT — two homes (relays); the locus is placed on pp_homeB, where the signal reaches
; it. pp_homeA has nothing resident and nothing arrives: the fair home, idle. pp_in is the entry.
[relay:pp_in]{sig_in, sig_out}
[relay:pp_homeA]{sig_in, sig_out}
[relay:pp_homeB]{sig_in, sig_out}
[spinner:pp_locus](w=16, n=8, rotor=quarter_turn_z){sig_in, socket}
[orb:pp_view]{pose}

[pp_in] --sig--> [pp_homeB]
[pp_homeB] --sig--> [pp_locus]
[pp_locus] --socket--> [pp_view]

; slot 0 of the multiplexer routes to home B
[cm_slot0] --sig--> [pp_in]

; PROVEN QUIESCENCE — its OWN clock domain: pq_clock fires ONCE at epoch 2 and is then done; the signal is
; still travelling through two relays and opens the Door later. The pulser's silence is not completion.
; pq_b is a router: chapter 18 draws from the quiescence chain's last relay.
[pulser:pq_clock](once at 2){sig_out}
[relay:pq_a]{sig_in, sig_out}
[relay:pq_b]{sig_in, sig_out}
[door:pq_done]{sig_in}

[pq_clock] --sig--> [pq_a]
[pq_a] --sig--> [pq_b]
[pq_b] --sig--> [pq_done]

; THREE-VALUED OUTCOME — two claims in one batch: one Applied (tv_open is configurable), one Rejected
; (tv_fixed is not). The third value has no forge counterpart: a Film is total. tv_in is the entry.
[relay:tv_in]{sig_in, sig_out}
[spinner:tv_open](w=16, n=8, rotor=quarter_turn_z, configurable){sig_in, socket}
[spinner:tv_fixed](w=16, n=8, rotor=quarter_turn_z){sig_in, socket}
[orb:tv_a]{pose}
[orb:tv_b]{pose}

[tv_in] --sig--> {[tv_open], [tv_fixed]}
[tv_open] --socket--> [tv_a]
[tv_fixed] --socket--> [tv_b]

; the once-clock's chain, after it has gone quiet, is what this chapter's attempts ride on
[pq_b] --sig--> [tv_in]

; ORTHOGONAL PERSISTENCE — its OWN slow clock domain (every 3): the rotor persists between ticks without the
; locus asking to be saved; where the state physically lives between epochs is the runtime's business.
[pulser:op_clock](every 3){sig_out}
[spinner:op_locus](w=16, n=8, rotor=quarter_turn_z){sig_in, socket}
[orb:op_view]{pose}

[op_clock] --sig--> [op_locus]
[op_locus] --socket--> [op_view]

; THREE SIZES OF WORLD — this fragment is a WRL GRAPH (the smallest size). ts_version fires ONCE at epoch 3:
; a version is a root taken at an instant. The chain so far is the graph; its seal is a wrl_head.
[pulser:ts_version](once at 3){sig_out}
[door:ts_root]{sig_in}

[ts_version] --sig--> [ts_root]

; WORLD BOUNDARY — GAP. Nothing in the tree defines the boundary, so this fragment declares nothing: the
; EMPTY WORLD, which WRL seals. The chain's id does not move here — this comment is not meaning.

; MEANING IS A HASH — its OWN clock domain and a door; the variant beside this changes `every 3` to `every 4`
; and seals to a different id. There is no version number to consult.
[pulser:mh_clock](every 3){sig_out}
[door:mh_gate]{sig_in}

[mh_clock] --sig--> [mh_gate]

; EXACT REPLAY — its OWN clock domain into a relay chain and a Door; the runner reduces this world TWICE and
; the build refuses unless both runs produce identical Film hashes. er_a is Part V's router in the chain.
[pulser:er_clock](every 2){sig_out}
[relay:er_a]{sig_in, sig_out}
[relay:er_b]{sig_in, sig_out}
[door:er_player]{sig_in}

[er_clock] --sig--> [er_a]
[er_a] --sig--> [er_b]
[er_b] --sig--> [er_player]

; CROSS-MACHINE SKILL REPLAY — one signal, two machines (replicated relays), two doors that open at the same
; epoch. cx_in is the entry; the machines are `*2`; cx_machine0 routes on to Part V.
[relay:cx_in]{sig_in, sig_out}
[relay:cx_machine*2]{sig_in, sig_out}
[door:cx_replay*2]{sig_in}

[cx_in] --sig--> {[cx_machine0], [cx_machine1]}
[cx_machine0] --sig--> [cx_replay0]
[cx_machine1] --sig--> [cx_replay1]

[er_a] --sig--> [cx_in]

; CONFIDENTIALITY UNDER CONTENT ADDRESSING — OPEN. The ruling is about keys, not topology. This fragment is
; the empty world: nothing is declared until studbook §10.2 is ruled.

; ESTABLISHED, NOT KNOWN — an observation (en_in) passes through en_established before it can act on the
; Door. en_established is Part V's router: chapters 27 and 28 draw from it.
[relay:en_in]{sig_in, sig_out}
[relay:en_established]{sig_in, sig_out}
[door:en_act]{sig_in}

[en_in] --sig--> [en_established]
[en_established] --sig--> [en_act]

[cx_machine0] --sig--> [en_in]

; STATE DOES NOT GRANT AUTHORITY — sd_state has state (a rotor) and no grant (not configurable). The claim at
; epoch 1 is Rejected(not_configurable). sd_in is the entry, fed by the established router.
[relay:sd_in]{sig_in, sig_out}
[spinner:sd_state](w=16, n=8, rotor=quarter_turn_z){sig_in, socket}
[orb:sd_view]{pose}

[sd_in] --sig--> [sd_state]
[sd_state] --socket--> [sd_view]

[en_established] --sig--> [sd_in]

; EVIDENCE BEFORE CLAIM — a claim at epoch 2 becomes a receipt with an outcome, in the Film, before anything
; downstream may cite it. ec_in is the entry and a router (chapter 29 draws from it); ec_ledger is a Door
; with an open port the chain feeds from the root clock.
[relay:ec_in]{sig_in, sig_out}
[spinner:ec_subject](w=16, n=8, rotor=quarter_turn_z, configurable){sig_in, socket}
[orb:ec_witness]{pose}
[door:ec_ledger]{sig_in}

[ec_in] --sig--> [ec_subject]
[ec_subject] --socket--> [ec_witness]

[en_established] --sig--> [ec_in]
; the ledger is fed by chapter 1's root clock: the same transition relation, one wire, one port
[al_world] --sig--> [ec_ledger]

; REFUSAL GATE — the page is a Door; material must pass rg_sufficiency (a relay, and a router) to open it.
; rg_in is the entry, fed by the evidence router.
[relay:rg_in]{sig_in, sig_out}
[relay:rg_sufficiency]{sig_in, sig_out}
[door:rg_page]{sig_in}

[rg_in] --sig--> [rg_sufficiency]
[rg_sufficiency] --sig--> [rg_page]

[ec_in] --sig--> [rg_in]

; INTERVENTION PROVENANCE — two writers (w=7, w=9) intervene on the same locus; every receipt names its writer
; and sequence. ip_in is the entry, fed by the sufficiency router.
[relay:ip_in]{sig_in, sig_out}
[spinner:ip_world](w=16, n=8, rotor=quarter_turn_z, configurable){sig_in, socket}
[orb:ip_view]{pose}

[ip_in] --sig--> [ip_world]
[ip_world] --socket--> [ip_view]

[rg_sufficiency] --sig--> [ip_in]

; DESCENT IS NOT DEPENDENCE — dd_child is fed by the same router as dd_parent (it descended from the same
; world). A claim sets the parent's rotor at epoch 2; the child's rotor does not move. dd_in is the entry.
[relay:dd_in]{sig_in, sig_out}
[spinner:dd_parent](w=16, n=8, rotor=quarter_turn_z, configurable){sig_in, socket}
[spinner:dd_child](w=16, n=8, rotor=quarter_turn_z, configurable){sig_in, socket}
[orb:dd_pv]{pose}
[orb:dd_cv]{pose}

[dd_in] --sig--> {[dd_parent], [dd_child]}
[dd_parent] --socket--> [dd_pv]
[dd_child] --socket--> [dd_cv]

[rg_sufficiency] --sig--> [dd_in]

; UNDERSTANDING BOUNDARY — two writers claim the same locus in one batch; both are Applied and the later
; canonical wins; the Film's `recognition:` lines are the register between observed and believed. ub_in is
; the entry — the last module on the board, fed by the descent router.
[relay:ub_in]{sig_in, sig_out}
[spinner:ub_locus](w=16, n=8, rotor=quarter_turn_z, configurable){sig_in, socket}
[orb:ub_view]{pose}

[ub_in] --sig--> [ub_locus]
[ub_locus] --socket--> [ub_view]

[dd_in] --sig--> [ub_in]