# **Evulgare Assurance Simulation Workbench: Product Architecture, Scientific Visualization, WebXR, Accessibility, and Performance**

## **Executive Summary**

The transition of Evulgare from a conventional web presence to a unified Assurance Simulation Workbench necessitates a radical architectural paradigm shift. Derived from the Latin root *evulgare*, meaning "to make public" or "divulge"1, the platform's core mandate is the transparent exposition of mathematical and physical bounds governing complex, autonomous decision-making systems. The evidence dictates that achieving this transparency without compromising institutional authority requires a strict decoupling of deterministic proof generation from browser-based rendering. The backend Python 3.13 service layer must retain absolute epistemological authority, while the frontend—constrained to zero-build-step vanilla JavaScript, semantic HTML, and handcrafted CSS—functions exclusively as a high-fidelity visualization, exploration, and verification client.  
This comprehensive blueprint specifies a capability-aware graphics pipeline that capitalizes on the 2026 baseline availability of WebGPU across major browser engines2, while orchestrating graceful degradation to WebGL2 and Semantic HTML4. Furthermore, it integrates the theoretical underpinnings of the Convergent AI Agent Framework (CAAF) and its Unified Assertion Interface (UAI)6, transforming safety constraints into a deterministic "Harness as an Asset"6. By fulfilling thirty-seven precise deliverables ranging from a WCAG 2.2 AA accessibility task matrix to exact performance budgets and progressive delivery architectures, this report provides the definitive roadmap for projecting Evulgare’s technical sophistication while preserving uncompromising scientific discipline.

## **Public-Site Audit**

An epistemological audit of the publicly observable Evulgare surface yields the following structural classifications. The analysis assumes no access to internal source code, user accounts, or private metrics. Every observation is strictly tagged to identify the nature of the claim.

| Observation / Feature | Epistemological Tag | Architectural Analysis |
| :---- | :---- | :---- |
| HTTPS protocol enforcement | \[observed public fact\] | The site mandates a secure context, which is a hard cryptographic prerequisite for WebXR session initialization and WebGPU adapter requests across all modern browsers4. |
| "Deterministic Python Service Layer" | \[documented first-party claim\] | Evulgare claims its backend computes all outcomes. The frontend must not duplicate physics, safety, or autonomy logic, acting only as a stateless receiver of simulation vectors. |
| Single Page Application (SPA) DOM manipulation | \[technical inference\] | The current state exhibits SPA-like routing without hard reloads. Without NPM frameworks, this implies a reliance on the native History API and vanilla ES module orchestration. |
| Absence of NPM/Node.js artifacts in production | \[technical inference\] | Minified payloads lack Webpack, Vite, or Next.js boilerplate, validating the strict architectural constraint of a vanilla DOM ecosystem without mandatory JavaScript compilation stages. |
| Visualization canvas rendering | \[observed public fact\] | The primary viewport utilizes standard \<canvas\> elements for spatial data representation, though current GPU utilization efficiency remains opaque. |
| Exact topology of the .uai event ingestion | \[unknown\] | The precise JSON serialization format bridging Flask to the browser state manager is not publicly visible and requires definition in this blueprint. |
| Caching strategy for deterministic variants | \[required product decision\] | A mechanism must be established to differentiate and cache baseline runs versus counterfactual branches efficiently without burdening the Python backend. |

## **Competitive and Adjacent Product Audit**

To design an uncompromising Assurance Simulation Workbench, transferable interaction patterns from adjacent high-stakes environments were analyzed. The superficial styling of commercial platforms is explicitly rejected in favor of functional primitives that convey safety and determinism.

| Domain / Adjacency | Representative Systems | Transferable Pattern | Strengths & Weaknesses |
| :---- | :---- | :---- | :---- |
| **Engineering Simulation Tools** | Concurrent SIMulation Workbench (SimWB)9 | Real-Time Database (RTDB) mapping, multi-rate model execution9, and Python API integration (PYToolkit)11. | **Strength:** Unyielding hard real-time determinism. **Weakness:** Heavy desktop client dependency; lacks web-native progressive delivery mechanisms. |
| **Safety and Assurance Case Tools** | CAAF (Convergent AI Agent Framework)7 | Recursive Atomic Decomposition (RAD)6, Harness as an Asset6, and the Unified Assertion Interface (UAI)6. | **Strength:** Enforces mathematically verifiable bounds on stochastic systems; perfect foundation for the Proof Inspector. **Weakness:** Requires rigid YAML constraint modeling upfront. |
| **Aerospace Mission Control** | NASA OpenMCT | Time-conductor UI, synchronized telemetry across multiple independent panels. | **Strength:** Flawless event-index synchronization. **Weakness:** High visual density overwhelms non-expert users; poor mobile reflow characteristics. |
| **Game Engine Editors** | Unreal Engine 5, Unity | Persistent outliner hierarchies, synchronized camera viewports, and granular detail inspector panels. | **Strength:** Excellent spatial context manipulation. **Weakness:** Gamified aesthetic is inappropriate for institutional assurance; high hardware requirements. |
| **System Provenance Tools** | Palantir Foundry / Apollo | Node-based causal chains tracing data lineage from raw input to final authoritative output. | **Strength:** Clear authority tracing and data provenance. **Weakness:** Proprietary rendering engines; over-reliance on opaque graph physics. |

## **Simulation Explorer Information Architecture**

The Simulation Explorer functions as the entry point to the Evulgare platform, designed to project immediate technical sophistication. It serves as a visual and functional index of available deterministic scenarios, avoiding marketing hyperbole in favor of data-dense, URL-addressable navigation.

### **Landing Page Architecture**

The landing page replaces traditional web headers with a functional, high-fidelity progressive preview. A WebM/AVIF background sequence or a lightweight WebGPU scene provides immediate context, overlaid with a stark, typography-driven title and a one-sentence operational objective. Below the preview, a persistent top-bar contains the URL-addressable routing controls, followed by a CSS Grid implementation displaying the Simulation Cards. A fixed system status footer continuously indicates the browser's WebGPU/WebGL2/WebXR capability3, current Flask API latency, and the active UAI engine version.

### **Card Content Specification**

Every simulation card in the Explorer grid acts as a dense metadata payload, eschewing generic rounded UI for square, technical borders. Each card must strictly contain a high-quality, low-poly static frame (WebP/AVIF format) representing the first divergence point of the scenario. The metadata block includes the exact simulation title (formatted in monospace, e.g., L3\_AD\_DEGRADATION\_PARADOX), a one-sentence purpose, the primary topic domain, a difficulty proxy based on computational complexity (O(1) to O(N)), and the estimated exploration duration. Capability badges indicate the interaction level (Static, Parametric, or Branching), total proof count, and research-source count. Finally, a row of binary support indicators confirms whether the scenario is XR-ready, Mobile-ready, and Accessibility-optimized.

### **URL Filter Specification**

Filters must map directly to URL search parameters to ensure that specific grid states are perfectly reproducible and shareable across institutional teams. The vanilla JavaScript router listens to popstate events to update the DOM without backend round-trips. The specification includes:

* ?topic=\[kinematics|thermodynamics|cybernetics|aerodynamics\]  
* ?mode=\[guided|explore|expert\]  
* ?difficulty=\[introductory|intermediate|advanced\]  
* ?duration=\[\<5m|\<15m|\>15m\]  
* ?goal=\[audit|compare|export\]  
* ?device=\[mobile|desktop\]  
* ?feature=\[replay|comparison|export|xr\]

### **Content and Onboarding: Learning Paths**

To onboard users into the epistemology of computational assurance, Evulgare utilizes three distinct interaction modes: Guided, Explore, and Expert. Guided mode is engineered to take a new user to a meaningful deterministic result in approximately three minutes by locking irrelevant variables and focusing the camera automatically on critical divergence points, without hiding the underlying uncertainty or proof conditions.  
To structure this content, seven distinct learning sequences are defined:

> 1. **Understanding Assurance:** Transitioning the user's mental model from "the system works" to "the system is mathematically proven not to fail under these bounded conditions."  
> 2. **Understanding Authority:** Tracing how a system's claim to act maps directly to a regulatory red-line via an executable YAML harness6.  
> 3. **Understanding Uncertainty:** Visualizing stochastic variance and Monte Carlo boundaries without implying that the uncertainty itself is unmanaged.  
> 4. **Understanding Provenance:** Navigating the cryptographically verifiable chain of evidence from a raw sensor input vector to a final system decision.  
> 5. **Understanding Resilience:** Simulating component failure and inspecting the deterministic recovery routing executed by the backend.  
> 6. **Understanding Autonomous Decisions:** Inspecting the Recursive Atomic Decomposition (RAD) DAG6 of an agent to see how complex problems are isolated into context firewalls.  
> 7. **Understanding Machine-Sovereign Systems:** Analyzing scenarios where human intervention speed is physically insufficient, necessitating pure algorithmic authority.

### **Content Patterns**

Every simulation within these paths utilizes a rigid content template: Objective (what is being tested), What to Change (identifying the bounded inputs), What to Observe (directing attention to the 3D viewport or timeline), Why it Matters (the real-world implication), What the Result Establishes (the definitive proof), What it Does Not Establish (explicitly stating the reality-gap qualification), a localized Glossary, and a link to the Next Simulation.

## **Unified Workbench**

The Workbench is the core visualization environment. It enforces the project's most critical constraint: absolute separation between the authoritative Python layer and the browser-based visualization renderer. The browser may visualize and navigate state, but it may never independently decide proof, authority, or mission outcome.

### **Desktop Workbench Specification**

The desktop layout utilizes a semantic CSS Grid (display: grid; grid-template-areas: ...) to establish a rigid, non-overlapping workspace. The top command bar is persistent, containing the scenario title, the global PASS/FAIL status, the current time-step, and strictly functional export/share controls. The left aside functions as the Scenario Panel, listing available bounded inputs, the hierarchical entity tree, and the baseline parameter toggles. The central \<main\> area houses the Simulation Viewport—the WebGPU/WebGL canvas or SVG fallback—featuring top-level representation tabs that allow the user to instantly switch between 2D, 3D, Text, and Table views of the exact same state data. The right aside is the Proof Inspector, a contextual panel detailing the specific Unified Assertion Interface (UAI) constraints acting on the currently selected entity. Finally, the footer contains the Synchronized Event Timeline, a scrubbable interface marking critical state transitions, causal divergences, and safety interventions.

### **Mobile Workbench Specification**

Responsive behavior must not turn the desktop interface into an unusable mobile dropdown maze. The mobile architecture adopts a stacked, scrollable card metaphor with a sticky bottom action bar. The central simulation viewport remains fixed at the top of the viewport at a strict 1:1 or 4:3 aspect ratio. The Timeline, Proof Inspector, and Scenario inputs are transformed into horizontal swipe-views or native bottom-sheet modals (\<dialog\> elements) triggered from the persistent bottom bar. To respect battery and thermal limits on mobile CPUs, the graphics pipeline automatically prefers WebGL2 or 2D Canvas over high-fidelity WebGPU passes unless the device is explicitly plugged into power and operating on a modern ARM architecture12.

### **Error and Recovery State Library**

The workbench must handle failure with absolute determinism, matching the seriousness of its subject matter.

| State | Trigger Condition | UI/UX Resolution Strategy |
| :---- | :---- | :---- |
| **No-JavaScript** | JS disabled by user or IT policy. | The core Flask Jinja template renders a \<noscript\> block containing the full text-based UAI assurance log in semantic HTML, proving the visualizer is strictly optional. |
| **Context Loss** | GPU driver crash or OS memory reclamation. | A "Graphics Hardware Reset" toast appears; the UI instantly falls back to the SVG/Table view while attempting a silent WebGPU context rebuild in the background4. |
| **API Timeout** | Python backend requires \> 15s to compute a complex variant. | A "Simulation Resolving..." skeleton loader appears with a deterministic progress bar driven by backend Server-Sent Events (SSE). |
| **Constraint Paradox** | Backend determines no safe state exists (e.g., stopping distance \> perception limit)6. | The viewport flashes a structural red border and halts playback. The Proof Inspector locks open, detailing the mathematically irreconcilable constraints. |
| **Invalid Chunk Hash** | Network tampering or packet corruption during progressive delivery. | Execution halts immediately. An "Evidence Package Corrupted" modal forces a hard refetch of the simulation file to preserve cryptographic fidelity. |

## **Event-Index State Model**

The analysis dictates a single, immutable, unidirectional state model to govern the entire application. The architecture is defined by an absolute EventIndex integer.  
When the user, or the automated playback loop, updates the application to EventIndex \= 17, a vanilla JavaScript state manager (utilizing an EventDispatcher or the native CustomEvent bus) broadcasts the transition. Instantly, the visual scene translates camera and object positions to match the telemetry of frame 17\. The selected entity updates its physical attributes (e.g., velocity, temperature). The tabular and narrative layers scroll to and highlight the text describing event 17\. The event log and metrics update their sparklines up to, and completely stopping at, event 17\. The Proof Inspector queries the UAI result specifically for event 17\. If the user is comparing a variant, the variant runner is mathematically clamped to its corresponding event 17\.  
This architecture explicitly identifies and eliminates anti-patterns caused by loosely synchronized UI panels. Allowing a 3D canvas to visually run ahead of the textual event log creates cognitive dissonance and destroys the platform's technical authority. Furthermore, if a user clicks an entity in the viewport, the UI must not locally mutate the entity's state. It must dispatch a selection intent, which updates the global state bus, which then trickles down to update the properties panel and the canvas highlight simultaneously.

## **Proof Inspector Specification**

The Proof Inspector is Evulgare's signature interface. It demystifies the black box of autonomous behavior by mapping it directly to the Unified Assertion Interface (UAI)6. The UAI acts as the mandatory transducer between semantic space and deterministic physical space, structurally preventing the system from "grading its own homework"6.

### **Status Enumerations**

Every condition evaluated by the deterministic Python backend returns one of eight strict types, which dictate the UI styling (using the handcrafted CSS variables):

* **PASS:** Constraint mathematically verified. (Muted green indicator).  
* **FAIL:** Constraint violated (e.g., stopping distance exceeds perception limit6). (Red indicator).  
* **UNKNOWN:** Insufficient evidence in the telemetry package to evaluate.  
* **NOT EVALUATED:** Skipped due to prior topological failure via State Locking15.  
* **NOT APPLICABLE:** The physical context firewall excludes this constraint from the current node6.  
* **SUPPORTED WITH QUALIFICATIONS:** Passed, but operating near threshold limits. (Amber indicator).  
* **SUSPENDED:** Temporarily deactivated by an authoritative safety intervention.  
* **WITHDRAWN:** Constraint invalidated by newer scenario rules in a variant branch.

### **Interface Display Architecture**

For any selected condition, the Inspector UI must render a rigorous data payload. The Proof ID is displayed as a monospace hash (e.g., UAI-7A9B-22). The Statement translates the YAML constraint into plain English (e.g., "Target speed must be \<= 55 km/h"6). The Evidence block displays the exact raw telemetry at that specific EventIndex. Assumptions and Defeaters clarify what environmental variables must hold true (e.g., dry asphalt) and what physical realities invalidate the proof (e.g., sensor icing). Affected Entities and Events are rendered as hyperlinks that jump the global timeline to the specific violation. The Research Basis links outward to ISO standards or academic literature. Finally, persistent action buttons allow the user to \[Jump to Event\], \[Compare Baseline\], or \[View Raw Evidence JSON\].

## **Causal Explanation Specification**

To answer the question "Why did this happen?", the UI utilizes the structure of Recursive Atomic Decomposition (RAD)6. The system stringently avoids fabricated machine monologues, LLM-generated chain-of-thought, or anthropomorphized text.  
The interactive view traces the exact sequence: Input (environmental boundary conditions) → Evidence (sensor data captured) → Transformation (the mathematical matrix applied) → Uncertainty (confidence intervals) → Claim & Authority (the system's intent to act and the policy permitting it) → Constraint & Decision (the UAI physical context firewall evaluation6) → Safety Intervention (if applicable) → Outcome (final deterministic state).  
The explanation uses structured facts and stable reason codes (e.g., ERR\_KINEMATICS\_VIOLATION) exclusively. The visual representation is a node-based Directed Acyclic Graph (DAG)6, where clicking a node reveals the JSON input and output payload for that specific micro-decision.

## **Baseline, Variant, and Branching Specification**

Evulgare’s core utility lies in comparing a known, proven baseline against a counterfactual variant.  
The original .uai run is pinned as an immutable reference track. When a user modifies a bounded input (e.g., changing weather from CLEAR to HEAVY\_RAIN), the frontend does not simulate the result. It dispatches a request to the Python backend, which computes the new variant and streams the JSON payload back to the browser.  
Once received, the frontend timeline mathematically diffs the two runs and drops a highly visible monospace marker at the exact millisecond the state vectors experience their first divergence. In side-by-side mode, two WebGPU viewports are instantiated. A single orbit control implementation broadcasts camera matrices to both viewports simultaneously, ensuring perfect spatial synchronization. Entities with a state delta greater than zero are rendered with a semantic teal shader overlay.  
Variants can be saved as immutable counterfactual branches. The UI displays a branch tree representing the multiverse of the scenario, allowing branch-to-branch comparison without altering the canonical history of the baseline.

## **Visualization-Layer Specification**

To manage visual complexity without overwhelming the user, the viewport supports orthogonal semantic layers. A fundamental stricture of the Assurance Simulation Workbench is that *every* layer must have an equivalent table and text representation in the DOM.

| Semantic Layer | Visual Representation (3D/2D) | Tabular/Text Equivalent |
| :---- | :---- | :---- |
| **SYSTEM** | The physical bounds of the machine (e.g., chassis, actuators). | Asset inventory list with dimensional matrices. |
| **EVIDENCE** | Raw sensor cones, LIDAR point clouds, and raw telemetry vectors. | Raw JSON feeds; timestamped sensor arrays. |
| **ASSURANCE** | Translucent bounding boxes representing proven safe operational volumes. | Min/Max physical constraints and UAI threshold values. |
| **AUTHORITY** | Geofences or hierarchical permission zones rendered as floor grids. | Boolean permission tables tied to spatial coordinates. |
| **UNCERTAINTY** | Gaussian blur volumes or particle clouds representing probabilistic state variance. | Standard deviation metrics; Monte Carlo boundary lists. |
| **EVENTS** | Spatial markers (glyphs) for discrete state transitions along trajectories. | The chronologically ordered Event Log. |
| **METRICS** | Heads-up floating telemetry numbers (velocity, temperature). | Traditional data tables mapping time against variables. |
| **WORLD TRUTH** | The objective physics of the simulation. | The absolute ground-truth physics coordinate array. |
| **AUTONOMY BELIEF** | The internal world-model held by the autonomous agent (often misaligned with World Truth). | The ingested sensor matrix prior to transformation. |
| **AUTONOMY INTENT** | The planned future trajectory of the agent (splines or vectors). | The target output coordinate matrix. |

## **Graphics, Camera System, and XR Architecture**

As of early 2026, WebGPU is a baseline feature across Chrome 113+, Edge 113+, Safari 26, and Firefox 141+2. It represents a massive leap over WebGL by providing first-class compute shaders, lower JavaScript overhead, and direct mapping to native Vulkan, Metal, and Direct3D 12 APIs2. However, Evulgare must implement capability-aware fallback sequences.

### **Graphics Fallback Architecture**

> 1. **WebGPU:** Primary target. Compute pipelines process thousands of parallel simulation states or uncertainty point clouds directly in the browser, while render pipelines draw the high-fidelity 3D output3.  
> 2. **WebGL2:** The primary fallback for Linux environments with blocked WebGPU adapters, older Android devices lacking modern ARM/Qualcomm GPUs12, or browsers operating in compatibility mode4.  
> 3. **WebGL (v1):** Maintained solely for legacy mobile device support.  
> 4. **Semantic Non-Graphics Representation:** The absolute baseline. If hardware acceleration is entirely disabled or missing, the canvas collapses, and the UI relies entirely on the tabular and textual representations of the event-index model.

### **Camera System**

The camera system is strictly controlled by the EventIndex global state. While users can free-roam via mouse/touch orbit controls, clicking a critical event in the timeline triggers a deterministic camera interpolation to a pre-computed optimal viewing matrix. Crucially, the camera system honors the OS-level prefers-reduced-motion CSS media query. If detected, cinematic camera sweeps are completely disabled, replaced by instant cuts to the target event coordinates to prevent vestibular distress.

### **Context Cleanup and Context Loss**

Given the massive data payloads involved in multi-branch simulation, GPU memory leakage is a critical threat. The architecture mandates the use of the vanilla JS FinalizationRegistry and explicit .destroy() calls on WebGPU buffers upon branch switching or scenario exit. Furthermore, the application listens for the gpu.device.lost event. Upon detection, it prompts a clean, seamless recreation of the graphics pipeline from the current EventIndex without requiring a destructive page reload4.

### **WebXR Experience and Fallback Plan**

WebXR is utilized to provide immersive spatial inspection of assurance bounds. The implementation requires a secure context (HTTPS) to expose the navigator.xr interface8. When initialized, the workbench UI wraps around the user as a cylindrical dashboard, while the 3D scenario plays out on a central holographic table. The fallback plan is absolute: API presence is not treated as physical XR acceptance. If navigator.xr is undefined, or if a session request is rejected because no physical headset is connected, the UI gracefully hides all XR entry buttons. XR is treated as a specialized, optional viewing modality, never a required path for proof inspection.

## **Accessibility Task Matrix (WCAG 2.2 AA)**

Evulgare must remain navigable by all users, explicitly avoiding the exclusionary trap of rendering complex simulations as opaque \<canvas\> blobs. Automated checks are utilized during CI/CD but are never presented as substitutes for manual human review.

| Modality | Implementation Specification |
| :---- | :---- |
| **Keyboard Navigation** | Strict logical DOM ordering mirroring the visual layout. Custom focus management using the :focus-visible pseudo-class with a high-contrast 2px solid border (--ev-color-accent). Spacebar/Enter globally toggles timeline playback. |
| **Screen Readers (NVDA, JAWS, VoiceOver, TalkBack)** | The 3D WebGPU/WebGL canvas is marked aria-hidden="true". The synchronized Event Timeline and Table layers use aria-live="polite" to announce critical state changes (e.g., "Event 17: Forward Collision Constraint Failed"). |
| **Zoom & Reflow** | CSS Grid and Flexbox layouts utilizing rem units ensure the UI reflows into a single column at 400% zoom without horizontal scrolling, satisfying WCAG 1.4.10. |
| **Forced Colors / High Contrast** | System-level forced colors are supported by relying on SVG iconography shapes rather than background colors to convey meaning. |
| **Switch Control & Voice Control** | All interactive elements are native \<button\>, \<a\>, or \<input\> tags. Click targets exceed the 44x44 CSS pixel minimum. |
| **Non-Color Status** | PASS/FAIL states never rely solely on color. They use distinct SVG iconography (a checkmark vs. a strict geometric cross) alongside explicit text labels. |
| **Table Navigation & Chart Alternatives** | All WebGL/Canvas metrics charts are backed by visually hidden HTML \<table\> elements containing the raw, structured data, fully navigable via standard screen reader table commands. |
| **Non-XR Task Equivalence** | Every task achievable in WebXR must have an exact equivalent in the standard 2D desktop/mobile interface. |

## **Performance Budgets and Progressive Delivery**

Delivering massive, deterministic .uai data payloads requires strict budgeting and advanced network chunking strategies to prevent browser thread locking.

### **Concrete Performance Budgets**

* **Initial HTML/JSON:** \< 50 KB (Gzipped) combined. Flask serves the shell and metadata instantly.  
* **JavaScript (Vanilla ES Modules):** \< 150 KB. The strict "no framework" constraint ensures this is achievable.  
* **CSS (Handcrafted):** \< 30 KB.  
* **Preview Media:** \< 500 KB (WebP/AVIF or highly optimized looping WebM).  
* **First 3D Frame (WebGPU init):** \< 1.0s.  
* **Largest Contentful Paint (LCP):** \< 1.5s (Targeting the Hero image/video on the Explorer).  
* **Interaction to Next Paint (INP):** \< 100ms. Crucial for timeline scrubber responsiveness.  
* **Cumulative Layout Shift (CLS):** 0.0. Enforced via strictly pre-allocated CSS DOM container dimensions.  
* **API Latency (Variant Run):** Dependent on Python compute complexity, but TTFB (Time to First Byte) of the SSE stream must be \< 500ms.  
* **FPS (Graphics):** 60 FPS baseline on desktop power; degrading to 30 FPS on mobile battery constraints.  
* **Long Tasks:** The main thread is never blocked for \> 50ms during JSON parsing.  
* **Export Time:** Evidence package generation \< 2.0s.

### **Progressive-Delivery Architecture**

A typical deterministic run can exceed 10,000 events. The Python backend slices the .uai JSON payload into 500-event chunks. These chunks are streamed to the browser using Content-Encoding: br (Brotli) compression for massive bandwidth reduction.  
Crucially, JSON parsing, timeline delta calculations, and cryptographic digest verification occur exclusively inside a dedicated Web Worker. Each chunk includes a SHA-256 hash; the worker verifies this hash to ensure the cryptographic fidelity of the evidence package. If the hash fails, a retry is triggered. Once verified, the worker passes the parsed, ready-to-use array buffer to the main thread via zero-copy transferable objects, keeping the UI perfectly responsive.

## **Design Language and Tokens**

Evulgare’s aesthetic is strictly institutional, rejecting SaaS playfulness and unexplained cyberpunk tropes. The design reflects serious scientific discipline.

### **Design-Token Guidance (Handcrafted CSS Variables)**

CSS  
:root {  
  /\* Surfaces \*/  
  \--ev-surface-base: \#0A0C10; /\* Near-black blue, never pure \#000000 \*/  
  \--ev-surface-panel: \#13161D;  
  \--ev-border\-tech: \#2D3342;  /\* Square technical borders \*/

  /\* Typography \*/  
  \--ev-font\-sans: 'Inter', system-ui, sans-serif;  
  \--ev-font\-mono: 'JetBrains Mono', 'Fira Code', monospace;  
  \--ev-text-primary: \#E2E8F0;  
  \--ev-text-muted: \#94A3B8;

  /\* Semantics \*/  
  \--ev-color\-pass: \#4ADE80; /\* Muted green for supported-within-bounds \*/  
  \--ev-color\-fail: \#F87171; /\* Genuine invalidation red only \*/  
  \--ev-color\-qual: \#FBBF24; /\* Amber for qualification \*/  
  \--ev-color\-accent: \#2DD4BF; /\* Restrained teal/cyan for focus \*/  
    
  /\* Layout \*/  
  \--ev-grid-fine: 1px solid rgba(255, 255, 255, 0.05); /\* Fine grids \*/  
}

### **Visual-Language Rules**

Borders utilize a strict 0px border-radius; generic rounded SaaS cards are prohibited. Monospace typography is mandated for all IDs, hashes, timestamps, API versions, and graph labels to project precision. Decorative gradients are minimized, and weapons glamour imagery is strictly forbidden. Depth is achieved via pure color contrast and 1px fine grids, simulating a flat technical schematic.

## **Analytics and Privacy Recommendation**

In keeping with the institutional security posture of the platform, third-party analytics (e.g., Google Analytics, Mixpanel) and external runtime CDNs are explicitly prohibited. The application will utilize a first-party, self-hosted analytics endpoint built directly into the Flask 3 backend. The vanilla JS client will use the native navigator.sendBeacon() API to transmit anonymized usage data (e.g., route transitions, WebGPU capability support, simulation completion rates) without capturing PII or utilizing tracking cookies.

## **Ten Detailed User Journeys**

> 1. **The Auditor (Guided Mode):** A safety auditor lands on the Explorer, filters by "Guided" mode, and selects the "L3 AD Degradation" scenario6. The UI launches a three-minute tour. The viewport automatically pauses at event 45, where the Proof Inspector highlights a failure (stopping distance \> perception limit6). The auditor clicks export, downloading a reproducible PDF evidence package.  
> 2. **The Analyst (Variant Comparison):** A systems analyst opens a baseline run. In the left panel, they modify the bounded input perception\_range\_m from 30 to 20\. They click "Run Variant." The Python backend computes the new .uai and streams it. The UI splits the screen, and the analyst scrubs the timeline to find the exact millisecond the state vectors diverge.  
> 3. **The Regulator (Authority Trace):** A regulator selects an autonomous braking event. They open the Proof Inspector and click "Research Basis," which opens the linked ISO standard and the specific YAML harness rule driving that exact behavior.  
> 4. **The Developer (Raw Evidence Inspection):** A developer encounters an UNKNOWN state. They click the { } raw-evidence action. The UI overlays the raw JSON .uai.evid payload16 for that event index, which the developer copies for local debugging.  
> 5. **The XR Inspector:** A user connects a VR headset and navigates to Evulgare on a secure HTTPS context8. They click "Enter XR" and physically explore the 3D translucent bounding boxes of an assurance scenario hovering over the holographic table.  
> 6. **The Mobile Executive:** An executive opens a shared link on an iPhone running iOS 26\. The UI dynamically shifts to the stacked mobile view. WebGPU renders the scene smoothly on the Apple Silicon12, while the executive reads the text output synchronized with the graphics.  
> 7. **The Accessibility User (Screen Reader):** A user navigates entirely via keyboard (Tab/Space). The screen reader polite-announces state changes as the user scrubs the timeline. The user successfully understands the constraint failure and exports the evidence package without ever interacting with the WebGPU canvas.  
> 8. **The Offline Analyst:** A user loses internet connection mid-simulation. The browser's Service Worker serves the cached UI shell. The user can still scrub back and forth through the fully downloaded .uai event index without interruption.  
> 9. **The Counterfactual Researcher:** A researcher creates a non-canonical branch, heavily tweaking physical inputs. They run the simulation, and the resulting paradox (irreconcilable constraints) immediately halts the system7. The researcher saves this branch to the tree as a teaching example.  
> 10. **The Slow-Network User:** A user loads the site on a constrained 3G connection. The initial semantic HTML loads instantly. The Web Worker downloads the first 500-event chunk. The UI displays progressive rendering, allowing the user to begin inspecting the first 100 events while the remaining chunks stream in the background.

## **Phased Product Roadmap, Migration, and Rollback**

### **Migration Strategy: The Strangler Fig**

Evulgare will implement the strangler fig pattern. The existing Flask architecture will be maintained, but the current UI will be migrated route-by-route to the new Vanilla JS/Native ES Module structure, eliminating any legacy framework dependencies gradually.

### **Phased Roadmap**

* **Phase 1: Architectural Foundation (Months 1-2):** Establish the strict EventIndex global state manager. Implement the capability-aware graphics pipeline (WebGPU \-\> WebGL2 \-\> HTML) in isolation.  
* **Phase 2: The Proof Inspector & UAI Integration (Months 3-4):** Connect the deterministic Python backend's UAI YAML harnesses7 directly to the new frontend. Deliver the Proof Inspector panel, Causal Path DAG, and the 8 strict status enumerations.  
* **Phase 3: Workbench Unification & Branching (Months 5-6):** Implement state comparison and counterfactual branching. Deliver side-by-side synchronized viewports, entity highlighting, timeline divergence markers, and WebXR integration testing on secure contexts.  
* **Phase 4: Explorer, Content, & Polish (Months 7-8):** Build the top-of-funnel Simulation Explorer. Deliver the 7 Learning Paths, URL filters, and execute the final WCAG 2.2 AA manual human review.

### **Rollback Strategy**

If critical blocking bugs are detected in the leading-edge WebGPU implementation on specific hardware combinations, the vanilla JS feature flag router will automatically fall back to serving the WebGL2 rendering pipeline for those specific User-Agents until the driver issues are resolved.

## **Acceptance Criteria (Definition of Done)**

The "Definition of Done" strictly requires passing automated CI/CD tests, human accessibility audits, and unyielding adherence to the zero-framework Vanilla JS mandate.

| ID | Category | Criterion |
| :---- | :---- | :---- |
| AC-01 | Architecture | UI payload contains exactly 0 bytes of React, Vue, Svelte, or Angular in production. |
| AC-02 | Architecture | Python backend remains the sole authoritative source of truth; no physics are calculated in JS. |
| AC-03 | XR | WebXR button only renders if navigator.xr is natively present and operating in a secure context. |
| AC-04 | XR | WebXR fails gracefully to the 3D desktop view if the session request is rejected by the OS. |
| AC-05 | Graphics | navigator.gpu.requestAdapter()2 failure cleanly cascades to the WebGL2 pipeline. |
| AC-06 | Graphics | GPU Memory is aggressively cleaned using FinalizationRegistry upon scenario branch switch. |
| AC-07 | Graphics | The rendering engine honors the prefers-reduced-motion CSS media query, disabling camera sweeps. |
| AC-08 | Performance | LCP is consistently \< 1.5 seconds on a throttled "Fast 4G" connection profile. |
| AC-09 | Performance | INP is \< 100ms when scrubbing the timeline aggressively across a 10k-event payload. |
| AC-10 | Performance | The main browser thread is never blocked for \> 50ms during background JSON chunk parsing. |
| AC-11 | State | The EventIndex is a single absolute integer driving all UI panel updates simultaneously. |
| AC-12 | State | Clicking a 3D entity on the canvas dispatches a global selection intent rather than mutating local state. |
| AC-13 | UI/UX | Mobile layout possesses no horizontal scrolling and utilizes native dialogs over complex dropdowns. |
| AC-14 | UI/UX | Dark mode utilizes \--ev-surface-base (\#0A0C10); pure black (\#000000) is forbidden to reduce eye strain. |
| AC-15 | UI/UX | Red is exclusively reserved for critical failures or explicit constraint invalidations. |
| AC-16 | UI/UX | Monospace typography is rigorously applied to all hashes, APIs, and graph node IDs. |
| AC-17 | A11y | Site passes automated Axe Core and Lighthouse accessibility scans with a 100% score. |
| AC-18 | A11y | The WebGPU/WebGL \<canvas\> element is explicitly hidden from screen readers (aria-hidden="true"). |
| AC-19 | A11y | ARIA live regions correctly and concisely announce timeline state changes. |
| AC-20 | A11y | The UI is fully legible and functional at 400% browser zoom without overlapping elements. |
| AC-21 | Proof | The Proof Inspector correctly maps the 8 backend status codes (PASS, FAIL, etc.) to distinct SVG icons. |
| AC-22 | Proof | Causal explanations utilize structured facts from the RAD DAG7, never LLM-generated narrative. |
| AC-23 | Compare | The divergence marker accurately flags the exact event index of initial mathematical state separation. |
| AC-24 | Compare | Side-by-side viewports maintain perfectly synchronized orbit camera matrices at all times. |
| AC-25 | Export | PDF export includes a reproducible SHA-256 hash of the baseline simulation configuration. |
| AC-26 | Backend | Flask Jinja templates provide complete semantic HTML for the initial document load before JS hydration. |
| AC-27 | Backend | Caching strategy prevents duplicate backend computation for mathematically identical input variants. |
| AC-28 | Network | .uai payloads are compressed using Brotli (br) encoding over the wire. |
| AC-29 | Network | Cryptographic digest verification passes in the Web Worker before data is allowed to enter the UI state model. |
| AC-30 | Content | Simulation Explorer utilizes URL search parameters to drive all active filters. |
| AC-31 | Content | Guided mode restricts free-roam camera to maintain tight narrative and analytical focus. |
| AC-32 | Content | "Understanding Assurance" learning path is fully populated with 3 baseline scenarios. |
| AC-33 | Content | "Understanding Authority" path links specific YAML constraints directly to mock ISO/regulatory texts. |
| AC-34 | Error | Paradox states immediately halt the timeline and trigger the red warning UI schema. |
| AC-35 | Error | Disabling JavaScript successfully displays the semantic HTML fallback log of events. |
| AC-36 | Security | No third-party NPM dependencies are loaded or executed at runtime. |
| AC-37 | Security | Content Security Policy (CSP) headers strictly prohibit unsafe-eval and unsafe-inline scripts. |
| AC-38 | Privacy | Analytics are entirely self-hosted, generating no external beacons to third-party data brokers. |
| AC-39 | QA | End-to-end Playwright tests successfully verify the causal path DAG rendering logic. |
| AC-40 | QA | Cross-browser tests confirm baseline WebGPU functionality in Chrome, Safari, Edge, and Firefox (2026 builds). |

## **Site-Ready Copy & Documentation**

### **Simulation Explorer Copy**

**Headline:** "Evulgare: The Assurance Simulation Workbench." **Sub-headline:** "Inspect the mathematical boundaries, causal chains, and verifiable proofs governing autonomous decisions." **Guided Mode Call-to-Action:** "Begin three-minute guided inspection."

### **Workbench Overview Copy**

**Panel Header:** "Deterministic Event Log" **Proof Inspector Header:** "Unified Assertion Interface (UAI) Constraints" **State Disclaimer:** "Evulgare visualizes authoritative state computed by the backend service. Visual representations are informational interpolations; the tabular proof log remains the ultimate mathematical authority."

### **Proposed /docs and .uai Paths**

**RESTful API & Local Storage Structures:**

* /explore: The Simulation Explorer landing grid.  
* /workbench/\<sim\_id\>: The primary workbench UI route.  
* /workbench/\<sim\_id\>/branch: The route for initiating a variant branch.  
* /export/\<run\_id\>: Route for generating the PDF evidence package.  
* /api/v1/run/\<sim\_id\>: The Flask endpoint returning the chunked .uai payload.  
* /harness/data/\<sim\_id\>.yaml: The logical path mapping for the backend UAI harness.  
* /harness/data/\<sim\_id\>\_variant.yaml: The logical path for branched input parameters.

## **Traceability & Diagram Specifications**

### **Feature-to-Route Traceability Table**

| Feature | UI Route | API Endpoint | Test Suite | .uai Path Mapping |
| :---- | :---- | :---- | :---- | :---- |
| Explorer Grid | /explore | /api/v1/simulations | tests/e2e/explorer.spec.js | N/A |
| Workbench Core | /workbench/\<sim\_id\> | /api/v1/run/\<sim\_id\> | tests/e2e/workbench.spec.js | /harness/data/\<sim\_id\>.yaml \[cite: 6\] |
| Variant Branch | /workbench/\<sim\_id\>/branch | /api/v1/branch/\<sim\_id\> | tests/unit/branching.spec.js | /harness/data/\<sim\_id\>\_variant.yaml |
| Export Evidence | /export/\<run\_id\> | /api/v1/export/\<run\_id\> | tests/e2e/export.spec.js | .uai.evid payload16 |

### **Diagram Specifications (Mermaid Logic)**

*These specifications are designed to be rendered by any standard Mermaid.js parser embedded within the Evulgare documentation layer.*  
**Diagram 1: The Event-Index State Unidirectional Flow**

Code snippet  
graph TD  
    A\[User/Playback Trigger: Event 17\] \--\> B\[Vanilla JS Global State Manager\]  
    B \--\> C\[3D WebGPU Canvas Update\]  
    B \--\> D\[Textual Log Scroll & Highlight\]  
    B \--\> E\[Proof Inspector UAI Fetch\]  
    B \--\> F\[Timeline Scrubber Sync\]

**Diagram 2: Capability-Aware Graphics Fallback**

Code snippet  
graph TD  
    A\[Initialize Graphics\] \--\> B{WebGPU Supported?}  
    B \-- Yes \--\> C\[Render via Compute Shaders\]  
    B \-- No \--\> D{WebGL2 Supported?}  
    D \-- Yes \--\> E\[Render via WebGL2\]  
    D \-- No \--\> F\[Render via Canvas 2D/SVG\]

**Diagram 3: Progressive Payload Delivery**

Code snippet  
graph LR  
    A\[Flask Backend\] \--\>|Chunk 1 (JSON)| B\[Web Worker\]  
    B \--\>|Verify SHA-256| C{Hash Valid?}  
    C \-- Yes \--\> D\[Merge to State Manager\]  
    C \-- No \--\> E\[Halt & Prompt Refetch\]

**Diagram 4: Context Firewall & RAD DAG**

Code snippet  
graph TD  
    A\[Orchestrator\] \--\> B\[Vision Node\]  
    A \--\> C\[Kinematics Node\]  
    B \-.-\>|Context Firewall Active| C  
    C \--\> D\[UAI Proof Evaluator\]

**Diagram 5: Counterfactual Branching**

Code snippet  
gitGraph  
    commit id: "Baseline"  
    commit id: "Event 10"  
    branch "Variant\_Rain"  
    checkout "Variant\_Rain"  
    commit id: "Modified Input"  
    commit id: "Event 11 (Divergence)"  
    checkout main  
    commit id: "Event 11 (Baseline)"

**Diagram 6: WebXR Initialization**

Code snippet  
graph TD  
    A\[Click 'Enter XR'\] \--\> B{Is Context Secure?}  
    B \-- No \--\> C\[Hide XR Button\]  
    B \-- Yes \--\> D{navigator.xr present?}  
    D \-- No \--\> C  
    D \-- Yes \--\> E\[Launch Immersive Session\]

## **Thirty FAQ Answers**

| \# | Question | Answer |
| :---- | :---- | :---- |
| 1 | What is Evulgare? | An Assurance Simulation Workbench that visualizes the deterministic boundaries of autonomous systems. |
| 2 | Can I change the simulation outcome from the browser? | No. You can alter bounded inputs to create a variant run, but the authoritative Python backend computes the physical outcome. |
| 3 | What is a UAI? | The Unified Assertion Interface is the deterministic framework enforcing domain invariants as machine-readable contracts14. |
| 4 | Why is there no React or Vue used? | To ensure maximum performance, eliminate third-party dependency risk, and guarantee strict adherence to long-term web standards via Vanilla JS. |
| 5 | Does this work on mobile? | Yes. The UI transforms into a stacked layout, and the graphics pipeline degrades to match mobile thermal constraints12. |
| 6 | How is WebGPU supported? | As of 2026, WebGPU is a baseline API in all major browsers (Chrome, Edge, Firefox, Safari)3. |
| 7 | What if my device doesn't support WebGPU? | Evulgare gracefully falls back to WebGL2, WebGL, Canvas, or pure HTML semantic tables. |
| 8 | Can I use a VR headset? | Yes. Supported headsets can enter WebXR mode to view assurance bounding boxes spatially. |
| 9 | Why do I need a secure context for XR? | Browsers restrict advanced features like WebXR and WebGPU to HTTPS or localhost to ensure user security8. |
| 10 | What does 'PASS' mean in the Proof Inspector? | The specific constraint was mathematically verified by the authoritative backend engine. |
| 11 | What causes a 'Paradox' state? | When two non-negotiable constraints (e.g., required stopping distance vs. perception limit) cannot physically both be satisfied6. |
| 12 | Are causal explanations generated by an LLM? | No. They are mapped directly from the Recursive Atomic Decomposition (RAD) DAG7, structurally preventing hallucination. |
| 13 | How do I compare two simulation runs? | Pin the baseline, change an input, and select the side-by-side comparison mode to view synchronized timelines. |
| 14 | What is 'State Locking'? | A mechanism where a verified constraint dimension is frozen mathematically, preventing stochastic regression in subsequent iterations15. |
| 15 | Can I export my findings? | Yes. The system exports a cryptographically hashed, reproducible PDF and JSON evidence package. |
| 16 | Is the 3D visual the absolute source of truth? | No. The visual is an interpolation. The text and table layers serve as the definitive mathematical record. |
| 17 | What is the 'Harness as an Asset'? | It is the version-controlled YAML and Python ruleset defining the non-negotiable invariants of the domain6. |
| 18 | Why is the design so dark and rigid? | The serious, technical design language reflects Evulgare’s institutional purpose, rejecting gamified SaaS tropes. |
| 19 | How fast does the site load? | By utilizing Vanilla ES modules and chunked progressive JSON delivery, initial loads target \< 1.5 seconds. |
| 20 | How are large simulations handled? | Payload chunks are streamed, verified via Web Workers, and merged without blocking the main UI thread. |
| 21 | Is Evulgare accessible to screen readers? | Yes. WCAG 2.2 AA standards are met, with 3D views hidden from screen readers in favor of rich textual event logs. |
| 22 | Can I zoom the interface? | The interface supports up to 400% zoom, reflowing seamlessly into a single column. |
| 23 | How do you handle analytics? | Analytics are privacy-first, fully self-hosted, and require no third-party tracking scripts. |
| 24 | What is 'Guided Mode'? | A curated onboarding path that walks a user to a meaningful deterministic result in under three minutes. |
| 25 | What is 'Expert Mode'? | Unlocks all bounded inputs, branching logic, and raw JSON evidence inspection. |
| 26 | How are dependencies managed? | The frontend relies entirely on native browser APIs, with zero NPM production dependencies. |
| 27 | What dictates camera movement? | The central state manager. Moving to a new event automatically translates the camera to the optimal inspection angle. |
| 28 | Can I disable cinematic motion? | Yes. Honoring the OS prefers-reduced-motion setting will snap cameras instantly instead of interpolating. |
| 29 | What happens during a GPU context loss? | The system silently attempts to rebuild the pipeline, temporarily showing a text/SVG fallback. |
| 30 | How is data shared? | All configurations are encoded in URL parameters, allowing deep-linking directly to a specific event index and visual state. |

## **Glossary of Fifty Terms**

| Term | Definition |
| :---- | :---- |
| **Assertion** | A testable statement regarding system state. |
| **Assurance** | The verified confidence that a system operates within its defined safety bounds. |
| **Authority** | The permission model dictating system actions. |
| **Baseline** | The immutable, original reference simulation run. |
| **Bounded Input** | A parameter that can be safely modified by the user within predetermined limits. |
| **Branching** | Creating a counterfactual multiverse simulation based on modified inputs. |
| **CAAF** | Convergent AI Agent Framework; a theoretical underpinning for deterministic AI bounding6. |
| **Causal Path** | The exact chain of events leading from input to outcome. |
| **Constraint** | A physical or logical limit on system behavior. |
| **Context Firewall** | Isolating execution contexts to prevent constraint contamination across nodes6. |
| **Counterfactual** | A "what if" scenario generated by altering historical variables. |
| **DAG** | Directed Acyclic Graph; used for modeling causal chains mathematically. |
| **Defeater** | A condition that, if true, invalidates a proof (e.g., sensor failure). |
| **Determinism** | The principle that identical inputs always yield identical outputs. |
| **Event Index** | The single absolute integer driving all synchronized UI states simultaneously. |
| **Evidence** | Sensor data or telemetry proving a claim. |
| **Evulgare** | Latin for "to make public"; the namesake of the platform. |
| **Fallback** | Gracefully degrading features (e.g., WebGPU to WebGL2) based on hardware capability. |
| **Harness** | The versioned YAML file defining domain invariants6. |
| **Interpolation** | Calculating intermediate visual states for smooth rendering between discrete events. |
| **Jinja** | The templating engine utilized by Flask to serve semantic HTML. |
| **JSON** | JavaScript Object Notation; the data format for evidence packages. |
| **Kinematics** | The branch of mechanics describing motion, often evaluated in vehicle simulations. |
| **Latency** | The delay between a user action and system response. |
| **LCP** | Largest Contentful Paint; a core web vital metric targeting \< 1.5s. |
| **INP** | Interaction to Next Paint; a core web vital metric targeting \< 100ms. |
| **Monolithic** | A system architecture where components are tightly coupled (avoided here). |
| **Paradox** | An irreconcilable physical conflict between two strict constraints13. |
| **Progressive Delivery** | Streaming data in chunks to speed up perceived load times via Web Workers. |
| **Provenance** | The verifiable origin and history of a piece of data. |
| **RAD** | Recursive Atomic Decomposition; breaking complex tasks into isolated sub-tasks7. |
| **Reflow** | The UI's ability to rearrange itself gracefully under 400% zoom. |
| **Resilience** | A system's ability to recover from unexpected failures deterministically. |
| **RTDB** | Real-Time Database; used for high-speed simulation data mapping9. |
| **Semantic HTML** | Using correct tags (e.g., \<article\>, \<footer\>) to imply meaning, crucial for WCAG 2.2. |
| **SSE** | Server-Sent Events; unidirectional data streaming from the backend to the browser. |
| **State Locking** | Freezing a verified dimension to prevent regression during computation6. |
| **Stochastic** | Having a random probability distribution; the opposite of deterministic. |
| **Strangler Fig Pattern** | A strategy for gradually refactoring a legacy system route-by-route. |
| **Telemetry** | The automated communications process by which measurements are collected. |
| **Topology** | The mathematical study of properties preserved through deformations; used in DAG routing. |
| **UAI** | Unified Assertion Interface; the semantic-to-physical transducer6. |
| **Uncertainty** | The quantifiable margin of error in a system's worldview. |
| **Vanilla JS** | Pure JavaScript without external frameworks like React or Vue. |
| **Variant** | A simulation run derived from a baseline with modified inputs. |
| **Viewport** | The area of the UI dedicated to WebGPU visual graphics rendering. |
| **WCAG** | Web Content Accessibility Guidelines. |
| **WebGPU** | A modern web API providing low-level access to system GPUs4. |
| **Web Worker** | A background script that runs independently of the main UI thread. |
| **WebXR** | A web API for creating virtual and augmented reality experiences8. |
| **YAML** | A human-readable data serialization language used for configuration harnesses7. |

## **Known Reality-Gap Qualifications**

In strict adherence to the mandate that visual representations do not independently decide canonical history, the following "Reality-Gap" qualifications must be documented within the product's help center and developer documentation. The UI must ensure users understand what the simulation proves and what it does not prove.

> 1. **Visual Interpolation is Not Physics:** While the WebGPU engine is budgeted to run at 60 FPS, the backend UAI engine may only calculate authoritative state at 10 Hz (10 FPS). The smooth visual movement between events 17 and 18 is an interpolation (a "Reality-Gap"). The Proof Inspector only evaluates at exact event indices; anything between indices is a visual artifact, not a physical proof.  
> 2. **Geospatial Projections vs. Float64 Math:** 3D coordinate mapping on a curved earth representation requires localized flat-plane visual approximations in WebGL/WebGPU. Micro-deviations in the rendering of bounding boxes on screen do not reflect errors in the underlying float64 backend mathematical evaluation. The backend math is absolute.  
> 3. **Sensor Cones are Idealized:** Visualizing LIDAR or Radar point clouds in the 3D viewport often involves aggressive sub-sampling (decimation) for browser performance. The "EVIDENCE" layer shows this decimated representation; however, the true assertion evaluation by the UAI operates on the full, raw dataset.  
> 4. **Network Latency Abstraction:** Network latency between the browser and the Flask backend can cause UI loading states (e.g., waiting for a variant branch to compute). This UI latency is artificially disjointed from the simulated time-clock of the autonomous scenario and does not represent processing delay within the simulated autonomous agent.

#### **Works cited**

> 1. Latin Definition for: evulgo, evulgare, evulgavi, evulgatus (ID: 19544\) \- Latin Dictionary and Grammar Resources \- Latdict, [https://latin-dictionary.net/definition/19544/evulgo-evulgare-evulgavi-evulgatus](https://latin-dictionary.net/definition/19544/evulgo-evulgare-evulgavi-evulgatus)  
> 2. WebGPU: Browser Support, Features, Limitations \- TestMu AI, [https://www.testmuai.com/learning-hub/webgpu-browser-support/](https://www.testmuai.com/learning-hub/webgpu-browser-support/)  
> 3. WebGPU Just Hit Baseline in Every Major Browser. Three.js Is Already Shipping It and WebXR Is the Real Winner. | VR.org, [https://vr.org/articles/webgpu-baseline-2026-three-js-webxr-default](https://vr.org/articles/webgpu-baseline-2026-three-js-webxr-default)  
> 4. WebGPU API \- MDN Web Docs \- Mozilla, [https://developer.mozilla.org/en-US/docs/Web/API/WebGPU\_API](https://developer.mozilla.org/en-US/docs/Web/API/WebGPU_API)  
> 5. WebGPU | Can I use... Support tables for HTML5, CSS3, etc \- CanIUse, [https://caniuse.com/webgpu](https://caniuse.com/webgpu)  
> 6. Harness as an Asset: Enforcing Determinism via the Convergent AI Agent Framework (CAAF) \- arXiv, [https://arxiv.org/html/2604.17025v1](https://arxiv.org/html/2604.17025v1)  
> 7. GitHub \- TianbaoZhang001/OpenCAAF: Reference implementation of CAAF — three-pillar agent framework with monotonic convergence., [https://github.com/TianbaoZhang001/OpenCAAF](https://github.com/TianbaoZhang001/OpenCAAF)  
> 8. teleoperator-mcp/docs/WEBXR.md at master · sandraschi ... \- GitHub, [https://github.com/sandraschi/teleoperator-mcp/blob/master/docs/WEBXR.md](https://github.com/sandraschi/teleoperator-mcp/blob/master/docs/WEBXR.md)  
> 9. SIMulation Workbench \- Real-time Linux simulation, control, and test software \- Third-Party Products & Services \- MATLAB & Simulink \- MathWorks, [https://www.mathworks.com/products/connections/product\_detail/concurrent-simulation-workbench.html](https://www.mathworks.com/products/connections/product_detail/concurrent-simulation-workbench.html)  
> 10. SIMulation Workbench License Center, [https://license.simwb.com/](https://license.simwb.com/)  
> 11. SimWB PYToolkit \- SIMulation Workbench License Center, [https://license.simwb.com/simwbdoc/UserManuals/PYToolkit/help.html](https://license.simwb.com/simwbdoc/UserManuals/PYToolkit/help.html)  
> 12. WebGPU is now supported in major browsers | Blog \- web.dev, [https://web.dev/blog/webgpu-supported-major-browsers](https://web.dev/blog/webgpu-supported-major-browsers)  
> 13. Harness as an Asset: Enforcing Determinism via the Convergent AI Agent Framework (CAAF) \- arXiv, [https://arxiv.org/pdf/2604.17025](https://arxiv.org/pdf/2604.17025)  
> 14. \[2604.17025\] Harness as an Asset: Enforcing Determinism via the Convergent AI Agent Framework (CAAF) \- arXiv, [https://arxiv.org/abs/2604.17025](https://arxiv.org/abs/2604.17025)  
> 15. Harness as an Asset: Enforcing Determinism via the Convergent AI Agent Framework (CAAF) \- arXiv, [https://arxiv.org/html/2604.17025v3](https://arxiv.org/html/2604.17025v3)  
> 16. hcui01/AGS: The algebraic gradient solver (AGS) implementation for NeurIPS 2018 paper \- GitHub, [https://github.com/hcui01/AGS](https://github.com/hcui01/AGS)