Hyperedges

A hyperedge is one identified relation with named participant roles and ordinals. Binary relationships are the two-participant case. A junction card exposes the roles; it is not another computation node.

Start with Pub/Sub delivery, notification merge, required-read joins, asset races, partition routing, authorization and permission versus lineage.

Role positions and laws

An incidence is (nodeId, portId, role, ordinal). A relation schema declares permitted roles, multiplicity, compatible port contracts, symmetry, eligibility and operational outcomes. Swapping quorum voters may be permitted; swapping caller and callee is not. Multiple incidences at one endpoint preserve multiplicity rather than collapsing to set membership.

The current definition validator checks endpoint existence and unique role/ordinal slots. It does not prove quorum intersection, transaction isolation, race cancellation, subscription durability or protocol correctness. Runtime adapters and versioned dialect verifiers must establish those laws before admission.

Laws, constraints and compositions

Consolidation decisions

Keep merge-any, join-all, race, barrier and quorum separate because they admit different outcomes. Keep authority, capability, ownership, placement and provenance separate even when each diagram has two participants. Represent replication, routing, supervision, cohorts, migration and navigation as profiles/compositions over explicit operators and constraints. H32 names operands around a computation node; H33 names candidates around a choice operator. Neither becomes a hidden universal executor.

Retire H34 as a combined executable type: a read grant cannot establish origin, and provenance cannot confer permission. Its diagram separates H23 and H27 and retains the legacy ID as an annotation. W3C PROV distinguishes origin records from authority; Reaktor must preserve that distinction.

Concrete adapters and domain scope

The GCP subscription model gives each subscription its own delivery/acknowledgement behavior; a topic is a resource node and a subscription relation binds it to consumers. Actor supervision separates restart decisions from durable state recovery. RouteNode navigation composes route state, typed payloads and lifecycle; FFI/RPC crossings retain explicit adapter and authority boundaries.

The diagrams cover app composition, web requests, distributed coordination, release tooling, native memory and sensor clocks. Domain labels select profiles and implementations rather than expanding the kernel into a new kind for every business feature.

H01 · Exclusive binding — Bind a repository to a real service or a mock

Which implementation supplies this required endpoint?

Domains and use cases: dependency wiring, mobile, services.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: The profile repository requires one compatible read endpoint per activation. The test scenario binds a mock while the mobile activation binds the real service. Candidate offers remain visible without becoming simultaneous providers of an exclusive binding.

Concrete module/design guide · Definition JSON · revision 724e156412f6

Laws and limits:

• Reject a second provider where exclusivity is required; dispatch can compile to a direct call.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Exclusive binding selects a supplier; it neither invokes the operation nor provides a failover policy.

H02 · Value flow — Calculate invoice totals from line items

Which data feeds which calculation?

Domains and use cases: computation, media, analytics.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: Line items and discount policy feed the subtotal calculation. Tax calculation consumes that result and its jurisdiction input; the invoice combines both. Data flow exposes inputs while effectful persistence remains a separate call.

Concrete module/design guide · Definition JSON · revision 4b66899f268b

Laws and limits:

• Copy/fanout is legal only for the value ownership profile; units and schemas must match.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• A value-flow incidence identifies data dependencies, not transaction scope or an effect schedule.

H03 · Control precedence — Remove user data in a safe order

Which operations must complete before account closure?

Domains and use cases: workflows, build, releases.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: The deletion workflow freezes new writes, removes scoped assets and records data removal before closing the account. It records receipts for each step and can resume after failure. The order is explicit control precedence rather than implied by card placement.

Concrete module/design guide · Definition JSON · revision e04fda72b929

Laws and limits:

• Defines ordering under a named profile; does not serialize unrelated graph layers.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• The product must separately define retention exceptions and scope; sequencing does not prove every data copy was deleted.

H04 · Event subscription — Process order events with dead-letter handling

Who owns acknowledgement and retry?

Domains and use cases: PubSub, messaging, IoT.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A GCP Pub/Sub subscription delivers order events to a worker. Successful business commit precedes its acknowledgement; exhausted failures enter an explicit dead-letter path. Topic resource, subscription and worker have distinct identities and contracts.

Concrete module/design guide · Definition JSON · revision 48d2f5d205fc

Laws and limits:

• Subscriptions name filters, replay and delivery rules; broker resources remain separate nodes.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Broker delivery guarantees are scoped to the subscription configuration; external writes need their own idempotency.

H05 · Request / reply binding — Load a profile with a deadline

Which caller is paired with which reply?

Domains and use cases: RPC, web, distributed systems.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A screen invokes a typed profile service through an RPC binding. The server reads the profile authority and returns a revisioned response. A deadline bounds the caller's wait; correlation keeps a late reply from replacing a newer screen request.

Concrete module/design guide · Definition JSON · revision 210389a98ff6

Laws and limits:

• Protocol includes correlation, failure and unknown outcomes; transport is chosen independently.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• RPC binding names correlation and outcomes; it does not mean the network is reliable or the call is authorized.

H06 · Multiparty session — Coordinate a multiplayer match session

Which participants share one protocol?

Domains and use cases: games, collaboration, messaging.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: Players and the authoritative match host participate in a session protocol with join, ready, input and acknowledgement phases. The lobby admits identities; a disconnected participant has a declared timeout path. Session roles retain player positions rather than reducing to unrelated pairwise wires.

Concrete module/design guide · Definition JSON · revision a02888748de2

Laws and limits:

• Single relation identity with role/cardinality checks; delivery comes from an explicit protocol.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Multiparty membership does not establish a session-type proof; protocol validation must include allowed phase transitions.

H07 · Broadcast / fanout — Invalidate caches after a configuration change

Which recipients must see the same occurrence?

Domains and use cases: PubSub, notifications, telemetry.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A committed configuration event fans out to web, mobile and server caches. Each cache applies the version independently and can acknowledge or reread current configuration. A fanout relation does not mean all recipients advance atomically.

Concrete module/design guide · Definition JSON · revision 44198f03a742

Laws and limits:

• State whether delivery waits for all, any or no receivers; slow receivers need a policy.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Fanout preserves one occurrence with multiple recipients; acknowledgement and failure are per participant.

H08 · Merge-any — Merge notification sources into one inbox

What happens when either source has a new item?

Domains and use cases: telemetry, IoT, streams.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: Push delivery and local reminders both feed an inbox merge. The merger emits each admitted item without waiting for the other source and deduplicates by notification identity. Its output updates current inbox state.

Concrete module/design guide · Definition JSON · revision 447299099895

Laws and limits:

• Specify interleaving, fairness and order; merging is not a join of corresponding values.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Merge-any emits admitted arrivals; it is not first-winner cancellation or join-all readiness.

H09 · Join-all — Assemble a profile from required reads

Which results must all be present?

Domains and use cases: media, workflows, parallel work.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: Profile and relationship reads are both required for the full header. A join combines their named results after checking revision context. Optional recommendations use a separate path and do not change the join's readiness law.

Concrete module/design guide · Definition JSON · revision 8e6a0638b8a9

Laws and limits:

• Align values by invocation/key; define failure, timeout and missing-input treatment.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Join-all requires the declared participants and failure policy; it does not create cross-service snapshot consistency.

H10 · Race / select — Race mirrors for an asset

Which valid response wins and what happens to losers?

Domains and use cases: services, latency, capability selection.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: Two asset mirrors compete to supply bytes for the same digest. The race accepts the first verified result and cancels remaining reads; invalid bytes cannot win merely by arriving first. The selected asset is handed to rendering.

Concrete module/design guide · Definition JSON · revision 173c545d7ec6

Laws and limits:

• Define first-completion versus first-success and cleanup/reconciliation of losing effects.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Winner eligibility, deadline and loser cancellation are race laws; arbitrary first arrival is not necessarily a valid result.

H11 · Keyed temporal join — Match payments with orders by time and key

How are late or unmatched records handled?

Domains and use cases: analytics, telemetry, IoT.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A reconciliation operator joins order and payment events by order ID within a declared time window. Watermark and late-event rules produce matched records or explicit exceptions. Matching timestamps alone cannot establish causality.

Concrete module/design guide · Definition JSON · revision a93614315f0d

Laws and limits:

• State key, clock, lateness/watermark and window policy; topology alone cannot pair records.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Key, window, watermark, duplicate and late-data policy are required parts of this profile.

H12 · Barrier / synchronization — Start a match after all players are ready

How does a phase advance without double-starting?

Domains and use cases: games, releases, distributed systems.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A barrier accepts readiness from the admitted player set for one match epoch. It releases the start phase only when the set is complete, or aborts under the timeout policy. Readiness from a previous epoch does not count.

Concrete module/design guide · Definition JSON · revision d3e9f3442fe1

Laws and limits:

• Specify membership epoch, arrival condition and failure handling; no hidden global clock.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Barrier synchronizes a named phase and membership epoch; unlike a value join it may repeat across phases.

H13 · Quorum requirement — Approve a replicated write with a quorum

Which votes count for this term?

Domains and use cases: distributed systems, replication, coordination.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: Three voters provide term-bound acknowledgements to a coordinator. A write becomes accepted only under the stated quorum and membership law. A receipt includes term and log position; it is not inferred from drawing a majority.

Concrete module/design guide · Definition JSON · revision cad8224462a6

Laws and limits:

• Names a qualified protocol and membership; counting votes alone does not implement consensus.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Threshold, eligible membership and failure assumptions must be specified; quorum edges alone do not implement consensus.

H14 · Replica group — Read from a replica group with explicit consistency

Which replica may serve this read?

Domains and use cases: offline mobile, data, distributed systems.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: Replica-group membership supplies candidates and their applied positions. A routing decision chooses an eligible replica for the requested read cut; the leader remains the write authority. Placement and quorum constraints are separate from group membership.

Concrete module/design guide · Definition JSON · revision ea48fac4abcc

Laws and limits:

• Replication/merge and fencing rules are explicit; schema does not create consistency.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Replica group is a composition profile; it needs consistency and membership rules and is not interchangeable with quorum.

H15 · Partition / route — Route conversations to partitions

Who owns a key during repartitioning?

Domains and use cases: distributed systems, tenancy, IoT.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: The router maps a conversation key through a partition map revision to its owner. Epoch fencing rejects stale routes during handoff. The relation names assignment; hash or range logic stays in the router's Kotlin implementation.

Concrete module/design guide · Definition JSON · revision ab3145279ee8

Laws and limits:

• Specify key function, assignment epoch and resharding; preserve owner and replay semantics.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Partition assignment does not migrate state; routing algorithm, map revision and fencing are explicit.

H16 · Atomic authority scope — Commit a membership and its audit row together

What lies inside the atomic authority scope?

Domains and use cases: transactions, commerce, data.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: The membership operation writes the membership row and audit row under one database transaction authority. Email dispatch follows the commit receipt outside the scope. A shared region frame cannot substitute for the transaction relation.

Concrete module/design guide · Definition JSON · revision d8f036275f79

Laws and limits:

• ACID applies only where that authority/profile implements it; not across arbitrary stores.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Atomicity is supplied by a named authority and isolation contract; external services are excluded.

H17 · Compensation relation — Refund after fulfilment cannot complete

How is a completed business effect compensated?

Domains and use cases: commerce, workflows, external effects.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: The order saga records a successful charge before attempting fulfilment. Failure proposes a refund linked to that charge receipt; reconciliation records refund completion or review-required state. Compensation does not erase the original payment history.

Concrete module/design guide · Definition JSON · revision c6cad3f8712c

Laws and limits:

• Compensation is a new effect with its own failure modes, not automatic historical erasure.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Compensation is a later authorized effect with its own failure law, not transactional rollback.

H18 · Supervision — Restart a failed worker without duplicating its work

Who decides restart and owns the child lifetime?

Domains and use cases: actors, games, services.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A supervisor observes worker failure and selects restart, stop or escalation. The durable job authority retains command state across restart. Child ownership and restart policy remain separate contracts.

Concrete module/design guide · Definition JSON · revision 3dcd7c543cf2

Laws and limits:

• Specify restart budget, state/ownership effects and host-death behavior.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Supervision is a lifecycle composition; restarting code does not repair corrupted state or roll back external effects.

H19 · Ownership / containment — Own resources inside a feature scope

Which parent releases a session and its buffers?

Domains and use cases: nested graphs, resources, FFI.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A conversation scope owns its subscription, native decoder handle and attachment lease. Child lifetime cannot outlive the scope without an explicit transfer. Graph containment may organize the same objects but does not automatically define resource ownership.

Concrete module/design guide · Definition JSON · revision ec15b1aaf5f9

Laws and limits:

• Selected ownership relation is acyclic; visual grouping is not ownership.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Ownership is a lifetime law; neither layout grouping nor placement expresses it.

H20 · Instantiation — Instantiate a reusable tenant service

Which definition creates which activation?

Domains and use cases: games, actors, tenancy.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A tenant factory creates service instances from one reusable definition. Each instance binds tenant-scoped state and its own activation ID. A registry prevents an accidental duplicate active lease for the same tenant.

Concrete module/design guide · Definition JSON · revision a8f762afba37

Laws and limits:

• Fresh activation identities and scopes; shared definitions are not shared mutable instance state.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Definition identity, tenant identity and activation identity are separate; instantiation is not ownership or placement.

H21 · Placement — Place an image worker near storage

Where may this execution run?

Domains and use cases: cloud, distributed systems, FFI.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A worker requires a target, capacity and data-locality profile. Placement assigns it to a compatible host; object-store access is a separate service binding. The assignment is desired state until an activation receipt confirms it.

Concrete module/design guide · Definition JSON · revision 9142f2899f68

Laws and limits:

• A plan expresses intended placement; observations separately establish what actually runs.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Placement neither grants data access nor proves locality, capacity or runtime health unless checked and observed.

H22 · Affinity / separation — Separate primary and backup across zones

Which shared failures must be excluded?

Domains and use cases: cloud, robotics, resource planning.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: Primary and backup placements name their failure domains. A separation constraint rejects a plan that places both in one zone, even if capacity is available. Replication behavior remains a separate relation and implementation.

Concrete module/design guide · Definition JSON · revision 4900acac70a9

Laws and limits:

• Co-location, anti-affinity or memory-domain rule is a constraint, not an executable wire.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Affinity and separation are constraint profiles; zone labels need trusted host facts and a declared failure model.

H23 · Scoped authorization — Restrict a docs graph to one principal

Which resources are admitted into the readable cut?

Domains and use cases: RBAC, agents, tenancy.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: Authorization relates a principal-bound grant to collection, sections and allowed operation. Retrieval applies it before graph expansion, including indirect links. The visible subgraph records the resulting cut but is not an independent authorization engine.

Concrete module/design guide · Definition JSON · revision 7f6f2f18b697

Laws and limits:

• Decision is tied to action/context; visual reachability neither proves nor grants access.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Authorization is distinct from capability discovery and navigation visibility; every sensitive effect rechecks its scope.

H24 · Capability resolution — Select a map renderer without platform conditionals

Which offer satisfies the required interaction contract?

Domains and use cases: capabilities, AI, mobile.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A feature declares a map-rendering requirement. Resolution compares browser and desktop offers by target, formats and interaction contract, then supplies one selected binding. Authority to read graph data is evaluated separately.

Concrete module/design guide · Definition JSON · revision 97c42148fc23

Laws and limits:

• Filter hard constraints and grants before preferences; pin or safely migrate running sessions.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Resolution checks compatibility; it is not an authorization grant, placement plan or fallback execution engine.

H25 · Implements / source ownership — Link a graph service to its source implementation

Which code owns this declared operation?

Domains and use cases: RGL, source publication, agents.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A source-ownership relation connects the messaging endpoint with its common Service contract and target handler. Source navigation uses that linkage at a revision. A runtime trace additionally needs source maps and activation evidence.

Concrete module/design guide · Definition JSON · revision 7172620fefc9

Laws and limits:

• Exactly one edit authority per region; generated projections are not independently editable truth.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Implementation linkage is a revisioned descriptive relation, not proof of behavior or deployment.

H26 · Artifact dependency — Build only artifacts affected by a contract edit

Which dependencies invalidate this build?

Domains and use cases: build, releases, code push.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A contract change invalidates dependent client and server codecs and their release manifest. Dependency relations retain artifact identities; the build system determines the transitive affected cut. Source derivation and compatibility evidence are separately recorded.

Concrete module/design guide · Definition JSON · revision 1b43f05fc39d

Laws and limits:

• Pin semantic/artifact revisions; cosmetic layout changes need not invalidate code.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Dependency is not provenance, execution order or semantic compatibility; those require their own laws.

H27 · Derivation / provenance — Trace a PDF to the exact docs revision

Which sections and renderer produced these bytes?

Domains and use cases: visitors, compilers, telemetry.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A PDF export derives from a section cut and render configuration. Its record names document revisions and the output digest. Later edits do not silently change the exported artifact's provenance; retrieval can cite both the live section and exported revision.

Concrete module/design guide · Definition JSON · revision 9bc1a246ffba

Laws and limits:

• Results carry input cut and transform version; unknown dependencies widen invalidation.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Provenance describes origin; it does not grant access or prove document correctness.

H28 · Evidence supports claim — Support an end-to-end latency claim

Which evidence justifies the stated budget?

Domains and use cases: Shadow, verification, releases.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A performance claim cites a bounded run, target revision and sampled latency distribution. Missing segments and clock assumptions are part of that support. A claim without matching evidence remains unknown or unqualified.

Concrete module/design guide · Definition JSON · revision 4dc5fb33e625

Laws and limits:

• Scope assumptions and coverage; evidence does not promote or authorize itself.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Supports-claim is not logical implication outside its assumptions and coverage.

H29 · Activation cohort — Activate a compatible client/server cohort

Which revisions must be admitted together?

Domains and use cases: releases, code push, distributed systems.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A cohort names a client contract, server implementation and state schema that are checked together for a release. Admission verifies compatibility before traffic routing; mixed-version rollout has an explicit policy. Cohort membership alone does not activate anything.

Concrete module/design guide · Definition JSON · revision 41e7375f2507

Laws and limits:

• Local root publication can be atomic; cross-host realization is recoverable coordination.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Cohort is a release composition with admission rules; it is not a synonym for transaction scope.

H30 · Boundary export / alias — Export a feature endpoint through a nested graph

Which internal endpoint does the boundary expose?

Domains and use cases: nested graphs, FFI, composition.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A conversation graph exports message state and send through explicit aliases. The parent binds those exports to presentation. Crossing HTTP still uses a service adapter; an alias preserves endpoint identity but supplies no transport.

Concrete module/design guide · Definition JSON · revision e1afe2396bbf

Laws and limits:

• Preserve role, ownership and protocol when hiding/expanding a reusable region.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Export/alias requires compatibility and source ownership; it must not erase authority, memory or process boundaries.

H31 · Clock / time alignment — Align camera and IMU observations

What uncertainty remains when clocks differ?

Domains and use cases: telemetry, robotics, Shadow.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A time-mapping relation records the camera and IMU clock domains and calibration evidence. Sensor fusion consumes timestamped observations with uncertainty bounds. It rejects samples outside the accepted alignment budget instead of comparing raw timestamps as one clock.

Concrete module/design guide · Definition JSON · revision b140be2149b4

Laws and limits:

• Alignment needs a defined transform/uncertainty; timestamps do not establish causal order.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Clock alignment is a constraint with uncertainty; it is not a delivery barrier or a shared physical clock.

H32 · Tensor / algebraic operation — Apply a transform to a batch of positions

Where does the algebra execute?

Domains and use cases: AI, media, robotics.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: The operand relation names matrix, position batch and result roles around an explicit Kotlin transform node. The node implements shape, precision and memory behavior; the relation records those roles without becoming a hidden tensor runtime.

Concrete module/design guide · Definition JSON · revision 83ed680cac08

Laws and limits:

• Validate axes, units and device layout; computation belongs to the qualified implementation.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Algebraic pattern is a domain profile; arbitrary algorithms stay in Kotlin/common or qualified foreign implementations.

H33 · Fallback / preference set — Prefer cached content and fall back to network

What makes a fallback eligible?

Domains and use cases: offline mobile, services, capabilities.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: The choice operator tries a cache only when its freshness satisfies the request, then uses the network path. Failure and cancellation policy are explicit. The preference relation names candidates while Kotlin logic implements the choice.

Concrete module/design guide · Definition JSON · revision 2f2999dadbaf

Laws and limits:

• Fallbacks must remain eligible and authorized; never silently relax mandatory privacy or safety.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Preference/fallback is composition, not merge-any or a race; candidate eligibility and ordering are explicit.

H34 · Data access / lineage — Separate permission from data lineage

Why must an access grant and derivation be two relations?

Domains and use cases: data, lineage, tenancy.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A report query receives an authorized read grant, then derives a report from a selected source cut. The legacy H34 annotation groups the topic for navigation only. Authorization uses H23 and lineage uses H27, because origin never grants access and access never proves origin.

Concrete module/design guide · Definition JSON · revision 04fb9a5ee514

Laws and limits:

• Records the modeled access scope; enforce at actual storage boundary and disclose opaque access.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Retire H34 as an executable combined type; retain its reference ID and decompose declarations into access and provenance.

H35 · State migration — Hand off a partition with fenced writers

Who may write after state transfer?

Domains and use cases: code push, data, migrations.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: The old owner drains at a cut, the candidate restores compatible state, and the authority advances the ownership epoch. Requests carrying an old epoch are rejected. Transfer evidence records both revisions and cut so an incomplete handoff is visible.

Concrete module/design guide · Definition JSON · revision 75076e44c27d

Laws and limits:

• Version checkpoints, fence writers and validate postconditions; inverse may not exist.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• State migration is an orchestrated profile with fencing and compatibility, not a guarantee supplied by an edge kind.

H36 · Navigation / interaction route — Navigate from a list to a detail screen and back

What carries route state and return data?

Domains and use cases: navigation, Compose, deep links.

Diagram legend. Frames are named graph regions. Left/right pins show required/offered participation, not a universal schedule. Filled pins are connected; hollow pins are unbound. A junction card preserves one relation's role slots.

Reaktor mapping: A list interaction invokes RouteNode push with the selected item. routeBinding supplies detail presentation and navBinding supplies host navigation. Editing returns a versioned result through back(return), which refreshes list state; Compose binds those contracts without a parallel navigation store.

Concrete module/design guide · Definition JSON · revision d0cfe6b9fe7b

Laws and limits:

• Choose destination with guards and grants; back-stack and cancellation semantics are explicit.
• The junction is a rendering of this relation and its incidence slots; it is not a new executable broker or computation node.
• Navigation is a domain composition over state, control and lifecycle; entering a route does not grant backend authority.