Ownership Matrix¶
Type: Reference The single source for "where does X live?" — every contract surface in re-frame2 has exactly one canonical home; other docs may reference the surface, but those references are informational and must not redefine the contract. Use this matrix to navigate, and to detect drift if a definition ever appears in a non-owning doc.
Every contract surface in re-frame2 has exactly one canonical home. Most canonical homes live in the /spec tree — that is the language-agnostic pattern. A small, deliberate set of contract surfaces has an external canonical home outside /spec, sanctioned by README §Canonical homes outside /spec): a tool-shared contract whose home stays with the tool artefact (tools/<tool>/spec/), or a CLJS-reference binding of a pattern-level obligation that ships in the implementation tree (implementation/...). External-home rows are flagged in the table below; they are indexed from this matrix even though they live elsewhere.
Other docs may reference any surface, but those references are non-normative — they cite the canonical home rather than redefining the contract. The "Referenced in" column lists those informational mentions.
Host scope. The pattern itself is scoped to the eight in-scope JS-cross-compile hosts defined in 000 §The pattern. Companion-doc rows below describe pattern-level contracts; non-target server-side hosts (Python, Ruby, Rust, server-side Kotlin / Java / Swift) are out of scope as first-class implementation targets, and surfaces that look "host-specific" are scoped to those eight.
The Artefact column names the Maven artefact that ships the surface in the CLJS reference. Surfaces marked core (split pending: <bead>) are currently in day8/re-frame2 and will move to day8/re-frame2-<feature-id> under the named bead (the concrete id is in the Artefact cell of each such row). The packaging architecture (artefact tiers, naming, independence rule) is normative in Conventions §Packaging conventions.
| Contract surface | Canonical home spec | Artefact | Referenced in (informational) |
|---|---|---|---|
| Goals, hard constraints, host-profile matrix, identity primitive, minimal-core contract | 000-Vision | spec-only (no runtime artefact) | Principles, Implementor-Checklist, API |
Registration grammar (reg-* shape, metadata map, single superset metadata-map middle slot carrying :interceptors — there is no positional interceptor vector) |
001-Registration | day8/re-frame2 (core) |
API, Spec-Schemas §:rf/registration-metadata, Construction-Prompts |
Registry kind taxonomy (the canonical kind keyword set) |
001-Registration | day8/re-frame2 (core) |
API, Spec-Schemas |
| Source-coordinate capture (macro-driven, CLJS reference) | 001-Registration | day8/re-frame2 (core) |
Tool-Pair, 009-Instrumentation (trace events carry coords) |
| Hot-reload semantics for registrations | 001-Registration | day8/re-frame2 (core) |
002-Frames (sub-cache invalidation) |
Registry query API (registrations, handler-meta, frame-ids, frame-meta — registrar contract) |
001-Registration | day8/re-frame2 (core) |
002-Frames §The public registrar query API (re-tabulates alongside frame-runtime queries), Tool-Pair, 007-Stories |
Frame-runtime queries (app-db-value, frame-state-value, sub-topology, sub-cache) |
002-Frames | day8/re-frame2 (core) |
Tool-Pair, 008-Testing |
| Frame model, identity, lifecycle, carried-frame target resolution (EP-0002) | 002-Frames | day8/re-frame2 (core) |
API, Spec-Schemas |
Event handlers — reg-event, the one public event-registration form (coeffects in, a closed effects-map out; the two-arg (coeffects, event) → effects-map contract; there is no reg-event-db / reg-event-fx / reg-event-ctx) |
002-Frames | day8/re-frame2 (core) |
001-Registration (:event kind + the retired event-registration names), API, Construction-Prompts CP-1, Pattern-AsyncEffect |
Dispatch envelope (dispatch, dispatch-sync, explicit-frame addressing, two-arg form) |
002-Frames | day8/re-frame2 (core) |
API, Tool-Pair |
subscribe (frame-bound and global forms; reg-sub registration surface) |
002-Frames | day8/re-frame2 (core) |
006-ReactiveSubstrate (the runtime cache & derivation graph the surface consumes), API, Construction-Prompts CP-2 |
| Subscription runtime — derivation graph, sub-cache, invalidation, change tracking, layer-1/2/3 semantics | 006-ReactiveSubstrate | day8/re-frame2 (core) |
002-Frames (registration & call-site surface), 008-Testing (compute-sub) |
Projection-equality pattern-contract — one physical frame-state container + two cached partition-projection reactions (app-db / runtime-db); the per-partition propagation rules (runtime-only / app-only / both commits) that fall out of make-derived-value's memoised equality |
006-ReactiveSubstrate §Frame-state container and partition projections | day8/re-frame2 (core) |
002-Frames (the two-partition frame contract states the split and defers the substrate mechanism here) |
subscribe-once (one-shot, non-reactive read; subscribe + deref + immediate unsubscribe) |
006-ReactiveSubstrate | day8/re-frame2 (core) |
API, 002-Frames (call-site surface), 008-Testing (compute-sub for the cache-bypassing pure equivalent) |
unsubscribe (explicit teardown; ref-count decrement; pairs with imperative subscribe) |
006-ReactiveSubstrate | day8/re-frame2 (core) |
API, 002-Frames (call-site surface) |
Internal observation port — the six-operation adapter-internal seam over the sub-cache (resolve-target / probe / acquire! / current? / read / release!): the observation-target / probe-evidence / lease value shapes (a target is stable identity, never a node handle; a lease is an owner token; static Story-override leases report :owned? false), the six frozen invariants, the port-abi-version load guard, and the fail-loud error contract (:rf.error/no-such-sub, :rf.error/frame-destroyed, :rf.error/read-after-release, :rf.error/reentrant-graph-op, :rf.error/observation-port-version-mismatch). INTERNAL — outside the closed public adapter contract; no feature predicate; not facade-exported |
006-ReactiveSubstrate §The internal observation port | day8/re-frame2 (core) — re-frame.substrate.observation; sole consumer is the day8/re-frame2-ui view runtime (lockstep release train + ABI guard) |
009-Instrumentation (the port's five error-catalogue rows), Conventions §Internal cross-artefact seams (packaging posture) |
frame-provider / frame-root (CLJS reference; two per-adapter React-context components, one verb each — rf2-nyea0r split; roots ensure; providers scope. frame-provider {:frame …} SCOPE-only plumbs an already-created frame id to a subtree (fails loud if absent); frame-root {:id …} ENSURE — a commit-owned two-pass boundary — creates-if-absent (in a useLayoutEffect) / reuses-no-reseed / provides id, no destroy-on-unmount; takes make-frame opts; per EP-0024 amended) |
002-Frames | day8/re-frame2 (core) |
004-Views, 007-Stories |
Effect-map shape (closed top-level set #{:db :fx :rf.db/runtime} — :rf.db/runtime reserved, framework-authority only, per EP-0018) |
002-Frames | day8/re-frame2 (core) |
Spec-Schemas §:rf/effect-map, API |
Effects (reg-fx) |
002-Frames | day8/re-frame2 (core) |
API, Pattern-AsyncEffect, 011-SSR (:platforms) |
Coeffects — the reg-cofx registrar contract (value-returning supplier; the ambient / recordable grades, :recordable? true / :provided? true) and the :rf.cofx/requires declaration key (EP-0017) |
001-Registration §Coeffects (registrar contract + grades + :rf.cofx/requires) |
day8/re-frame2 (core) |
002-Frames §Recordable coeffects (the flat :rf.cofx envelope field + delivery), API, Spec-Schemas §:rf/cofx-meta / §:rf.cofx/requires, 011-SSR (:platforms) |
| Run-to-completion drain semantics | 002-Frames | day8/re-frame2 (core) |
005-StateMachines (drain interaction), 008-Testing (synchronous triggers) |
Registered interceptors — reg-interceptor (the :interceptor registry kind: named full-context context -> context behaviour, referenced by id from event / frame :interceptors chains); the framework-standard [:rf.interceptor/path …] reference (EP-0022) |
001-Registration §Interceptors (registrar kind + descriptor + metadata) | day8/re-frame2 (core) |
002-Frames §Registered interceptors and the chain grammar (by-reference chains + overrides + standard :rf.interceptor/path), API, 009-Instrumentation |
Per-frame and per-call overrides (:fx-overrides, :interceptor-overrides, :interceptors) |
002-Frames | day8/re-frame2 (core) |
008-Testing, 007-Stories |
| Machines-as-event-handlers foundation hooks | 002-Frames | day8/re-frame2 (core) |
005-StateMachines (full grammar) |
View contract — ui/defview (pure (props) → template), the template grammar + the portability law (one normalized AST → two emitters), handlers-as-data, sub / local / effect / lease, presence, interop, the JVM structural subset, hot reload, and the removed-forms absences. [TRANSITION] the frozen reg-view family + Form-1/2/3 ship in day8/re-frame2-reagent (and the UIx/Helix/slim adapters) until the S7 deletion wave; their live contract relocates to spec/004A-Reagent-Compat.md then. |
004-Views | day8/re-frame2-ui |
API, 004B-UI-Tree-and-Conversion, 004C-Roots-and-Mount, 008-Testing, 011-SSR, Construction-Prompts CP-4 |
Ephemeral view-state placement rule (default app-db; the local tier — the narrow law: local holds keystroke-latency view ephemera and MAY be read by same-view committed handlers, the seam where a local value crosses into an event vector is where it becomes product state; the forbidden tier — cross-view observation, replay/persistence, schema/tool inspection, durable navigation, or subscription-derived computation MUST be in app-db, loading flags the classic example). Supersedes the earlier strict "forbidden if any handler ever reads it" test. |
004-Views §Local state and the placement rule | day8/re-frame2-ui |
inside-out.md (argues the app-db default), migration/from-re-frame-v1 O-13/O-14 (substrate rehome defers here for placement) |
UI structural tree ABI v1 (five closed node variants, canonical form, semantic normalization N) + the one DOM conversion table both emitters consume + the emit-ui-tree SSR consumption boundary (version-gated) |
004B-UI-Tree-and-Conversion | day8/re-frame2-ui |
004-Views, 008-Testing, 011-SSR |
Root identity + mount — the mount grammar, Root Descriptor v1 (:rf.root/*), derivation/slug rules, element locators, three-layer fail-loud duplicate/conflict detection, and the ui.test/render root-or-view forms. Defer: the Root Manifest v1 render-time extension keys → S5 (co-owned with 011). |
004C-Roots-and-Mount | day8/re-frame2-ui |
004-Views, 002-Frames (frame preflight ENSURE), 011-SSR |
Presence (declarative enter/exit retention), ui/html (the one trusted-markup escaping bypass + its compiler-manifest site record), and ui/error-boundary (the explicit error component) — declared 004-owned view primitives |
004-Views | day8/re-frame2-ui |
API, 009-Instrumentation (error/warning catalogue rows land with their stages), 011-SSR |
The ui.test contract — Tier-1 headless structural testing (render / find / find-all / query / text / attrs), the tier table + .cljc authoring constraint, the selector grammar, and the compiled-view G-1 / G-14 / parity-corpus gates |
008-Testing | day8/re-frame2-ui (re-frame.ui.test) |
004-Views, 004D-UI-Test-Selectors, 004B-UI-Tree-and-Conversion |
State machine grammar and reg-machine (transition table, :always, :after, :spawn, :spawn-all, hierarchical states, :tags, :type :parallel + :regions, snapshot shape) |
005-StateMachines | day8/re-frame2-machines |
CP-5-MachineGuide, Pattern-NineStates, Pattern-WebSocket, Pattern-Boot, Pattern-LongRunningWork |
| Reactive substrate contract + reference adapters (Reagent default, plain-atom for JVM) | 006-ReactiveSubstrate | day8/re-frame2 (core) — substrate contract + plain-atom adapter; the Reagent adapter ships in day8/re-frame2-reagent |
008-Testing, 011-SSR |
UIx adapter (use-subscribe hook, flush-views! test flush, source-coord wrapping component, UIx-side frame-provider) |
006-ReactiveSubstrate | day8/re-frame2-uix |
API, Conventions (adapter shipping convention) |
Helix adapter (use-subscribe hook, flush-views! test flush, source-coord wrapping component, Helix-side frame-provider) |
006-ReactiveSubstrate | day8/re-frame2-helix |
API, Conventions (adapter shipping convention) |
Shared React frame Context (factored out so every React-shaped adapter consumes the same createContext object) |
002-Frames, 006-ReactiveSubstrate | day8/re-frame2 (core) — re-frame.adapter.context, CLJS-only; consumed by day8/re-frame2-reagent, day8/re-frame2-uix, and day8/re-frame2-helix |
API |
| Stories / Variants / Workspaces | 007-Stories | day8/re-frame2-story (post-v1 optional artefact) |
008-Testing (portable-stories-as-tests) |
Testing infrastructure (fixtures, synchronous triggers, per-test stubs, headless evaluation, framework adapters, JVM-runnable suites; the two test-only namespaces ship in the same artefact as siblings split on the assertion axis per 008-Testing §Audience-split — re-frame.test-support is the runtime-state axis (registrar, frames, app-db, drain, in-flight requests): fixture machinery (snapshot-registrar, restore-registrar!, make-reset-runtime-fixture), the assert-path-equals assertion fn (mirrors the :rf.assert/path-equals Story event), bounded-deadline polling (poll-until); re-frame.test-helpers is the view-tree axis (hiccup data, :data-testid selectors, attached handlers) — hiccup-walk finders (find-by-testid / find-all-by-testid / find-by-testid-prefix, find-by-attr / find-all-by-attr / find-by-attr-prefix), tree readers (expand-tree, attrs, children, text-content), handler reach (extract-handler, invoke-handler), authoring helper (testid); the single-frame e2e shape composes these with make-reset-runtime-fixture + poll-until) |
008-Testing | day8/re-frame2 (core) — re-frame.test-support and re-frame.test-helpers ship in the core artefact |
API, 007-Stories, 011-SSR (render-to-string as the HTML-string view-test sibling of hiccup-walk), conformance/ |
| Trace event model (envelope, ids, listener API) | 009-Instrumentation | day8/re-frame2 (core) |
Tool-Pair, API |
:rf.cascade/captured emit shape — focused-event-only per-epoch cascade-DAG aggregator; end-of-epoch emit via the :trace.cascade/capture-for-epoch! late-bind hook when the installed focus predicate matches |
009-Instrumentation §Trace event emission catalogue | day8/re-frame2 (core) |
Tool-Pair, 006-ReactiveSubstrate (memo skip interaction) |
Always-on event-emit substrate — register-listener! / unregister-listener! (the :events stream); one tight record per processed event ({:event :event-id :frame :time :outcome :elapsed-ms}); post-elision; survives goog.DEBUG=false and -Dre-frame.debug=false; per-listener exceptions isolated |
009-Instrumentation §What is available in production builds | day8/re-frame2 (core) |
API §Event-emit, Security §Production gates, Tool-Pair |
Always-on error-emit substrate — register-listener! / unregister-listener! (the :errors stream); union of three record shapes: the per-event error record ({:error :event :event-id :frame :time :exception :elapsed-ms}, fanned out by dispatch-on-error! per production-reachable per-event :rf.error/*), the frame-teardown report ({:error :rf.error/frame-teardown-failed :frame :hook-failures :reason :recovery :time}, one bounded record per destroy with failed cleanup hooks — EP-0008 promotion criterion), and the six EP-0008-promoted SSR non-event categories (ssr-render-failed / ssr-streaming-writer-failed / malformed-hydration-payload incl. a frameless :frame nil sub-path / ssr-head-resolution-failed / sanitised-on-projection / ssr-ring-error-view-failed) — the last two shapes ride the general dispatch-error-record! helper; listeners branch on (:error record) (the non-event arms carry no :event / :event-id); post-elision; survives goog.DEBUG=false and -Dre-frame.debug=false; per-listener exceptions isolated. Recovery is framework-owned (the per-category typed defaults); the per-frame :on-error recovery policy was removed |
009-Instrumentation §What is available in production builds | day8/re-frame2 (core) |
API §Error-emit, Security §Production gates, 013-Flows §Failure semantics (flow-eval-exception path) |
Error contract (structured trace events; framework-owned per-category recovery); the §Error event catalogue is the single source of truth for every :rf.error/*, :rf.warning/*, :rf.fx/*, :rf.cofx/*, :rf.ssr/*, :rf.epoch/*, :rf.http/*, :rf.frame/*, :rf.route.nav-token/* category — id · :op-type · trigger · default :recovery · :tags |
009-Instrumentation | day8/re-frame2 (core) |
API, all Specs that emit errors cite this section |
Schema attachment (:schema, reg-app-schema), validation timing, dev-vs-prod elision, validator-fn extension point |
010-Schemas | core (split pending → day8/re-frame2-schemas) |
001-Registration §Schema integration, Spec-Schemas |
SSR flow (server frame lifecycle, hydration payload, :rf/hydrate, hydration-mismatch detection) |
011-SSR | day8/re-frame2-ssr |
004-Views, 008-Testing, 012-Routing |
Streaming SSR (:rf/suspense-boundary hiccup marker, per-request continuations registry, per-subtree hydration deltas, chunk-ordering contract, inline-fallback failure semantics) |
011-SSR §Streaming SSR | day8/re-frame2-ssr (re-frame.ssr.streaming ns — primitive) + day8/re-frame2-ssr-ring (re-frame.ssr.ring.streaming ns — chunked-HTTP host adapter) |
011-SSR, API, Conventions (:rf/suspense-boundary reserved hiccup head) |
:platforms metadata on reg-fx/reg-cofx; pure hiccup → HTML emitter |
011-SSR | day8/re-frame2 (core) — :platforms metadata; the hiccup→HTML emitter ships in day8/re-frame2-ssr |
002-Frames, API |
Route grammar, :route sub, navigation events, route-not-found, navigation-blocking, fragments, scroll restoration |
012-Routing | day8/re-frame2-routing |
011-SSR, API |
Flows (reg-flow / :rf.fx/reg-flow / :rf.fx/clear-flow, computed-state declarations materialised into app-db) |
013-Flows | day8/re-frame2-flows |
API, Conventions (:rf.fx/* reserved) |
Managed HTTP requests (:rf.http/managed fx, args-map shape, decode pipeline, :accept normalisation, retry-with-backoff, abort surface, frame-aware reply addressing, eight-category :rf.http/* failure taxonomy, schema-reflection metadata, canned stubs, with-managed-request-stubs) |
014-HTTPRequests | day8/re-frame2-http — production fx surface in re-frame.http.managed; canned-stub fxs and the with-managed-request-stubs family of macros / fns in the sibling re-frame.http.test-support |
API, Spec-Schemas, Conventions (:rf.http/* reserved), Pattern-AsyncEffect, Pattern-RemoteData, Pattern-StaleDetection, 009-Instrumentation (:rf.http/retry-attempt trace) |
Data classification (EP-0025) — a hygiene helper (NOT security; fail-open). Durable app-db paths classified by four commit-plane effects (:sensitive / :large / :clear-sensitive / :clear-large, applied WITH the :db write) into a per-frame :rf.runtime/elision registry; transient payloads by :sensitive / :large registration metadata on reg-event / reg-fx / reg-cofx / reg-sub; subsystem instance data by projection-relative :sensitive / :large declarations on reg-machine / reg-resource / reg-mutation / reg-route, lowered per instance. :rf/redacted / :rf.size/large-elided display sentinels; sensitive-wins-over-large; NO propagation, NO value-match/taint, NO frame :sensitive annotation (both the :app-db durable block and the :http carrier block removed), NO durable-state schema-prop classification, NO imperative add-marks / set-marks API (all removed by EP-0025). The HTTP carrier capability rides the :rf.http/managed reg-fx registration (:carriers block — the transient-payload case); the frame :observability sink policy survives on the frame validate! seam. |
015-Data-Classification | day8/re-frame2 (core) — the re-frame.classification + re-frame.elision + re-frame.projection impl surface is core-owned and boot side-effect-required (never a separable artefact); the dev-only trace-projection surface is interop/debug-enabled?-gated and DCEs out of :advanced + goog.DEBUG=false CLJS bundles via goog.DEBUG, while the reg-time validate-classification! validator, the commit-plane effect applier (re-frame.elision/apply-classification-effects), and the redact-event-by-registration egress redactor are always-on and survive production |
001-Registration (registration metadata-map shape), 002-Frames (the four commit-plane effects + event-arg shape), 005-StateMachines (machine projection-relative :data declaration, lowered per actor), 006-ReactiveSubstrate (registration-owned sub-output classification — no propagation), 009-Instrumentation (trace-bus emission of sentinels), 010-Schemas (schemas validate + drive validation-failure-trace redaction only — not durable app-db classification), 013-Flows (flow output classification, :source :flow), Conventions (reserved commit-plane effects + sentinel keywords + :rf.runtime/elision), Security (pattern-level privacy posture this Spec grounds), tools/mcp-base/spec/sensitive.md, tools/mcp-base/spec/elision.md (cross-MCP wire-elision walker consumers) |
Resources — declarative server-state (HTTP-only): reg-resource / clear-resource, resource identity [cache-scope resource-id canonical-params], fail-closed scope policy (no silent global default), active owners vs causes (per-kind release authority), the compact lifecycle FSM + :refresh-error status semantics, the :rf.resource/* events/subs/accessors, the :rf.runtime/resources cache + neutral :rf.runtime/work-ledger runtime subsystems, dedupe / stale-reply suppression / GC, route :resources, SSR preload/hydration, and restore/replay reconciliation. Mutations (reg-mutation / clear-mutation / :rf.mutation/execute, instance-keyed) and the EP-0016 action-wave surfaces: call-site :reply-to mutation continuations (D1), per-target scoped invalidation descriptors (D2), populate-as-authoritative-load + :refetch-populated? (R1), map-form exact targets (R2), and request-decoration doctrine via the Spec 014 seam (R3). The named normative home of EP-0003 (HTTP-only scope), EP-0016 (mutation completion / scoped invalidation / named scope resolvers), and EP-0019 (optimistic mutation rollback — :optimistic / :optimistic-tags / :on-conflict + the commit/rollback/reconcile settle protocol); GraphQL deferred |
016-Resources | day8/re-frame2-resources (post-v1 optional artefact) |
EP-0003, EP-0016, 014-HTTPRequests (:rf.http/managed transport + interceptor decoration seam), 012-Routing (:resources accepted-key extension + route-resource :scope resolver refs), 011-SSR (project-runtime-db projection), Runtime-Subsystems (the five-clause graduation), Conventions (:rf.resource/* / :rf.mutation/* / :rf.scope/* / :rf.work/* reserved, :rf.runtime/resources + :rf.runtime/work-ledger + :rf.runtime/mutations runtime-db keys), Pattern-RemoteData, 009-Instrumentation (:rf.resource/* / :rf.mutation/* trace families + error categories land with the implementation slice), EP-0011 (the reply envelope the mutation :reply-to map lowers onto), EP-0019 (optimistic mutation rollback) |
Named resource-scope resolvers — reg-resource-scope / clear-resource-scope (the :resource-scope registrar kind), the {:inputs … :resolve …} declared-input grammar, the [:db <rf-path>] input source (whole-db fn = tooling-marked explicit-cost sugar; [:runtime path] reserved, not shipped), the {:from-db <id>} use-site reference (fail-closed on nil), and the resolve-resource-scope resolver helper (not an effect, but emits :rf.resource/scope-resolved dev trace — not a pure data helper). EP-0016 Decision 3 |
016-Resources §Named resource-scope resolvers | day8/re-frame2-resources (post-v1 optional artefact) |
EP-0016, EP-0012 ([:db <rf-path>] is a concrete :rf/path; the forward-compatible named-declaration shape), EP-0014 (the reserved [:runtime path] input source), 001-Registration (the :resource-scope registrar kind), API (facade classification), Conventions (:rf.scope/* reserved + the {:from-db} reference form) |
Runtime shapes (Malli, CLJS reference) — :rf/effect-map, :rf/registration-metadata, :rf/hydration-payload, :rf/trace-event, etc. |
the per-Spec owner of each shape; Spec-Schemas is the projection (collected EDN forms) — non-canonical | per-surface (matches the owning Spec's row) | every Spec that owns a shape |
| API signatures (consolidated) | the per-Spec owner of each surface; API is the projection — non-canonical | per-surface (matches the owning Spec's row) | per-Spec owners |
| Migration rules (re-frame v1.x → re-frame2, CLJS reference) | MIGRATION | spec-only (no runtime artefact) | per-Spec owners (contract content); Migration owns the rules |
| Pair-tool runtime contract (inspect, dispatch, hot-swap, time-travel, fx-stub, source-map) | Tool-Pair | core for the inspect / dispatch / hot-swap / fx-stub / source-map slices (which ride the registrar / dispatch / trace surfaces in day8/re-frame2); the time-travel slice — the re-frame.epoch namespace, :rf/epoch-record ring buffer, register-epoch-listener! / unregister-epoch-listener! listener API, restore-epoch! rewind, and the :rf.epoch/* trace ops — ships in day8/re-frame2-epoch |
001-Registration, 009-Instrumentation |
Cross-MCP shared primitives (:rf.mcp/* + :rf.size/* wire-marker keys + JSON-RPC error codes; spec/009 §Privacy default-suppress filter; :rf.size/large-elided walker; arg coercion; path-keyed structural diff; overflow-marker payload builder; token-budget cap pipeline) — external canonical home (per README §Canonical homes outside /spec; tool-shared contract, ships with the artefact). Indexed by tools/mcp-base/spec/README.md, with per-namespace contracts in: vocab.md, sensitive.md, elision.md, args.md, diff-encode.md, overflow.md, cap.md. |
tools/mcp-base/spec/ (external: tool-shared, downstream of /spec; per-namespace docs indexed above) |
day8/re-frame2-mcp-base — consumed by tools/re-frame2-pair-mcp/ and tools/story-mcp/ |
Tool-Pair, 009-Instrumentation (§Privacy filter, :rf.size/large-elided) |
| Security posture, threat model, behavioural MUSTs, pragmatic stance, decisions log — language-agnostic pattern-level coordination layer naming what is defended, where the defense's contract lives, and why the call was made. Threat model + scope, the eight categories (input validation, XSS, CRLF, privacy, DoS, MCP authority, editor URI allowlist, file-path boundaries, production gates), the catalogue references into Conventions.md / 009 / 010 / 011 / 014, the four-proposition pragmatic stance, and the 38-decision bead log. The mirror to this matrix — Security names what is defended; Ownership names where the defense's contract lives. | Security | spec-only (no runtime artefact) | Conventions, Principles, per-spec owners of each named defense (009 / 010 / 011 / 014 / Tool-Pair / API / Implementor-Checklist / 007-Stories) |
CLJS-reference security specifics — named functions (re-frame.core/elide-wire-value, re-frame.interop/debug-enabled?), numeric defaults (:rf.http/max-decoded-keys 10000, :timeout-ms 30000, drain-depth ceiling, :rf.size/threshold-bytes 16384), JVM-vs-CLJS stub semantics, the exact :rf.error/* keywords each safety check emits, and the full 38-bead audit trail — external canonical home (per README §Canonical homes outside /spec; CLJS-reference binding of the pattern-level MUSTs in Security.md; split executed by (A).3 (a)) |
implementation/SECURITY.md (external: CLJS-reference binding, downstream of /spec) |
spec-only (no runtime artefact); the named functions ship in the artefacts named on their respective rows above | Security (pattern-level companion); per-spec owners of each named fn / numeric default |
Reserved-namespace policy, reserved fx-ids and app-db keys |
Conventions | spec-only (no runtime artefact) | every Spec that uses a reserved id cites the Conventions list |
Runtime-subsystem contract — the five clauses (subtree, write authority, read API, projection/elision policy, teardown) every :rf.runtime/* child of the runtime-db partition satisfies; the grading table for the shipped children (the four v1 subsystems machines / routing / elision / ssr, plus the resource trio resources / work-ledger / mutations — the resource-trio rows are mirrored from 016 §Runtime-subsystem graduation, their canonical home) and the plugin/extension seam (a 3rd-party :rf.runtime/<lib> is a new graded instance). The durable-state analogue of Managed-Effects. Names the shape; the reserved keys are owned by Conventions, the per-clause mechanisms by 002 |
Runtime-Subsystems | spec-only (no runtime artefact) — the per-clause mechanisms ship on their owning rows (machines / routing / SSR / core) | Conventions §Reserved runtime-db keys, 002-Frames §Write authority / §Durable vs transient / §Destroy, 005-StateMachines, 011-SSR, 012-Routing, Managed-Effects |
Operational-environment ownership — the non-durable layer beside the durable runtime subsystems, split across two owners: the process owns the singletons every frame shares (the registrar, the installed adapter selection, the capability map, the live frame registry); each frame owns its host-transient subsystem state (keyed per-frame, released on destroy-frame!) and its teardown bookkeeping. Includes adapter ownership = process selection + render-root instances; capability maps + late-bind-as-bridge; host-transient subsystem state + its grading column (complements the EP-0006 durable five-clause contract). The non-durable sibling of the five-clause runtime-subsystem contract. The public composition model is image → frame → event stream (rf/image + rf/make-frame); a frame is addressed by its id alone, and resolution is process-global. There is no runtime-realm container and no (realm, frame) two-part address; the realm/app/module constructors are absent from the facade. |
Runtime-Subsystems §The operational environment | spec-only (no runtime artefact) — the process/frame ownership ships on day8/re-frame2 |
EP-0023 (the image → frame → event stream public model), EP-0024 (the one-frame-value teardown backbone), EP-0006 (the durable five-clause contract this complements), 002-Frames §Frame addressing, Spec-Schemas §:rf/host-transient-descriptor, 006-ReactiveSubstrate (the adapter contract, ownership unchanged), 001-Registration (the process-global registrar), Conventions §Reserved namespaces (:rf.capability/*), EP-0013 (the realm-container model record) |
Derivation/process algebra — the common vocabulary every declared fact/process over the frame fold lowers to: fact, derivation, process, declared input, output, the four-class storage axis (:ephemeral / :app-db / :runtime-db / :host-transient) + the separate :authority remote axis, the seven-policy evaluation axis (:on-demand / :after-event / :on-reply / :on-route / :on-transition / :scheduled / :manual), lifecycle/owner, materialized vs ephemeral output, the node/edge graph model, the static/live + don't-execute rules, the named-resolver enrichment, and the whole-value law (delta law semantic-only in slice-1). The derivation/process analogue of Managed-Effects (effects) and Runtime-Subsystems (durable state). Slice-1: vocabulary + internal registration metadata only — no public authoring primitive or stable graph-accessor name (deferred). The named normative home of EP-0014 |
Derivations | spec-only (no runtime artefact) — the per-member registration metadata ships on its owning rows (subs / flows / resources / routing / machines) | EP-0014, 006-ReactiveSubstrate (subscriptions = the first derivation instance; cites the whole-value law), 013-Flows (flows = materialized :after-event derivations), 016-Resources (resources = processes; :authority :remote + :storage :runtime-db), 012-Routing (route facts), 005-StateMachines (machines = processes; selectors = derivations), Spec-Schemas §:rf/derivation-node, Managed-Effects, Runtime-Subsystems, EP-0006 (storage-class ↔ projection-tier alignment), EP-0012 (node identity), EP-0013 (the relocation seam), EP-0015 (redaction metadata) |
| Construction-prompt scaffolding templates | Construction-Prompts | spec-only (no runtime artefact) | per-Spec owners (contract content); Construction-Prompts owns the scaffolding shape |
| Conformance fixtures (canonical interactions and expected emissions, in EDN) | conformance/ | spec-only (no runtime artefact) | per-Spec owners (contract content); conformance owns the fixture corpus |
Xray event-spine architecture — the 4-layer chrome (ribbon · event list · tab bar · detail panel), the spine sub :rf.xray/focus collapsing two-axis selection into single-axis, the 6-tab inventory (Event / App-db / Views / Trace / Machines / Routing — the Issues tab was removed per Option (c); issues surface inline in the Epoch panel + the L2 event-row pink-wash + the always-on issues ribbon signal), the IN/OUT filter pills + edit popup, the Settings modal popup, the Causality popover (c-key transient overlay), the frame-observation isolation invariants (I1–I4) with browser-feature test gate, and the data-classification rendering contract that consumes spec/015 — external canonical home (per README §Canonical homes outside /spec; tool-shared contract, ships with the Xray artefact tree under tools/xray/spec/). |
tools/xray/spec/018-Event-Spine.md (external: tool-spec, downstream of /spec) |
day8/re-frame2-xray (the Xray tool artefact) |
tools/xray/spec/000-Vision.md (6-tab inventory), tools/xray/spec/007-UX-IA.md (typography + colour tokens + keyboard map), tools/xray/spec/003-Machine-Inspector.md (Machines tab content), tools/xray/spec/012-Views.md (Views tab content), tools/xray/spec/016-Auxiliary-Panels.md (per-tab content), tools/xray/spec/017-Test-Coverage-Matrix.md (test gates) |
Drift rule: if a contract surface acquires a second normative definition (a redefinition rather than a citation), that is a corpus bug. File it as a spec-review bead and resolve by collapsing back to the listed owner.